').html(data.forecast).text();
data.forecast = data.forecast.trim();
data.pressunit = data.pressunit.trim();
if (data.pressunit === 'in') {
data.pressunit = 'inHg';
}
data.windunit = data.windunit.trim();
data.windunit = data.windunit.toLowerCase();
if (data.windunit === 'knots') {
data.windunit = 'kts';
}
if (data.windunit === 'kmh' || data.windunit === 'kph') {
data.windunit = 'km/h';
}
data.rainunit = data.rainunit.trim();
try {
if (data.cloudbaseunit.toLowerCase() === 'metres') {
data.cloudbaseunit = 'm';
} else if (data.cloudbaseunit.toLowerCase() === 'feet') {
data.cloudbaseunit = 'ft';
}
} catch (e) {
data.cloudbaseunit = '';
}
if (config.showCloudGauge && (
(config.weatherProgram === 4 || config.weatherProgram === 5) ||
data.cloudbasevalue === '')) {
data.cloudbaseunit = (data.windunit === 'mph' || data.windunit === 'kts') ? 'ft' : 'm';
data.cloudbasevalue = calcCloudbase(data.temp, data.tempunit, data.dew, data.cloudbaseunit);
}
if (data.tempunit[1] !== displayUnits.temp && userUnitsSet) {
if (data.tempunit[1] === 'C') {
convTempData(c2f);
} else {
convTempData(f2c);
}
} else if (firstRun) {
displayUnits.temp = data.tempunit[1];
setRadioCheck('rad_unitsTemp', displayUnits.temp);
}
if (data.rainunit !== displayUnits.rain && userUnitsSet) {
convRainData(displayUnits.rain === 'mm' ? in2mm : mm2in);
} else if (firstRun) {
displayUnits.rain = data.rainunit;
setRadioCheck('rad_unitsRain', displayUnits.rain);
}
if (data.windunit !== displayUnits.wind && userUnitsSet) {
convWindData(data.windunit, displayUnits.wind);
} else if (firstRun) {
displayUnits.wind = data.windunit;
displayUnits.windrun = getWindrunUnits(data.windunit);
setRadioCheck('rad_unitsWind', displayUnits.wind);
}
if (data.pressunit !== displayUnits.press && userUnitsSet) {
convBaroData(data.pressunit, displayUnits.press);
} else if (firstRun) {
displayUnits.press = data.pressunit;
setRadioCheck('rad_unitsPress', displayUnits.press);
}
if (data.cloudbaseunit !== displayUnits.cloud && userUnitsSet) {
convCloudBaseData(displayUnits.cloud === 'm' ? ft2m : m2ft);
} else if (firstRun) {
displayUnits.cloud = data.cloudbaseunit;
setRadioCheck('rad_unitsCloud', displayUnits.cloud);
}
statusScroller.setText(data.forecast);
if (firstRun) {
doFirst();
}
$.publish('gauges.dataUpdated', {});
retVal = true;
} else {
if (data.ver < realtimeVer) {
statusTimer.setValue(0);
statusScroller.setText('Your ' + config.realTimeURL.substr(config.realTimeURL.lastIndexOf('/') + 1) + ' file template needs updating!');
return false;
} else {
statusScroller.setText(strings.realtimeCorrupt);
}
ledIndicator.setLedOnOff(false);
ledIndicator.setTitle(strings.led_title_unknown);
retVal = false;
}
return retVal;
},
//
// pagetimeout() called once every config.pageUpdateLimit minutes to stop updates and prevent page 'sitters'
//
pageTimeout = function () {
statusScroller.setText(strings.StatusPageLimit);
ledIndicator.setLedColor(steelseries.LedColor.RED_LED);
ledIndicator.setTitle(strings.StatusPageLimit);
ledIndicator.blink(true);
ledIndicator.setTitle(strings.StatusTimeout);
clearTimeout(downloadTimer);
if ($.active > 0) {
jqXHR.abort();
}
clearInterval(tickTockInterval);
statusTimer.setValue(0);
$('#canvas_led').click(
function click() {
$('#canvas_led').unbind('click');
statusTimer.reset(1);
tickTockInterval = setInterval(
function tick() {
$.publish('gauges.clockTick', null);
},
1000
);
setTimeout(pageTimeout, config.pageUpdateLimit * 60 * 1000);
getRealtime();
}
);
},
//
// doFirst() called by doUpdate() the first time the page is updated to set-up various things that are
// only known when the realtimegauges.txt data is available
//
doFirst = function () {
var cacheDefeat = '?' + (new Date()).getTime().toString();
if (data.tempunit[1] === 'F') {
displayUnits.temp = 'F';
setRadioCheck('rad_unitsTemp', 'F');
setTempUnits(false);
}
if (data.pressunit !== 'hPa') {
displayUnits.press = data.pressunit;
setRadioCheck('rad_unitsPress', data.pressunit);
setBaroUnits(data.pressunit);
}
if (data.windunit !== 'km/h') {
displayUnits.wind = data.windunit;
setRadioCheck('rad_unitsWind', data.windunit);
setWindUnits(data.windunit);
}
if (data.rainunit !== 'mm') {
displayUnits.rain = data.rainunit;
setRadioCheck('rad_unitsRain', data.rainunit);
setRainUnits(false);
}
if (config.showSolarGauge && typeof data.SolarTM !== 'undefined' && gaugeSolar) {
gaugeSolar.gauge.setMaxMeasuredValueVisible(true);
}
if (config.showCloudGauge && data.cloudbaseunit !== 'm') {
displayUnits.cloud = data.cloudbaseunit;
setRadioCheck('rad_unitsCloud', data.cloudbaseunit);
setCloudBaseUnits(false);
}
$('#scriptVer').html(config.scriptVer);
$('#programVersion').html(data.version);
$('#programBuild').html(data.build);
$('#programName').html(programLink[config.weatherProgram]);
if (config.showPopupData) {
ddimgtooltip.init('[id^="tip_"]');
if ($(window).width() < 480) {
$('.ddimgtooltip').filter(':hidden').width('200px');
}
}
if (config.showPopupData && config.showPopupGraphs) {}
firstRun = false;
},
//
// createTempSections() creates an array of gauge sections appropriate for Celsius or Fahrenheit scales
//
createTempSections = function (celsius) {
var section;
if (celsius) {
section = [
steelseries.Section(-100, -35, 'rgba(0, 23, 128, 0.6)'),
steelseries.Section(-35, -30, 'rgba(0, 35, 189, 0.6)'),
steelseries.Section(-30, -25, 'rgba(0, 44, 240, 0.6)'),
steelseries.Section(-25, -20, 'rgba(15, 59, 255, 0.6)'),
steelseries.Section(-20, -15, 'rgba(92, 122, 255, 0.6)'),
steelseries.Section(-15, -10, 'rgba(61, 97, 255, 0.6)'),
steelseries.Section(-10, -5, 'rgba(102, 130, 255, 0.6)'),
steelseries.Section(-5, -1, 'rgba(138, 159, 255, 0.6)'),
steelseries.Section(-1, 1, 'rgba(255, 255, 255, 0.6)'),
steelseries.Section(1, 5, 'rgba(222, 211, 211, 0.6)'),
steelseries.Section(5, 10, 'rgba(227, 206, 206, 0.6)'),
steelseries.Section(10, 15, 'rgba(212, 175, 175, 0.6)'),
steelseries.Section(15, 20, 'rgba(209, 143, 143, 0.6)'),
steelseries.Section(20, 25, 'rgba(233, 83, 83, 0.6)'),
steelseries.Section(25, 30, 'rgba(217, 28, 28, 0.6)'),
steelseries.Section(30, 40, 'rgba(172, 22, 22, 0.6)'),
steelseries.Section(40, 100, 'rgba(113, 15, 15, 0.6)')
];
} else {
section = [
steelseries.Section(-200, -30, 'rgba(0, 23, 128, 0.6)'),
steelseries.Section(-30, -25, 'rgba(0, 35, 189, 0.6)'),
steelseries.Section(-25, -15, 'rgba(0, 44, 240, 0.6)'),
steelseries.Section(-15, -5, 'rgba(15, 59, 255, 0.6)'),
steelseries.Section(-5, 5, 'rgba(61, 97, 255, 0.6)'),
steelseries.Section(5, 15, 'rgba(102, 130, 255, 0.6)'),
steelseries.Section(15, 25, 'rgba(138, 159, 255, 0.6)'),
steelseries.Section(25, 30, 'rgba(179, 193, 255, 0.6)'),
steelseries.Section(30, 34, 'rgba(255, 255, 255, 0.6)'),
steelseries.Section(32, 40, 'rgba(222, 211, 211, 0.6)'),
steelseries.Section(40, 50, 'rgba(227, 206, 206, 0.6)'),
steelseries.Section(50, 60, 'rgba(212, 175, 175, 0.6)'),
steelseries.Section(60, 70, 'rgba(209, 143, 143, 0.6)'),
steelseries.Section(70, 80, 'rgba(233, 83, 83, 0.6)'),
steelseries.Section(80, 90, 'rgba(217, 28, 28, 0.6)'),
steelseries.Section(90, 110, 'rgba(172, 22, 22, 0.6)'),
steelseries.Section(110, 200, 'rgba(113, 15, 15, 0.6)')
];
}
return section;
},
//
// createRainSections() returns an array of section highlights for the Rain Rate gauge
//
/*
Assumes 'standard' descriptive limits from UK met office:
< 0.25 mm/hr - Very light rain
0.25mm/hr to 1.0mm/hr - Light rain
1.0 mm/hr to 4.0 mm/hr - Moderate rain
4.0 mm/hr to 16.0 mm/hr - Heavy rain
16.0 mm/hr to 50 mm/hr - Very heavy rain
> 50.0 mm/hour - Extreme rain
Roughly translated to the corresponding Inch rates
< 0.001
0.001 to 0.05
0.05 to 0.20
0.20 to 0.60
0.60 to 2.0
> 2.0
*/
createRainRateSections = function (metric) {
var factor = metric ? 1 : 1 / 25;
return [steelseries.Section(0, 0.25 * factor, 'rgba(203, 231, 255, 0.5)'),
steelseries.Section(0.25 * factor, 1 * factor, 'rgba(130, 214, 255, 0.5)'),
steelseries.Section(1 * factor, 4 * factor, 'rgba(80, 117, 212, 0.5)'),
steelseries.Section(4 * factor, 16 * factor, 'rgba(45, 75, 235, 0.68)'),
steelseries.Section(16 * factor, 50 * factor, 'rgba(22, 45, 201, 0.8)'),
steelseries.Section(50 * factor, 1000 * factor, 'rgba(36, 0, 255, 0.92)')];
},
//
// createRainFallSections()returns an array of section highlights for total rainfall in mm or inches
//
createRainfallSections = function (metric) {
var factor = metric ? 1 : 1 / 25;
return [steelseries.Section(0, 5 * factor, 'rgba(0, 250, 0, 1)'),
steelseries.Section(5 * factor, 10 * factor, 'rgba(0, 250, 117, 1)'),
steelseries.Section(10 * factor, 25 * factor, 'rgba(218, 246, 0, 1)'),
steelseries.Section(25 * factor, 40 * factor, 'rgba(250, 186, 0, 1)'),
steelseries.Section(40 * factor, 50 * factor, 'rgba(250, 95, 0, 1)'),
steelseries.Section(50 * factor, 65 * factor, 'rgba(250, 0, 0, 1)'),
steelseries.Section(65 * factor, 75 * factor, 'rgba(250, 6, 80, 1)'),
steelseries.Section(75 * factor, 100 * factor, 'rgba(205, 18, 158, 1)'),
steelseries.Section(100 * factor, 125 * factor, 'rgba(0, 0, 250, 1)'),
steelseries.Section(125 * factor, 500 * factor, 'rgba(0, 219, 212, 1)')];
},
//
// createRainfallGradient() returns an array of SS colours for continuous gradient colouring of the total rainfall LED gauge
//
createRainfallGradient = function (metric) {
var grad = new steelseries.gradientWrapper(
0,
(metric ? 100 : 4),
[0, 0.1, 0.62, 1],
[new steelseries.rgbaColor(15, 148, 0, 1),
new steelseries.rgbaColor(213, 213, 0, 1),
new steelseries.rgbaColor(213, 0, 25, 1),
new steelseries.rgbaColor(250, 0, 0, 1)]
);
return grad;
},
//
// createClousBaseSections() returns an array of section highlights for the Cloud Base gauge
//
createCloudBaseSections = function (metric) {
var section;
if (metric) {
section = [steelseries.Section(0, 150, 'rgba(245, 86, 59, 0.5)'),
steelseries.Section(150, 300, 'rgba(225, 155, 105, 0.5)'),
steelseries.Section(300, 750, 'rgba(212, 203, 109, 0.5)'),
steelseries.Section(750, 1000, 'rgba(150, 203, 150, 0.5)'),
steelseries.Section(1000, 1500, 'rgba(80, 192, 80, 0.5)'),
steelseries.Section(1500, 2500, 'rgba(0, 140, 0, 0.5)'),
steelseries.Section(2500, 5500, 'rgba(19, 103, 186, 0.5)')];
} else {
section = [steelseries.Section(0, 500, 'rgba(245, 86, 59, 0.5)'),
steelseries.Section(500, 1000, 'rgba(225, 155, 105, 0.5)'),
steelseries.Section(1000, 2500, 'rgba(212, 203, 109, 0.5)'),
steelseries.Section(2500, 3500, 'rgba(150, 203, 150, 0.5)'),
steelseries.Section(3500, 5500, 'rgba(80, 192, 80, 0.5)'),
steelseries.Section(5500, 8500, 'rgba(0, 140, 0, 0.5)'),
steelseries.Section(8500, 18000, 'rgba(19, 103, 186, 0.5)')];
}
return section;
},
//
//--------------- Helper functions ------------------
//
//
// getord() converts a value in degrees (0-360) into a localised compass point (N, ENE, NE, etc)
//
getord = function (deg) {
if (deg === 0) {
// Special case, 0=No wind, 360=North
return strings.calm;
} else {
return (strings.coords[Math.floor((deg + 11.25) / 22.5) % 16]);
}
},
//
// getUrlParam() extracts the named parameter from the current page URL
//
getUrlParam = function (paramName) {
var name, regexS, regex, results;
name = paramName.replace(/(\[|\])/g, '\\$1');
regexS = '[\\?&]' + name + '=([^&#]*)';
regex = new RegExp(regexS);
results = regex.exec(window.location.href);
if (results === null) {
return '';
} else {
return results[1];
}
},
//
// extractDecimal() returns a decimal number from a string, the decimal point can be either a dot or a comma
// it ignores any text such as pre/appended units
//
extractDecimal = function (str, errVal) {
try {
return (/[\-+]?[0-9]+\.?[0-9]*/).exec(str.replace(',', '.'))[0];
} catch (e) {
// error condition
return errVal || -9999;
}
},
//
// extractInteger() returns an integer from a string
// it ignores any text such as pre/appended units
//
extractInteger = function (str, errVal) {
try {
return (/[\-+]?[0-9]+/).exec(str)[0];
} catch (e) {
// error condition
return errVal || -9999;
}
},
//
// tempTrend() converts a temperature trend value into a localised string, or +1, 0, -1 depending on the value of bTxt
//
tempTrend = function (trend, units, bTxt) {
// Scale is over 3 hours, in Celsius
var val = trend * 3 * (units[1] === 'C' ? 1 : (5 / 9)),
ret;
if (trend === -9999) {
ret = (bTxt ? '--' : trend);
} else if (val > 5) {
ret = (bTxt ? strings.RisingVeryRapidly : 1);
} else if (val > 3) {
ret = (bTxt ? strings.RisingQuickly : 1);
} else if (val > 1) {
ret = (bTxt ? strings.Rising : 1);
} else if (val > 0.5) {
ret = (bTxt ? strings.RisingSlowly : 1);
} else if (val >= -0.5) {
ret = (bTxt ? strings.Steady : 0);
} else if (val >= -1) {
ret = (bTxt ? strings.FallingSlowly : -1);
} else if (val >= -3) {
ret = (bTxt ? strings.Falling : -1);
} else if (val >= -5) {
ret = (bTxt ? strings.FallingQuickly : -1);
} else {
ret = (bTxt ? strings.FallingVeryRapidly : -1);
}
return ret;
},
//
// baroTrend() converts a pressure trend value into a localised string, or +1, 0, -1 depending on the value of bTxt
//
baroTrend = function (trend, units, bTxt) {
var val = trend * 3,
ret;
if (units === 'inHg') {
val *= 33.8639;
} else if (units === 'kPa') {
val *= 10;
}
if (trend === -9999) {
ret = (bTxt ? '--' : trend);
} else if (val > 6.0) {
ret = (bTxt ? strings.RisingVeryRapidly : 1);
} else if (val > 3.5) {
ret = (bTxt ? strings.RisingQuickly : 1);
} else if (val > 1.5) {
ret = (bTxt ? strings.Rising : 1);
} else if (val > 0.1) {
ret = (bTxt ? strings.RisingSlowly : 1);
} else if (val >= -0.1) {
ret = (bTxt ? strings.Steady : 0);
} else if (val >= -1.5) {
ret = (bTxt ? strings.FallingSlowly : -1);
} else if (val >= -3.5) {
ret = (bTxt ? strings.Falling : -1);
} else if (val >= -6.0) {
ret = (bTxt ? strings.FallingQuickly : -1);
} else {
ret = (bTxt ? strings.FallingVeryRapidly : -1);
}
return ret;
},
//
// getMinTemp() returns the lowest temperature today for gauge scaling
//
getMinTemp = function (deflt) {
return Math.min(
extractDecimal(data.tempTL, deflt),
extractDecimal(data.dewpointTL, deflt),
extractDecimal(data.apptempTL, deflt));
},
//
// getMaxTemp() returns the highest temperature today for gauge scaling
//
getMaxTemp = function (deflt) {
return Math.max(
extractDecimal(data.tempTH, deflt),
extractDecimal(data.apptempTH, deflt));
},
c2f = function c2f(val) {
return (extractDecimal(val) * 9 / 5 + 32).toFixed(1);
},
f2c = function f2c(val) {
return ((extractDecimal(val) - 32) * 5 / 9).toFixed(1);
},
mph2ms = function mph2ms(val) {
return (extractDecimal(val) * 0.447).toFixed(1);
},
kts2ms = function kts2ms(val) {
return (extractDecimal(val) * 0.515).toFixed(1);
},
kmh2ms = function kmh2ms(val) {
return (extractDecimal(val) * 0.2778).toFixed(1);
},
ms2kts = function ms2kts(val) {
return (extractDecimal(val) * 1.9426).toFixed(1);
},
ms2mph = function ms2mph(val) {
return (extractDecimal(val) * 2.237).toFixed(1);
},
ms2kmh = function ms2kmh(val) {
return (extractDecimal(val) * 3.6).toFixed(1);
},
mm2in = function mm2in(val) {
return (extractDecimal(val) / 25.4).toFixed(2);
},
in2mm = function in2mm(val) {
return (extractDecimal(val) * 25.4).toFixed(1);
},
miles2km = function miles2km(val) {
return (extractDecimal(val) * 1.609344).toFixed(1);
},
nmiles2km = function nmiles2km(val) {
return (extractDecimal(val) * 1.85200).toFixed(1);
},
km2miles = function km2miles(val) {
return (extractDecimal(val) / 1.609344).toFixed(1);
},
km2nmiles = function km2nmiles(val) {
return (extractDecimal(val) / 1.85200).toFixed(1);
},
hpa2inhg = function hpa2inhg(val, decimals) {
return (extractDecimal(val) * 0.029528744).toFixed(decimals || 3);
},
inhg2hpa = function inhg2hpa(val) {
return (extractDecimal(val) / 0.029528744).toFixed(1);
},
kpa2hpa = function kpa2hpa(val) {
return (extractDecimal(val) * 10).toFixed(1);
},
hpa2kpa = function hpa2kpa(val, decimals) {
return (extractDecimal(val) / 10).toFixed(decimals || 2);
},
m2ft = function m2ft(val) {
return (val * 3.2808399).toFixed(0);
},
ft2m = function ft2m(val) {
return (val / 3.2808399).toFixed(0);
},
//
// setCookie() writes the 'obj' in cookie 'name' for persistent storage
//
setCookie = function (name, obj) {
var date = new Date(),
expires;
date.setYear(date.getFullYear() + 1);
expires = '; expires=' + date.toGMTString();
document.cookie = name + '=' + encodeURIComponent(JSON.stringify(obj)) + expires;
},
//
// getCookie() reads the value of cookie 'name' from persistent storage
//
getCookie = function (name) {
var i, x, y,
ret = null,
arrCookies = document.cookie.split(';');
for (i = arrCookies.length; i--;) {
x = arrCookies[i].split('=');
if (x[0].trim() === name) {
try {
y = decodeURIComponent(x[1]);
} catch (e) {
y = x[1];
}
ret = JSON.parse(unescape(y));
break;
}
}
return ret;
},
//
// setRadioCheck() sets the desired value of the HTML radio buttons to be selected
//
setRadioCheck = function (obj, val) {
$('input:radio[name="' + obj + '"]').filter('[value="' + val + '"]').prop('checked', true);
},
//
// convTempData() converts all the temperature values using the supplied conversion function
//
convTempData = function (convFunc) {
data.apptemp = convFunc(data.apptemp);
data.apptempTH = convFunc(data.apptempTH);
data.apptempTL = convFunc(data.apptempTL);
data.dew = convFunc(data.dew);
data.dewpointTH = convFunc(data.dewpointTH);
data.dewpointTL = convFunc(data.dewpointTL);
data.heatindex = convFunc(data.heatindex);
data.heatindexTH = convFunc(data.heatindexTH);
data.humidex = convFunc(data.humidex);
data.intemp = convFunc(data.intemp);
data.temp = convFunc(data.temp);
data.tempTH = convFunc(data.tempTH);
data.tempTL = convFunc(data.tempTL);
data.wchill = convFunc(data.wchill);
data.wchillTL = convFunc(data.wchillTL);
if (convFunc === c2f) {
data.temptrend = (+extractDecimal(data.temptrend) * 9 / 5).toFixed(1);
data.tempunit = '°F';
} else {
data.temptrend = (+extractDecimal(data.temptrend) * 5 / 9).toFixed(1);
data.tempunit = '°C';
}
},
//
// convRainData() converts all the rain data units using the supplied conversion function
//
convRainData = function (convFunc) {
data.rfall = convFunc(data.rfall);
data.rrate = convFunc(data.rrate);
data.rrateTM = convFunc(data.rrateTM);
data.hourlyrainTH = convFunc(data.hourlyrainTH);
data.rainunit = convFunc === mm2in ? 'in' : 'mm';
},
//
// convWindData() converts all the wind values using the supplied conversion function
//
convWindData = function (from, to) {
var fromFunc1, toFunc1,
fromFunc2, toFunc2,
dummy = function (val) {
return val;
};
// convert to m/s & km
switch (from) {
case 'mph':
fromFunc1 = mph2ms;
fromFunc2 = miles2km;
break;
case 'kts':
fromFunc1 = kts2ms;
fromFunc2 = nmiles2km;
break;
case 'km/h':
fromFunc1 = kmh2ms;
fromFunc2 = dummy;
break;
case 'm/s':
// falls through
default:
fromFunc1 = dummy;
fromFunc2 = dummy;
}
// conversion function from km to required units
switch (to) {
case 'mph':
toFunc1 = ms2mph;
toFunc2 = km2miles;
displayUnits.windrun = 'miles';
break;
case 'kts':
toFunc1 = ms2kts;
toFunc2 = km2nmiles;
displayUnits.windrun = 'n.miles';
break;
case 'km/h':
toFunc1 = ms2kmh;
toFunc2 = dummy;
displayUnits.windrun = 'km';
break;
case 'm/s':
default:
toFunc1 = dummy;
toFunc2 = dummy;
displayUnits.windrun = 'km';
}
data.wgust = toFunc1(fromFunc1(data.wgust));
data.wgustTM = toFunc1(fromFunc1(data.wgustTM));
data.windTM = toFunc1(fromFunc1(data.windTM));
data.windrun = toFunc2(fromFunc2(data.windrun));
data.wlatest = toFunc1(fromFunc1(data.wlatest));
data.wspeed = toFunc1(fromFunc1(data.wspeed));
data.windunit = to;
},
//
// convBaroData() converts all the pressure values using the supplied conversion function
//
convBaroData = function (from, to) {
var fromFunc, toFunc,
dummy = function (val) {
return val;
};
switch (from) {
case 'hPa':
case 'mb':
fromFunc = dummy;
break;
case 'inHg':
fromFunc = inhg2hpa;
break;
case 'kPa':
fromFunc = kpa2hpa;
break;
}
switch (to) {
case 'hPa':
case 'mb':
toFunc = dummy;
break;
case 'inHg':
toFunc = hpa2inhg;
break;
case 'kPa':
toFunc = hpa2kpa;
break;
}
data.press = toFunc(fromFunc(data.press));
data.pressH = toFunc(fromFunc(data.pressH));
data.pressL = toFunc(fromFunc(data.pressL));
data.pressTH = toFunc(fromFunc(data.pressTH));
data.pressTL = toFunc(fromFunc(data.pressTL));
data.presstrendval = toFunc(fromFunc(data.presstrendval), 3);
data.pressunit = to;
},
//
// convCloudBaseData() converts all the cloud base data units using the supplied conversion function
//
convCloudBaseData = function (convFunc) {
data.cloudbasevalue = convFunc(data.cloudbasevalue);
data.cloudbaseunit = convFunc === m2ft ? 'ft' : 'm';
},
//
// setUnits() Main data conversion routine, calls all the setXXXX() sub-routines
//
setUnits = function (radio) {
var sel = radio.value;
userUnitsSet = true;
switch (sel) {
// == Temperature ==
case 'C':
displayUnits.temp = sel;
if (data.tempunit[1] !== sel) {
setTempUnits(true);
convTempData(f2c);
if (gaugeTemp) {gaugeTemp.update();}
if (gaugeDew) {gaugeDew.update();}
}
break;
case 'F':
displayUnits.temp = sel;
if (data.tempunit[1] !== sel) {
setTempUnits(false);
convTempData(c2f);
if (gaugeTemp) {gaugeTemp.update();}
if (gaugeDew) {gaugeDew.update();}
}
break;
// == Rainfall ==
case 'mm':
displayUnits.rain = sel;
if (data.rainunit !== sel) {
setRainUnits(true);
convRainData(in2mm);
if (gaugeRain) {gaugeRain.update();}
if (gaugeRRate) {gaugeRRate.update();}
}
break;
case 'in':
displayUnits.rain = sel;
if (data.rainunit !== sel) {
setRainUnits(false);
convRainData(mm2in);
if (gaugeRain) {gaugeRain.update();}
if (gaugeRRate) {gaugeRRate.update();}
}
break;
// == Pressure ==
case 'hPa':
// falls through
case 'inHg':
// falls through
case 'mb':
// falls through
case 'kPa':
displayUnits.press = sel;
if (data.pressunit !== sel) {
convBaroData(data.pressunit, sel);
setBaroUnits(sel);
if (gaugeBaro) {gaugeBaro.update();}
}
break;
// == Wind speed ==
case 'mph':
// falls through
case 'kts':
// falls through
case 'm/s':
// falls through
case 'km/h':
displayUnits.wind = sel;
if (data.windunit !== sel) {
convWindData(data.windunit, sel);
setWindUnits(sel);
if (gaugeWind) {gaugeWind.update();}
if (gaugeDir) {gaugeDir.update();}
if (gaugeRose) {gaugeRose.update();}
}
break;
// == CloudBase ==
case 'm':
displayUnits.cloud = sel;
if (data.cloudbaseunit !== sel) {
setCloudBaseUnits(true);
convCloudBaseData(ft2m);
if (gaugeCloud) {gaugeCloud.update();}
}
break;
case 'ft':
displayUnits.cloud = sel;
if (data.cloudbaseunit !== sel) {
setCloudBaseUnits(false);
convCloudBaseData(m2ft);
if (gaugeCloud) {gaugeCloud.update();}
}
break;
// no default
}
if (config.useCookies) {
setCookie('units', displayUnits);
}
},
setTempUnits = function (celsius) {
if (celsius) {
data.tempunit = '°C';
if (gaugeTemp) {
gaugeTemp.data.sections = createTempSections(true);
gaugeTemp.data.minValue = gaugeGlobals.tempScaleDefMinC;
gaugeTemp.data.maxValue = gaugeGlobals.tempScaleDefMaxC;
}
if (gaugeDew) {
gaugeDew.data.sections = createTempSections(true);
gaugeDew.data.minValue = gaugeGlobals.tempScaleDefMinC;
gaugeDew.data.maxValue = gaugeGlobals.tempScaleDefMaxC;
}
} else {
data.tempunit = '°F';
if (gaugeTemp) {
gaugeTemp.data.sections = createTempSections(false);
gaugeTemp.data.minValue = gaugeGlobals.tempScaleDefMinF;
gaugeTemp.data.maxValue = gaugeGlobals.tempScaleDefMaxF;
}
if (gaugeDew) {
gaugeDew.data.sections = createTempSections(false);
gaugeDew.data.minValue = gaugeGlobals.tempScaleDefMinF;
gaugeDew.data.maxValue = gaugeGlobals.tempScaleDefMaxF;
}
}
if (gaugeTemp) {
gaugeTemp.gauge.setUnitString(data.tempunit);
gaugeTemp.gauge.setSection(gaugeTemp.data.sections);
}
if (gaugeDew) {
gaugeDew.gauge.setUnitString(data.tempunit);
gaugeDew.gauge.setSection(gaugeTemp.data.sections);
}
},
setRainUnits = function (mm) {
if (mm) {
data.rainunit = 'mm';
if (gaugeRain) {
gaugeRain.data.lcdDecimals = 1;
gaugeRain.data.scaleDecimals = 1;
gaugeRain.data.labelNumberFormat = gaugeGlobals.labelFormat;
gaugeRain.data.sections = (gaugeGlobals.rainUseSectionColours ? createRainfallSections(true) : []);
gaugeRain.data.maxValue = gaugeGlobals.rainScaleDefmm;
gaugeRain.data.grad = (gaugeGlobals.rainUseGradientColours ? createRainfallGradient(true) : null);
}
if (gaugeRRate) {
gaugeRRate.data.lcdDecimals = 1;
gaugeRRate.data.scaleDecimals = 0;
gaugeRRate.data.labelNumberFormat = gaugeGlobals.labelFormat;
gaugeRRate.data.sections = createRainRateSections(true);
gaugeRRate.data.maxValue = gaugeGlobals.rainRateScaleDefmm;
}
} else {
data.rainunit = 'in';
if (gaugeRain) {
gaugeRain.data.lcdDecimals = 2;
gaugeRain.data.scaleDecimals = gaugeGlobals.rainScaleDefIn < 1 ? 2 : 1;
gaugeRain.data.labelNumberFormat = steelseries.LabelNumberFormat.FRACTIONAL;
gaugeRain.data.sections = (gaugeGlobals.rainUseSectionColours ? createRainfallSections(false) : []);
gaugeRain.data.maxValue = gaugeGlobals.rainScaleDefIn;
gaugeRain.data.grad = (gaugeGlobals.rainUseGradientColours ? createRainfallGradient(false) : null);
}
if (gaugeRRate) {
gaugeRRate.data.lcdDecimals = 2;
gaugeRRate.data.scaleDecimals = gaugeGlobals.rainRateScaleDefIn < 1 ? 2 : 1;
gaugeRRate.data.labelNumberFormat = steelseries.LabelNumberFormat.FRACTIONAL;
gaugeRRate.data.sections = createRainRateSections(false);
gaugeRRate.data.maxValue = gaugeGlobals.rainRateScaleDefIn;
}
}
if (gaugeRain) {
gaugeRain.data.value = 0;
gaugeRain.gauge.setUnitString(data.rainunit);
gaugeRain.gauge.setSection(gaugeRain.data.sections);
gaugeRain.gauge.setGradient(gaugeRain.data.grad);
gaugeRain.gauge.setFractionalScaleDecimals(gaugeRain.data.scaleDecimals);
gaugeRain.gauge.setLabelNumberFormat(gaugeRain.data.labelNumberFormat);
gaugeRain.gauge.setLcdDecimals(gaugeRain.data.lcdDecimals);
}
if (gaugeRRate) {
gaugeRRate.data.value = 0;
gaugeRRate.gauge.setUnitString(data.rainunit + '/h');
gaugeRRate.gauge.setSection(gaugeRRate.data.sections);
gaugeRRate.gauge.setFractionalScaleDecimals(gaugeRRate.data.scaleDecimals);
gaugeRRate.gauge.setLabelNumberFormat(gaugeRRate.data.labelNumberFormat);
gaugeRRate.gauge.setLcdDecimals(gaugeRRate.data.lcdDecimals);
}
},
setWindUnits = function (to) {
var maxVal;
if (!gaugeWind) {return;}
// conversion function to required units
switch (to) {
case 'mph':
maxVal = gaugeGlobals.windScaleDefMaxMph;
break;
case 'kts':
maxVal = gaugeGlobals.windScaleDefMaxKts;
break;
case 'km/h':
maxVal = gaugeGlobals.windScaleDefMaxKmh;
break;
case 'm/s':
maxVal = gaugeGlobals.windScaleDefMaxMs;
break;
// no default
}
// set the gauges
data.windunit = to;
gaugeWind.data.maxValue = maxVal;
gaugeWind.gauge.setUnitString(data.windunit);
gaugeWind.gauge.setValue(0);
},
setBaroUnits = function (to) {
var minVal, maxVal;
if (!gaugeBaro) {return;}
// set to the required units
switch (to) {
case 'hPa':
// falls through
case 'mb':
minVal = gaugeGlobals.baroScaleDefMinhPa;
maxVal = gaugeGlobals.baroScaleDefMaxhPa;
gaugeBaro.data.lcdDecimals = 1;
gaugeBaro.data.scaleDecimals = 0;
gaugeBaro.data.labelNumberFormat = gaugeGlobals.labelFormat;
break;
case 'inHg':
minVal = gaugeGlobals.baroScaleDefMininHg;
maxVal = gaugeGlobals.baroScaleDefMaxinHg;
gaugeBaro.data.lcdDecimals = 2;
gaugeBaro.data.scaleDecimals = 1;
gaugeBaro.data.labelNumberFormat = steelseries.LabelNumberFormat.FRACTIONAL;
break;
case 'kPa':
minVal = gaugeGlobals.baroScaleDefMinkPa;
maxVal = gaugeGlobals.baroScaleDefMaxkPa;
gaugeBaro.data.lcdDecimals = 2;
gaugeBaro.data.scaleDecimals = 1;
gaugeBaro.data.labelNumberFormat = steelseries.LabelNumberFormat.FRACTIONAL;
break;
// no default
}
data.pressunit = to;
gaugeBaro.gauge.setUnitString(to);
gaugeBaro.gauge.setLcdDecimals(gaugeBaro.data.lcdDecimals);
gaugeBaro.gauge.setFractionalScaleDecimals(gaugeBaro.data.scaleDecimals);
gaugeBaro.gauge.setLabelNumberFormat(gaugeBaro.data.labelNumberFormat);
gaugeBaro.data.minValue = minVal;
gaugeBaro.data.maxValue = maxVal;
gaugeBaro.data.value = gaugeBaro.data.minValue;
},
setCloudBaseUnits = function (m) {
if (!gaugeCloud) {return;}
if (m) {
gaugeCloud.data.sections = createCloudBaseSections(true);
gaugeCloud.data.maxValue = gaugeGlobals.cloudScaleDefMaxm;
} else {
gaugeCloud.data.sections = createCloudBaseSections(false);
gaugeCloud.data.maxValue = gaugeGlobals.cloudScaleDefMaxft;
}
gaugeCloud.data.value = 0;
gaugeCloud.gauge.setUnitString(m ? strings.metres : strings.feet);
gaugeCloud.gauge.setSection(gaugeCloud.data.sections);
},
//
// setLang() switches the HTML page language set, called by changeLang() in language.js
//
setLang = function (newLang) {
strings = newLang;
// temperature
if (gaugeTemp) {
if ($('#rad_temp1').is(':checked')) {
gaugeTemp.data.title = strings.temp_title_out;
} else {
gaugeTemp.data.title = strings.temp_title_in;
}
gaugeTemp.gauge.setTitleString(gaugeTemp.data.title);
if (data.ver) {gaugeTemp.update();}
}
if (gaugeDew) {
switch ($('input[name="rad_dew"]:checked').val()) {
case 'dew':
gaugeDew.data.title = strings.dew_title;
break;
case 'app':
gaugeDew.data.title = strings.apptemp_title;
break;
case 'wnd':
gaugeDew.data.title = strings.chill_title;
break;
case 'hea':
gaugeDew.data.title = strings.heat_title;
break;
case 'hum':
gaugeDew.data.title = strings.humdx_title;
break;
// no default
}
gaugeDew.gauge.setTitleString(gaugeDew.data.title);
if (data.ver) {gaugeDew.update();}
}
// rain
if (gaugeRain) {
gaugeRain.data.title = strings.rain_title;
gaugeRain.gauge.setTitleString(gaugeRain.data.title);
if (data.ver) {gaugeRain.update();}
}
// rrate
if (gaugeRRate) {
gaugeRRate.data.title = strings.rrate_title;
gaugeRRate.gauge.setTitleString(gaugeRRate.data.title);
if (data.ver) {gaugeRRate.update();}
}
// humidity
if (gaugeHum) {
if ($('#rad_hum1').is(':checked')) {
gaugeHum.data.title = strings.hum_title_out;
} else {
gaugeHum.data.title = strings.hum_title_in;
}
gaugeHum.gauge.setTitleString(gaugeHum.data.title);
if (data.ver) {gaugeHum.update();}
}
// barometer
if (gaugeBaro) {
gaugeBaro.data.title = strings.baro_title;
gaugeBaro.gauge.setTitleString(gaugeBaro.data.title);
if (data.ver) {gaugeBaro.update();}
}
// wind
if (gaugeWind) {
gaugeWind.data.title = strings.wind_title;
gaugeWind.gauge.setTitleString(gaugeWind.data.title);
if (data.ver) {gaugeWind.update();}
}
if (gaugeDir) {
gaugeDir.gauge.setPointSymbols(strings.compass);
gaugeDir.data.titles = [strings.latest_web, strings.tenminavg_web];
gaugeDir.gauge.setLcdTitleStrings(gaugeDir.data.titles);
if (data.ver) {gaugeDir.update();}
}
if (gaugeUV) {
gaugeUV.gauge.setTitleString(strings.uv_title);
if (data.ver) {gaugeUV.update();}
}
if (gaugeSolar) {
gaugeSolar.gauge.setTitleString(strings.solar_title);
if (data.ver) {gaugeSolar.update();}
}
if (gaugeRose) {
gaugeRose.setTitle(strings.windrose);
gaugeRose.setCompassString(strings.compass);
if (data.ver) {gaugeRose.update();}
}
if (gaugeCloud) {
// Cloudbase
gaugeCloud.data.units = data.cloudunit === 'm' ? strings.metres : strings.feet;
gaugeCloud.gauge.setTitleString(strings.cloudbase_title);
gaugeCloud.gauge.setUnitString(gaugeCloud.data.units);
if (data.ver) {gaugeCloud.update();}
}
},
//
// return windrun units based on the windspeed units
//
getWindrunUnits = function (spdUnits) {
var retVal;
switch (spdUnits) {
case 'mph':
retVal = 'miles';
break;
case 'kts':
retVal = 'n.miles';
break;
case 'km/h':
// falls through
case 'm/s':
// falls through
default:
retVal = 'km';
break;
}
return retVal;
},
//
// performs a simple cloudbase calculation for those weather programs that don't supply it
//
calcCloudbase = function (temp, tempunit, dew, cloudbaseunit) {
var sprd = temp - dew;
var cb = sprd * (tempunit[1] === 'C' ? 400 : 227.3); // cloud base in feet
if (cloudbaseunit === 'm') {
cb = ft2m(cb);
}
return cb;
},
//
// create a shadow effect for the gauge using CSS
//
gaugeShadow = function (size) {
var offset = Math.floor(size * 0.01);
return {
'box-shadow' : offset + 'px ' + offset + 'px ' + offset + 'px ' + gaugeGlobals.shadowColour,
'border-radius': Math.floor(size / 2) + 'px'
};
},
//
// generate a colour gradient based on start and end values
//
gradient = function (startCol, endCol, fraction) {
var redOrigin, grnOrigin, bluOrigin,
gradientSizeRed, gradientSizeGrn, gradientSizeBlu;
redOrigin = parseInt(startCol.substr(0, 2), 16);
grnOrigin = parseInt(startCol.substr(2, 2), 16);
bluOrigin = parseInt(startCol.substr(4, 2), 16);
gradientSizeRed = parseInt(endCol.substr(0, 2), 16) - redOrigin; //Graduation Size Red
gradientSizeGrn = parseInt(endCol.substr(2, 2), 16) - grnOrigin;
gradientSizeBlu = parseInt(endCol.substr(4, 2), 16) - bluOrigin;
return (redOrigin + (gradientSizeRed * fraction)).toFixed(0) + ',' +
(grnOrigin + (gradientSizeGrn * fraction)).toFixed(0) + ',' +
(bluOrigin + (gradientSizeBlu * fraction)).toFixed(0);
};
// ########################################################
// End of gauges() var declarations
// ########################################################
//
// Execution starts here
//
if (!document.createElement('canvas').getContext) {
$('body').html(strings.canvasnosupport);
setTimeout(function () {
window.location = config.oldGauges;
}, 3000);
return false;
} else {
$(document).ready(function () {
init(config.dashboardMode);
});
}
return {
setLang : setLang,
setUnits : setUnits,
processData: processData
};
}()),
/*!
* Image w/ description tooltip v2.0 - For FF1+ IE6+ Opr8+
* Created: April 23rd, 2010. This notice must stay intact for usage
* Author: Dynamic Drive at http://www.dynamicdrive.com/
* Visit http://www.dynamicdrive.com/ for full source code
* Modified: M Crossley June 2011, January 2012
* v2.-
*/
ddimgtooltip = {
tiparray: (function () {
var style = {background: '#FFFFFF', color: 'black', border: '2px ridge darkblue'},
i = 12, // set to number of tooltips required
tooltips = [];
for (;i--;) {
tooltips[i] = [null, ' ', style];
}
return tooltips;
}()),
tooltipoffsets: [20, -30], //additional x and y offset from mouse cursor for tooltips
tipDelay: 70,
delayTimer: 0,
tipprefix: 'imgtip', //tooltip DOM ID prefixes
createtip: function ($, tipid, tipinfo) {
if ($('#' + tipid).length === 0) { //if this tooltip doesn't exist yet
return $('
')
.html(
((tipinfo[1]) ? '
' + tipinfo[1] + '
' : '') +
(tipinfo[0] !== null ? '
' : '')
)
.css(tipinfo[2] || {})
.appendTo(document.body);
}
return null;
},
positiontooltip: function ($, $tooltip, e) {
var x = e.pageX + this.tooltipoffsets[0],
y = e.pageY + this.tooltipoffsets[1],
tipw = $tooltip.outerWidth(),
tiph = $tooltip.outerHeight(),
wWidth = $(window).width(),
wHght = $(window).height(),
dTop = $(document).scrollTop();
x = (x + tipw > $(document).scrollLeft() + wWidth) ? x - tipw - (ddimgtooltip.tooltipoffsets[0] * 2) : x;
y = (y + tiph > dTop + wHght) ? dTop + wHght - tiph - 10 : y;
x = Math.max(x, 0);
if (tipw >= wWidth) {
$($tooltip.attr('id') + '_img').css({width: wWidth - 20});
$('#' + $tooltip.attr('id') + '_img').css({width: wWidth - 20});
y = e.pageY + 5;
}
$tooltip.css({left: x, top: y});
},
delaybox: function ($, $tooltip) {
if (this.showTips) {
ddimgtooltip.delayTimer = setTimeout(
function () {
ddimgtooltip.showbox($tooltip);
}, ddimgtooltip.tipDelay);
}
},
showbox: function (tooltip) {
if (this.showTips) {
//$(tooltip).show();
$(tooltip).fadeIn(400);
}
},
hidebox: function ($, $tooltip) {
clearTimeout(ddimgtooltip.delayTimer);
//$tooltip.hide();
$tooltip.fadeOut(400);
},
showTips: false,
init: function (targetselector) {
var tiparray = ddimgtooltip.tiparray,
$targets = $(targetselector);
if ($targets.length === 0) {
return;
}
$targets.each(function () {
var $target = $(this),
tipsuffix, tipid,
$tooltip;
var ind = ($target.attr('id').match(/_(\d+)/) || [])[1] || ''; //match d of attribute id='tip_d'
tipsuffix = parseInt(ind, 10); //get d as integer
tipid = this.tipid = ddimgtooltip.tipprefix + tipsuffix; //construct this tip's ID value and remember it
$tooltip = ddimgtooltip.createtip($, tipid, tiparray[tipsuffix]);
$target.mouseenter(function (e) {
var $tooltip = $('#' + this.tipid);
ddimgtooltip.delaybox($, $tooltip, e);
});
$target.mouseleave(function () {
var $tooltip = $('#' + this.tipid);
ddimgtooltip.hidebox($, $tooltip);
});
$target.mousemove(function (e) {
var $tooltip = $('#' + this.tipid);
ddimgtooltip.positiontooltip($, $tooltip, e);
});
if ($tooltip) {
$tooltip.mouseenter(function () {
ddimgtooltip.hidebox($, $(this));
});
}
});
}
};
function createSummary(data){
$("#currentT").html("
" + data['temp'] + " °C");
$("#todayMaxT").html("
" + data['tempTH'] + " °C" + data['TtempTH'] + "");
$("#todayMinT").html("
" + data['tempTL'] + " °C" + data['TtempTL'] + "");
$("#yesterdayMaxT").html("
" + data['yesterday']['data']['maxT'] + " °C" + data['yesterday']['data']['maxTTime'] + "");
$("#yesterdayMinT").html("
" + data['yesterday']['data']['minT'] + "°C" + data['yesterday']['data']['minTTime'] + "");
$("#currentA").html("
" + data['apptemp'] + " °C");
$("#todayMaxA").html("
" + data['apptempTH'] + " °C" + data['TapptempTH'] + "");
$("#todayMinA").html("
" + data['apptempTL'] + " °C" + data['TapptempTL'] + "");
$("#yesterdayMaxA").html("
" + data['yesterday']['data']['maxA'] + " °C" + data['yesterday']['data']['maxATime'] + "");
$("#yesterdayMinA").html("
" + data['yesterday']['data']['minA'] + " °C" + data['yesterday']['data']['minATime'] + "");
$("#currentD").html("
" + data['dew'] + " °C");
$("#todayMaxD").html("
" + data['dewpointTH'] + " °C" + data['TdewpointTH'] + "");
$("#todayMinD").html("
" + data['dewpointTL'] + " °C" + data['TdewpointTL'] + "");
$("#yesterdayMaxD").html("
" + data['yesterday']['data']['maxD'] + " °C" + data['yesterday']['data']['maxDTime'] + "");
$("#yesterdayMinD").html("
" + data['yesterday']['data']['minD'] + " °C" + data['yesterday']['data']['minDTime'] + "");
$("#currentH").html("
" + data['hum'] + " %");
$("#todayMaxH").html("
" + data['humTH'] + " %" + data['ThumTH'] + "");
$("#todayMinH").html("
" + data['humTL'] + " %" + data['ThumTL'] + "");
$("#yesterdayMaxH").html("
" + data['yesterday']['data']['maxH'] + " %" + data['yesterday']['data']['maxHTime'] + "");
$("#yesterdayMinH").html("
" + data['yesterday']['data']['minH'] + " %" + data['yesterday']['data']['minHTime'] + "");
$("#currentP").html("
" + data['press'] + " hPa");
$("#todayMaxP").html("
" + data['pressTH'] + " hPa" + data['TpressTH'] + "");
$("#todayMinP").html("
" + data['pressTL'] + " hPa" + data['TpressTL'] + "");
$("#yesterdayMaxP").html("
" + data['yesterday']['data']['maxP'] + " hPa" + data['yesterday']['data']['maxPTime'] + "");
$("#yesterdayMinP").html("
" + data['yesterday']['data']['minP'] + " hPa" + data['yesterday']['data']['minPTime'] + "");
$("#currentW").html("
" + data['wlatest'] + " km/h");
$("#todayMaxW").html("
" + data['windTM'] + " km/h" + data['TwindTM'] + "");
$("#yesterdayMaxW").html("
" + data['yesterday']['data']['maxW'] + " km/h" + data['yesterday']['data']['maxWTime'] + "");
$("#currentG").html("
" + data['wgust'] + " km/h");
$("#todayMaxG").html("
" + data['wgustTM'] + " km/h" + data['TwgustTM'] + "");
$("#yesterdayMaxG").html("
" + data['yesterday']['data']['maxG'] + " km/h" + data['yesterday']['data']['maxGTime'] + "");
$("#todayR").html("
" + data['rfall'] + " mm");
$("#yesterdayR").html("
" + data['yesterday']['data']['R'] + " mm");
}
// if String doesn't offer a .trim() method, add it
String.prototype.trim = String.prototype.trim || function trim() {
return this.replace(/^\s+|\s+$/g, '');
};