/*
* Modified: Jachym, Meteotemplate, 2017
*/
/*!
* Created by Mark Crossley, July 2011
* see scriptVer below for latest release
*
* Released under GNU GENERAL PUBLIC LICENSE, Version 2, June 1991
* See the enclosed License file
*/
/*!
* Tiny Pub/Sub - v0.7.0 - 2013-01-29
* https://github.com/cowboy/jquery-tiny-pubsub
* Copyright (c) 2013 "Cowboy" Ben Alman; Licensed MIT
*/
(function ($) {
'use strict';
var o = $({});
$.subscribe = function () {o.on.apply(o, arguments);};
$.unsubscribe = function () {o.off.apply(o, arguments);};
$.publish = function () {o.trigger.apply(o, arguments);};
}(jQuery));
var gauges = (
function () {
'use strict';
var strings = LANG.IT, //Set to your default language. Store all the strings in one object
config = {
scriptVer : '2.5.17',
weatherProgram : 4, // set to MB, but using custom Meteotemplate file instead
imgPathURL : './images/',
oldGauges : 'gauges.htm',
realtimeInterval : 30,
longPoll : false,
gaugeMobileScaling : 0.85,
graphUpdateTime : 15,
stationTimeout : 11,
pageUpdateLimit : 99999,//period after which the page stops automatically updating, in minutes (default 20)
pageUpdatePswd : 'its-me',
digitalFont : false,digitalForecast : false, showPopupData : true, showPopupGraphs : false,
mobileShowGraphs : false,
showWindVariation : true,
showWindMetar : false,
showIndoorTempHum : false,
showCloudGauge : false,
showUvGauge : false, showSolarGauge : false, showSunshineLed : true,
showRoseGauge : true,
showRoseGaugeOdo : true,
showRoseOnDirGauge : true,
showGaugeShadow : false, roundCloudbaseVal : true,
realTimeUrlLongPoll: 'realtimegauges-longpoll.php',
realTimeUrlCumulus : '',
realTimeUrlWD : '',
realTimeUrlVWS : '',
realTimeUrlWC : '',
realTimeUrlMB : 'ssMeteotemplate.php',
realTimeUrlWView : '',
realTimeUrlWeewx : '',
useCookies : false,
tipImages : [],
dashboardMode : false,
dewDisplayType : 'app'
},
gaugeGlobals = {
minMaxArea : 'rgba(212,132,134,0.6)',
windAvgArea : 'rgba(212,132,134,0.6)',
windVariationSector : 'rgba(120,200,120,0.7)',
frameDesign : steelseries.FrameDesign.SHINY_METAL,
background : steelseries.BackgroundColor.WHITE,
foreground : steelseries.ForegroundType.TYPE2,
pointer : steelseries.PointerType.TYPE11,
pointerColour : steelseries.ColorDef.GRAY,
dirAvgPointer : steelseries.PointerType.TYPE11,
dirAvgPointerColour : steelseries.ColorDef.BLUE,
gaugeType : steelseries.GaugeType.TYPE4,
lcdColour : steelseries.LcdColor.BLUE2,
knob : steelseries.KnobType.STANDARD_KNOB,
knobStyle : steelseries.KnobStyle.BLACK,
labelFormat : steelseries.LabelNumberFormat.STANDARD,
tickLabelOrientation : steelseries.TickLabelOrientation.HORIZONTAL,
rainUseSectionColours : false,
rainUseGradientColours: false,
tempTrendVisible : true, pressureTrendVisible : true, uvLcdDecimals : 1, sunshineThreshold : 50,
sunshineThresholdPct : 75,
tempScaleDefMinC : -30.0,
tempScaleDefMaxC : 40.0,
tempScaleDefMinF : 0.0,
tempScaleDefMaxF : 120.0,
baroScaleDefMinhPa : 980,
baroScaleDefMaxhPa : 1040,
baroScaleDefMinkPa : 99,
baroScaleDefMaxkPa : 103,
baroScaleDefMininHg : 28.00,
baroScaleDefMaxinHg : 32.00,
windScaleDefMaxMph : 60.0,
windScaleDefMaxKts : 60.0,
windScaleDefMaxMs : 30.0,
windScaleDefMaxKmh : 80.0,
rainScaleDefMaxmm : 25.0,
rainScaleDefMaxIn : 2.00,
rainRateScaleDefMaxmm : 100.0,
rainRateScaleDefMaxIn : 8.00,
uvScaleDefMax : 12.0,
solarGaugeScaleMax : 1440.0,
cloudScaleDefMaxft : 3000,
cloudScaleDefMaxm : 1000,
shadowColour : 'rgba(220,220,220,0.3)'
},
commonParams = {
fullScaleDeflectionTime: 4,
gaugeType : gaugeGlobals.gaugeType,
minValue : 0,
niceScale : true,
ledVisible : false,
frameDesign : gaugeGlobals.frameDesign,
backgroundColor : gaugeGlobals.background,
foregroundType : gaugeGlobals.foreground,
pointerType : gaugeGlobals.pointer,
pointerColor : gaugeGlobals.pointerColour,
knobType : gaugeGlobals.knob,
knobStyle : gaugeGlobals.knobStyle,
lcdColor : gaugeGlobals.lcdColour,
lcdDecimals : 1,
digitalFont : config.digitalFont,
tickLabelOrientation : gaugeGlobals.tickLabelOrientation,
labelNumberFormat : gaugeGlobals.labelFormat
},
firstRun = true,
userUnitsSet = false,
data = {},
tickTockInterval,
ajaxDelay = config.longPoll ? Math.max(config.realtimeInterval - 20, 0) : config.realtimeInterval,
downloadTimer,
timestamp = 0,
jqXHR = null,
displayUnits = null,
sampleDate,
realtimeVer,
programLink = ['','','', '','','',''],
ledIndicator, statusScroller, statusTimer,
gaugeTemp, gaugeDew, gaugeRain, gaugeRRate,
gaugeHum, gaugeBaro, gaugeWind, gaugeDir,
gaugeUV, gaugeSolar, gaugeCloud, gaugeRose,
/* _imgBackground, // Uncomment if using a background image on the gauges */
init = function (dashboard) {
switch (config.weatherProgram) {
case 4:
realtimeVer = 10;
config.realTimeURL = config.longPoll ? config.realTimeUrlLongPoll : config.realTimeUrlMB;
config.showPopupGraphs = false;
config.showRoseGauge = true;
config.showCloudGauge = false;
config.tipImgs = null;
config.showWindVariation = true;
break;
default:
realtimeVer = 0;
config.realtimeURL = null;
config.showPopupGraphs = false;
config.tipImgs = null;
}
if ($(window).width() < 480) {
config.gaugeScaling = config.gaugeMobileScaling;
config.showPopupGraphs = config.mobileShowGraphs;
} else {
config.gaugeScaling = 1;
}
/*
_imgBackground = document.createElement('img');
$(_imgBackground).attr('src', config.imgPathURL + 'logoSmall.png');
*/
displayUnits = getCookie('units');
if (displayUnits !== null) {
userUnitsSet = true;
setRadioCheck('rad_unitsTemp', displayUnits.temp);
data.tempunit = '°' + displayUnits.temp;
setRadioCheck('rad_unitsRain', displayUnits.rain);
data.rainunit = displayUnits.rain;
setRadioCheck('rad_unitsPress', displayUnits.press);
data.pressunit = displayUnits.press;
setRadioCheck('rad_unitsWind', displayUnits.wind);
data.windunit = displayUnits.wind;
displayUnits.windrun = getWindrunUnits(data.windunit);
setRadioCheck('rad_unitsCloud', displayUnits.cloud);
data.cloudunit = displayUnits.cloud;
} else {
displayUnits = {
temp : 'C',
rain : 'mm',
press : 'hPa',
wind : 'km/h',
windrun: 'km',
cloud : 'm'
};
data.tempunit = '°C';
data.rainunit = 'mm';
data.pressunit = 'hPa';
data.windunit = 'km/h';
data.cloudunit = 'm';
}
if (config.showPopupData) {
ddimgtooltip.showTips = config.showPopupData;
}
if (config.showPopupGraphs) {
ddimgtooltip.tiparray[0][0] = (config.tipImgs[0][0] === null ? null : '');
ddimgtooltip.tiparray[1][0] = (config.tipImgs[1][0] === null ? null : '');
ddimgtooltip.tiparray[2][0] = (config.tipImgs[2] === null ? null : '');
ddimgtooltip.tiparray[3][0] = (config.tipImgs[3] === null ? null : '');
ddimgtooltip.tiparray[4][0] = (config.tipImgs[4][0] === null ? null : '');
ddimgtooltip.tiparray[5][0] = (config.tipImgs[5] === null ? null : '');
ddimgtooltip.tiparray[6][0] = (config.tipImgs[6] === null ? null : '');
ddimgtooltip.tiparray[7][0] = (config.tipImgs[7] === null ? null : '');
ddimgtooltip.tiparray[8][0] = (config.tipImgs[8] === null ? null : '');
ddimgtooltip.tiparray[9][0] = (config.tipImgs[9] === null ? null : '');
ddimgtooltip.tiparray[10][0] = (config.tipImgs[10] === null ? null : '');
ddimgtooltip.tiparray[11][0] = (config.tipImgs[11] === null ? null : '');
}
ledIndicator = singleLed.getInstance();
statusScroller = singleStatus.getInstance();
statusTimer = singleTimer.getInstance();
gaugeTemp = singleTemp.getInstance();
if (gaugeTemp) {gauges.doTemp = gaugeTemp.update;}
gaugeDew = singleDew.getInstance();
if (gaugeDew) {gauges.doDew = gaugeDew.update;}
gaugeHum = singleHum.getInstance();
if (gaugeHum) {gauges.doHum = gaugeHum.update;}
gaugeBaro = singleBaro.getInstance();
gaugeWind = singleWind.getInstance();
gaugeDir = singleDir.getInstance();
gaugeRain = singleRain.getInstance();
gaugeRRate = singleRRate.getInstance();
if (!config.showUvGauge) {
$('#canvas_uv').parent().remove();
} else {
gaugeUV = singleUV.getInstance();
}
if (!config.showSolarGauge) {
$('#canvas_solar').parent().remove();
} else {
gaugeSolar = singleSolar.getInstance();
}
if (!config.showRoseGauge) {
$('#canvas_rose').parent().remove();
} else {
gaugeRose = singleRose.getInstance();
if (gaugeRose) {
gaugeRose.setTitle(strings.windrose);
gaugeRose.setCompassString(strings.compass);
}
}
if (!config.showCloudGauge) {
$('#canvas_cloud').parent().remove();
$('#cloud').parent().remove();
} else {
gaugeCloud = singleCloudBase.getInstance();
}
changeLang(strings, false);
if (!dashboard) {
getRealtime();
tickTockInterval = setInterval(
function () {
$.publish('gauges.clockTick', null);
},
1000);
if (config.pageUpdateLimit > 0 && getUrlParam('pageUpdate') !== config.pageUpdatePswd) {
setTimeout(pageTimeout, config.pageUpdateLimit * 60 * 1000);
}
}
},
singleLed = (function () {
var instance; // Stores a reference to the Singleton
var led; // Stores a reference to the SS LED
function init() {
// create led indicator
if ($('#canvas_led').length) {
led = new steelseries.Led(
'canvas_led', {
ledColor: steelseries.LedColor.GREEN_LED,
size : $('#canvas_led').width()
});
setTitle(strings.led_title);
}
function setTitle(newTitle) {
$('#canvas_led').attr('title', newTitle);
}
function setLedColor(newColour) {
if (led) {
led.setLedColor(newColour);
}
}
function setLedOnOff(onState) {
if (led) {
led.setLedOnOff(onState);
}
}
function blink(blinkState) {
if (led) {
led.blink(blinkState);
}
}
return {
setTitle : setTitle,
setLedColor: setLedColor,
setLedOnOff: setLedOnOff,
blink : blink
};
}
return {
// Get the Singleton instance if one exists
// or create one if it doesn't
getInstance: function () {
if (!instance) {
instance = init();
}
return instance;
}
};
})(),
singleStatus = (function () {
var instance; // Stores a reference to the Singleton
var scroller; // Stores a reference to the SS scrolling display
function init() {
// create forecast display
if ($('#canvas_status').length) {
scroller = new steelseries.DisplaySingle(
'canvas_status', {
width : $('#canvas_status').width(),
height : $('#canvas_status').height(),
lcdColor : gaugeGlobals.lcdColour,
unitStringVisible: false,
value : strings.statusStr,
digitalFont : config.digitalForecast,
valuesNumeric : false,
autoScroll : true,
alwaysScroll : false
});
}
function setValue(newTxt) {
if (scroller) {
scroller.setValue(newTxt);
}
}
return {setText: setValue};
}
return {
// Get the Singleton instance if one exists
// or create one if it doesn't
getInstance: function () {
if (!instance) {
instance = init();
}
return instance;
}
};
})(),
singleTimer = (function () {
var instance, // Stores a reference to the Singleton
lcd, // Stores a reference to the SS LED
count = 1;
function init() {
function tick() {
if (lcd) {
lcd.setValue(count);
count += config.longPoll ? 1 : -1;
}
}
function reset(val) {
count = val;
}
function setValue(newVal) {
if (lcd) {
lcd.setValue(newVal);
}
}
// create timer display
if ($('#canvas_timer').length) {
lcd = new steelseries.DisplaySingle(
'canvas_timer', {
width : $('#canvas_timer').width(),
height : $('#canvas_timer').height(),
lcdColor : gaugeGlobals.lcdColour,
lcdDecimals : 0,
unitString : strings.timer,
unitStringVisible: true,
digitalFont : config.digitalFont,
value : count
});
// subcribe to data updates
$.subscribe('gauges.clockTick', tick);
}
return {
reset : reset,
setValue: setValue
};
}
return {
// Get the Singleton instance if one exists
// or create one if it doesn't
getInstance: function () {
if (!instance) {
instance = init();
}
return instance;
}
};
})(),
singleTemp = (function () {
var instance;
var ssGauge;
var cache = {};
function init() {
var params = $.extend(true, {}, commonParams);
cache.sections = createTempSections(true);
cache.areas = [];
cache.minValue = gaugeGlobals.tempScaleDefMinC;
cache.maxValue = gaugeGlobals.tempScaleDefMaxC;
cache.title = strings.temp_title_out;
cache.value = gaugeGlobals.tempScaleDefMinC + 0.0001;
cache.maxMinVisible = false;
cache.selected = 'out';
// create temperature radial gauge
if ($('#canvas_temp').length) {
params.size = Math.ceil($('#canvas_temp').width() * config.gaugeScaling);
params.gaugeType = steelseries.GaugeType.TYPE4;
params.section = cache.sections;
params.area = cache.areas;
params.minValue = cache.minValue;
params.maxValue = cache.maxValue;
params.thresholdVisible = false;
params.minMeasuredValueVisible = cache.maxMinVisible;
params.maxMeasuredValueVisible = cache.maxMinVisible;
params.titleString = cache.title;
params.unitString = data.tempunit;
params.trendVisible = gaugeGlobals.tempTrendVisible;
//params.customLayer = _imgBackground; // uncomment to add a background image - See Logo Images above
ssGauge = new steelseries.Radial('canvas_temp', params);
ssGauge.setValue(cache.value);
// over-ride CSS applied size?
if (config.gaugeScaling !== 1) {
$('#canvas_temp').css({width: params.size + 'px', height: params.size + 'px'});
}
// add a shadow to the gauge
if (config.showGaugeShadow) {
$('#canvas_temp').css(gaugeShadow(params.size));
}
// remove indoor temperature/humidity options?
if (!config.showIndoorTempHum) {
$('#rad_temp1').remove();
$('#lab_temp1').remove();
$('#rad_temp2').remove();
$('#lab_temp2').remove();
$('#rad_hum1').remove();
$('#lab_hum1').remove();
$('#rad_hum2').remove();
$('#lab_hum2').remove();
}
// subcribe to data updates
$.subscribe('gauges.dataUpdated', update);
$.subscribe('gauges.graphUpdate', updateGraph);
} else {
return null;
}
function update() {
var sel = cache.selected;
if (arguments.length === 1) {
sel = arguments[0].value;
}
var t1, scaleStep, tip;
cache.minValue = data.tempunit[1] === 'C' ? gaugeGlobals.tempScaleDefMinC : gaugeGlobals.tempScaleDefMinF;
cache.maxValue = data.tempunit[1] === 'C' ? gaugeGlobals.tempScaleDefMaxC : gaugeGlobals.tempScaleDefMaxF;
if (sel === 'out') {
cache.low = extractDecimal(data.tempTL);
cache.high = extractDecimal(data.tempTH);
cache.lowScale = getMinTemp(cache.minValue);
cache.highScale = getMaxTemp(cache.maxValue);
cache.value = extractDecimal(data.temp);
cache.title = strings.temp_title_out;
cache.loc = strings.temp_out_info;
cache.trendVal = extractDecimal(data.temptrend);
cache.popupImg = 0;
if (gaugeGlobals.tempTrendVisible) {
t1 = tempTrend(+cache.trendVal, data.tempunit, false);
if (t1 === -9999) {
// trend value isn't currently available
cache.trend = steelseries.TrendState.OFF;
} else if (t1 > 0) {
cache.trend = steelseries.TrendState.UP;
} else if (t1 < 0) {
cache.trend = steelseries.TrendState.DOWN;
} else {
cache.trend = steelseries.TrendState.STEADY;
}
}
} else {
cache.low = extractDecimal(data.intemp);
cache.lowScale = cache.low;
cache.high = cache.low;
cache.highScale = cache.low;
cache.value = cache.low;
cache.title = strings.temp_title_in;
cache.loc = strings.temp_in_info;
cache.maxMinVisible = false;
cache.popupImg = 1;
if (gaugeGlobals.tempTrendVisible) {
cache.trend = steelseries.TrendState.OFF;
}
}
// has the gauge type changed?
if (cache.selected !== sel) {
cache.selected = sel;
//Change gauge title
ssGauge.setTitleString(cache.title);
ssGauge.setMaxMeasuredValueVisible(cache.maxMinVisible);
ssGauge.setMinMeasuredValueVisible(cache.maxMinVisible);
if (config.showPopupGraphs && config.tipImgs[0][cache.popupImg] !== null) {
var cacheDefeat = '?' + $('#imgtip0_img').attr('src').split('?')[1];
$('#imgtip0_img').attr('src', config.imgPathURL + config.tipImgs[0][cache.popupImg] + cacheDefeat);
}
}
//auto scale the ranges
scaleStep = data.tempunit[1] === 'C' ? 10 : 20;
while (cache.lowScale < cache.minValue) {
cache.minValue -= scaleStep;
if (cache.highScale <= cache.maxValue - scaleStep) {
cache.maxValue -= scaleStep;
}
}
while (cache.highScale > cache.maxValue) {
cache.maxValue += scaleStep;
if (cache.minValue >= cache.minValue + scaleStep) {
cache.minValue += scaleStep;
}
}
if (cache.minValue !== ssGauge.getMinValue() || cache.maxValue !== ssGauge.getMaxValue()) {
ssGauge.setMinValue(cache.minValue);
ssGauge.setMaxValue(cache.maxValue);
ssGauge.setValue(cache.minValue);
}
if (cache.selected === 'out') {
cache.areas = [steelseries.Section(+cache.low, +cache.high, gaugeGlobals.minMaxArea)];
} else {
cache.areas = [];
}
if (gaugeGlobals.tempTrendVisible) {
ssGauge.setTrend(cache.trend);
}
ssGauge.setArea(cache.areas);
ssGauge.setValueAnimated(+cache.value);
if (ddimgtooltip.showTips) {
// update tooltip
if (cache.selected === 'out') {
tip = cache.loc + ' - ' + strings.lowestF_info + ': ' + cache.low + data.tempunit + ' ' + strings.at + ' ' + data.TtempTL +
' | ' +
strings.highestF_info + ': ' + cache.high + data.tempunit + ' ' + strings.at + ' ' + data.TtempTH;
if (cache.trendVal !== -9999) {
tip += '
' +
strings.temp_trend_info + ': ' + tempTrend(cache.trendVal, data.tempunit, true) +
' ' + cache.trendVal + data.tempunit + '/h';
}
} else {
tip = cache.loc + ': ' + data.intemp + data.tempunit;
}
$('#imgtip0_txt').html(tip);
}
} // End of update()
function updateGraph(evnt, cacheDefeat) {
if (config.tipImgs[0][cache.popupImg] !== null) {
$('#imgtip0_img').attr('src', config.imgPathURL + config.tipImgs[0][cache.popupImg] + cacheDefeat);
}
}
return {
data : cache,
update: update,
gauge : ssGauge
};
} // End of init()
return {
// Get the Singleton instance if one exists
// or create one if it doesn't
getInstance: function () {
if (!instance) {
instance = init();
}
return instance;
}
};
})(), // End singleTemp()
singleDew = (function () {
var instance; // Stores a reference to the Singleton
var ssGauge; // Stores a reference to the SS Gauge
var cache = {}; // Stores various config values and parameters
function init() {
var params = $.extend(true, {}, commonParams);
var tmp;
//define dew point gauge start values
cache.sections = createTempSections(true);
cache.areas = [];
cache.minValue = gaugeGlobals.tempScaleDefMinC;
cache.maxValue = gaugeGlobals.tempScaleDefMaxC;
cache.value = gaugeGlobals.tempScaleDefMinC + 0.0001;
// Has the end user selected a preferred 'scale' before
tmp = getCookie('dewGauge');
cache.selected = tmp !== null ? tmp : config.dewDisplayType;
setRadioCheck('rad_dew', cache.selected);
switch (cache.selected) {
case 'dew':
cache.title = strings.dew_title;
cache.popupImg = 0;
break;
case 'app':
cache.title = strings.apptemp_title;
cache.popupImg = 1;
break;
case 'wnd':
cache.title = strings.chill_title;
cache.popupImg = 2;
break;
case 'hea':
cache.title = strings.heat_title;
cache.popupImg = 3;
break;
case 'hum':
cache.title = strings.humdx_title;
cache.popupImg = 4;
// no default
}
cache.minMeasuredVisible = false;
cache.maxMeasuredVisible = false;
// create dew point radial gauge
if ($('#canvas_dew').length) {
params.size = Math.ceil($('#canvas_dew').width() * config.gaugeScaling);
params.section = cache.sections;
params.gaugeType = steelseries.GaugeType.TYPE4;
params.area = cache.areas;
params.minValue = cache.minValue;
params.maxValue = cache.maxValue;
params.thresholdVisible = false;
params.titleString = cache.title;
params.unitString = data.tempunit;
ssGauge = new steelseries.Radial('canvas_dew', params);
ssGauge.setValue(cache.value);
// over-ride CSS applied size?
if (config.gaugeScaling !== 1) {
$('#canvas_dew').css({width: params.size + 'px', height: params.size + 'px'});
}
// add a shadow to the gauge
if (config.showGaugeShadow) {
$('#canvas_dew').css(gaugeShadow(params.size));
}
// subcribe to data updates
$.subscribe('gauges.dataUpdated', update);
$.subscribe('gauges.graphUpdate', updateGraph);
} else {
// cannot draw gauge, return null
return null;
}
function update() {
// if rad isn't specified, just use existing value
var sel = cache.selected;
// Argument length === 2 when called from event handler
if (arguments.length === 1) {
sel = arguments[0].value;
// save the choice in a cookie
setCookie('dewGauge', sel);
}
var tip, scaleStep;
cache.minValue = data.tempunit[1] === 'C' ? gaugeGlobals.tempScaleDefMinC : gaugeGlobals.tempScaleDefMinF;
cache.maxValue = data.tempunit[1] === 'C' ? gaugeGlobals.tempScaleDefMaxC : gaugeGlobals.tempScaleDefMaxF;
cache.lowScale = getMinTemp(cache.minValue);
cache.highScale = getMaxTemp(cache.maxValue);
switch (sel) {
case 'dew': // dew point
cache.low = extractDecimal(data.dewpointTL);
cache.high = extractDecimal(data.dewpointTH);
cache.value = extractDecimal(data.dew);
cache.areas = [steelseries.Section(+cache.low, +cache.high, gaugeGlobals.minMaxArea)];
cache.title = strings.dew_title;
cache.minMeasuredVisible = false;
cache.maxMeasuredVisible = false;
cache.popupImg = 0;
tip = strings.dew_info + ':' +
'
' +
'- ' + strings.lowest_info + ': ' + cache.low + data.tempunit + ' ' + strings.at + ' ' + data.TdewpointTL +
' | ' + strings.highest_info + ': ' + cache.high + data.tempunit + ' ' + strings.at + ' ' + data.TdewpointTH;
break;
case 'app': // apparent temperature
cache.low = extractDecimal(data.apptempTL);
cache.high = extractDecimal(data.apptempTH);
cache.value = extractDecimal(data.apptemp);
cache.areas = [steelseries.Section(+cache.low, +cache.high, gaugeGlobals.minMaxArea)];
cache.title = strings.apptemp_title;
cache.minMeasuredVisible = false;
cache.maxMeasuredVisible = false;
cache.popupImg = 1;
tip = tip = strings.apptemp_info + ':' +
'
' +
'- ' + strings.lowestF_info + ': ' + cache.low + data.tempunit + ' ' + strings.at + ' ' + data.TapptempTL +
' | ' + strings.highestF_info + ': ' + cache.high + data.tempunit + ' ' + strings.at + ' ' + data.TapptempTH;
break;
case 'wnd': // wind chill
cache.low = extractDecimal(data.wchillTL);
cache.high = extractDecimal(data.wchill);
cache.value = extractDecimal(data.wchill);
cache.areas = [];
cache.title = strings.chill_title;
cache.minMeasuredVisible = true;
cache.maxMeasuredVisible = false;
cache.popupImg = 2;
tip = strings.chill_info + ':' +
'
' +
'- ' + strings.lowest_info + ': ' + cache.low + data.tempunit + ' ' + strings.at + ' ' + data.TwchillTL;
break;
case 'hea': // heat index
cache.low = extractDecimal(data.heatindex);
cache.high = extractDecimal(data.heatindexTH);
cache.value = extractDecimal(data.heatindex);
cache.areas = [];
cache.title = strings.heat_title;
cache.minMeasuredVisible = false;
cache.maxMeasuredVisible = true;
cache.popupImg = 3;
tip = strings.heat_info + ':' +
'
' +
'- ' + strings.highest_info + ': ' + cache.high + data.tempunit + ' ' + strings.at + ' ' + data.TheatindexTH;
break;
case 'hum': // humidex
cache.low = extractDecimal(data.humidex);
cache.high = extractDecimal(data.humidex);
cache.value = extractDecimal(data.humidex);
cache.areas = [];
cache.title = strings.humdx_title;
cache.minMeasuredVisible = false;
cache.maxMeasuredVisible = false;
cache.popupImg = 4;
tip = strings.humdx_info + ': ' + cache.value + data.tempunit;
break;
// no default
}
if (cache.selected !== sel) {
cache.selected = sel;
// change gauge title
ssGauge.setTitleString(cache.title);
// and graph image
if (config.showPopupGraphs && config.tipImgs[1][cache.popupImg] !== null) {
var cacheDefeat = '?' + $('#imgtip1_img').attr('src').split('?')[1];
$('#imgtip1_img').attr('src', config.imgPathURL + config.tipImgs[1][cache.popupImg] + cacheDefeat);
}
}
//auto scale the ranges
scaleStep = data.tempunit[1] === 'C' ? 10 : 20;
while (cache.lowScale < cache.minValue) {
cache.minValue -= scaleStep;
if (cache.highScale <= cache.maxValue - scaleStep) {
cache.maxValue -= scaleStep;
}
}
while (cache.highScale > cache.maxValue) {
cache.maxValue += scaleStep;
if (cache.minValue >= cache.minValue + scaleStep) {
cache.minValue += scaleStep;
}
}
if (cache.minValue !== ssGauge.getMinValue() || cache.maxValue !== ssGauge.getMaxValue()) {
ssGauge.setMinValue(cache.minValue);
ssGauge.setMaxValue(cache.maxValue);
ssGauge.setValue(cache.minValue);
}
ssGauge.setMinMeasuredValueVisible(cache.minMeasuredVisible);
ssGauge.setMaxMeasuredValueVisible(cache.maxMeasuredVisible);
ssGauge.setMinMeasuredValue(+cache.low);
ssGauge.setMaxMeasuredValue(+cache.high);
ssGauge.setArea(cache.areas);
ssGauge.setValueAnimated(+cache.value);
if (ddimgtooltip.showTips) {
// update tooltip
$('#imgtip1_txt').html(tip);
}
}
function updateGraph(evnt, cacheDefeat) {
if (config.tipImgs[1][cache.popupImg] !== null) {
$('#imgtip1_img').attr('src', config.imgPathURL + config.tipImgs[1][cache.popupImg] + cacheDefeat);
}
}
return {
data : cache,
update: update,
gauge : ssGauge
};
} // End of init()
return {
// Get the Singleton instance if one exists
// or create one if it doesn't
getInstance: function () {
if (!instance) {
instance = init();
}
return instance;
}
};
})(), // End of singleDew()
singleRain = (function () {
var instance; // Stores a reference to the Singleton
var ssGauge; // Stores a reference to the SS Gauge
var cache = {}; // Stores various config values and parameters
function init() {
var params = $.extend(true, {}, commonParams);
// define rain gauge start values
cache.maxValue = gaugeGlobals.rainScaleDefMaxmm;
cache.value = 0.0001;
cache.title = strings.rain_title;
cache.lcdDecimals = 1;
cache.scaleDecimals = 1;
cache.labelNumberFormat = gaugeGlobals.labelFormat;
cache.sections = (gaugeGlobals.rainUseSectionColours ? createRainfallSections(true) : []);
cache.valGrad = (gaugeGlobals.rainUseGradientColours ? createRainfallGradient(true) : null);
// create rain radial bargraph gauge
if ($('#canvas_rain').length) {
params.size = Math.ceil($('#canvas_rain').width() * config.gaugeScaling);
params.maxValue = cache.maxValue;
params.thresholdVisible = false;
params.titleString = cache.title;
params.unitString = data.rainunit;
params.valueColor = steelseries.ColorDef.BLUE;
params.gaugeType = steelseries.GaugeType.TYPE4;
params.valueGradient = cache.valGrad;
params.useValueGradient = gaugeGlobals.rainUseGradientColours;
params.useSectionColors = gaugeGlobals.rainUseSectionColour;
params.useSectionColors = gaugeGlobals.rainUseSectionColours;
params.labelNumberFormat = cache.labelNumberFormat;
params.fractionalScaleDecimals = cache.scaleDecimals;
ssGauge = new steelseries.RadialBargraph('canvas_rain', params);
ssGauge.setValue(cache.value);
// over-ride CSS applied size?
if (config.gaugeScaling !== 1) {
$('#canvas_rain').css({width: params.size + 'px', height: params.size + 'px'});
}
// add a shadow to the gauge
if (config.showGaugeShadow) {
$('#canvas_rain').css(gaugeShadow(params.size));
}
// subcribe to data updates
$.subscribe('gauges.dataUpdated', update);
$.subscribe('gauges.graphUpdate', updateGraph);
} else {
// cannot draw gauge, return null
return null;
}
function update() {
cache.value = extractDecimal(data.rfall);
if (data.rainunit === 'mm') { // 10, 20, 30...
cache.maxValue = Math.max(Math.ceil(cache.value / 10) * 10, gaugeGlobals.rainScaleDefMaxmm);
} else {
// inches 0.5, 1.0, 2.0, 3.0 ... 10.0, 12.0, 14.0
if (cache.value < 6) {
cache.maxValue = Math.max(Math.ceil(cache.value), gaugeGlobals.rainRateScaleDefMaxIn);
} else {
cache.maxValue = Math.max(Math.ceil(cache.value / 2) * 2, gaugeGlobals.rainRateScaleDefMaxIn);
}
cache.scaleDecimals = cache.maxValue < 1 ? 2 : 1;
}
if (cache.maxValue !== ssGauge.getMaxValue()) {
ssGauge.setValue(0);
ssGauge.setFractionalScaleDecimals(cache.scaleDecimals);
ssGauge.setMaxValue(cache.maxValue);
}
ssGauge.setValueAnimated(cache.value);
if (ddimgtooltip.showTips) {
// update tooltip
$('#imgtip2_txt').html(strings.LastRain_info + ': ' + data.LastRained);
}
} // End of update()
function updateGraph(evnt, cacheDefeat) {
if (config.tipImgs[2] !== null) {
$('#imgtip2_img').attr('src', config.imgPathURL + config.tipImgs[2] + cacheDefeat);
}
}
return {
data : cache,
update: update,
gauge : ssGauge
};
} // End of init()
return {
// Get the Singleton instance if one exists
// or create one if it doesn't
getInstance: function () {
if (!instance) {
instance = init();
}
return instance;
}
};
})(),
singleRRate = (function () {
var instance; // Stores a reference to the Singleton
var ssGauge; // Stores a reference to the SS Gauge
var cache = {}; // Stores various config values and parameters
function init() {
var params = $.extend(true, {}, commonParams);
// define rain rate gauge start values
cache.maxMeasured = 0;
cache.maxValue = gaugeGlobals.rainRateScaleDefMaxmm;
cache.value = 0.0001;
cache.title = strings.rrate_title;
cache.lcdDecimals = 1;
cache.scaleDecimals = 0;
cache.labelNumberFormat = gaugeGlobals.labelFormat;
cache.sections = createRainRateSections(true);
// create rain rate radial gauge
if ($('#canvas_rrate').length) {
params.size = Math.ceil($('#canvas_rrate').width() * config.gaugeScaling);
params.section = cache.sections;
params.maxValue = cache.maxValue;
params.thresholdVisible = false;
params.maxMeasuredValueVisible = true;
params.gaugeType = steelseries.GaugeType.TYPE4;
params.titleString = cache.title;
params.unitString = data.rainunit + '/h';
params.lcdDecimals = cache.lcdDecimals;
params.labelNumberFormat = cache.labelNumberFormat;
params.fractionalScaleDecimals = cache.scaleDecimals;
params.niceScale = false;
ssGauge = new steelseries.Radial('canvas_rrate', params);
ssGauge.setMaxMeasuredValue(cache.maxMeasured);
ssGauge.setValue(cache.value);
// over-ride CSS applied size?
if (config.gaugeScaling !== 1) {
$('#canvas_rrate').css({width: params.size + 'px', height: params.size + 'px'});
}
// add a shadow to the gauge
if (config.showGaugeShadow) {
$('#canvas_rrate').css(gaugeShadow(params.size));
}
// subcribe to data updates
$.subscribe('gauges.dataUpdated', update);
$.subscribe('gauges.graphUpdate', updateGraph);
} else {
// cannot draw gauge, return null
return null;
}
function update() {
var tip;
cache.value = extractDecimal(data.rrate);
cache.maxMeasured = extractDecimal(data.rrateTM);
cache.overallMax = Math.max(cache.maxMeasured, cache.value); // workaround for VWS bug, not supplying correct max value today
if (data.rainunit === 'mm') { // 10, 20, 30...
cache.maxValue = Math.max(Math.ceil(cache.overallMax / 10) * 10, gaugeGlobals.rainRateScaleDefMaxmm);
} else {
// inches 0.5, 1.0, 2.0, 3.0 ... 10.0, 12.0, 14.0
if (cache.value < 6) {
cache.maxValue = Math.max(Math.ceil(cache.value), gaugeGlobals.rainRateScaleDefMaxIn);
} else {
cache.maxValue = Math.max(Math.ceil(cache.value / 2) * 2, gaugeGlobals.rainRateScaleDefMaxIn);
}
cache.scaleDecimals = cache.maxValue < 1 ? 2 : 1;
}
if (cache.maxValue !== ssGauge.getMaxValue()) {
ssGauge.setValue(0);
ssGauge.setFractionalScaleDecimals(cache.scaleDecimals);
ssGauge.setMaxValue(cache.maxValue);
}
ssGauge.setValueAnimated(cache.value);
ssGauge.setMaxMeasuredValue(cache.maxMeasured);
if (ddimgtooltip.showTips) {
// update tooltip
tip = strings.rrate_info + ':
' +
'- ' + strings.maximum_info + ': ' + data.rrateTM + ' ' + data.rainunit + '/h ' + strings.at + ' ' + data.TrrateTM;
$('#imgtip3_txt').html(tip);
}
} // End of update()
function updateGraph(evnt, cacheDefeat) {
if (config.tipImgs[3] !== null) {
$('#imgtip3_img').attr('src', config.imgPathURL + config.tipImgs[3] + cacheDefeat);
}
}
return {
data : cache,
update: update,
gauge : ssGauge
};
} // End of init()
return {
// Get the Singleton instance if one exists
// or create one if it doesn't
getInstance: function () {
if (!instance) {
instance = init();
}
return instance;
}
};
})(),
singleHum = (function () {
var instance; // Stores a reference to the Singleton
var ssGauge; // Stores a reference to the SS Gauge
var cache = {}; // Stores various config values and parameters
function init() {
var params = $.extend(true, {}, commonParams);
// define humidity gauge start values
cache.areas = [];
cache.value = 0.0001;
cache.title = strings.hum_title_out;
cache.selected = 'out';
// create humidity radial gauge
if ($('#canvas_hum').length) {
params.size = Math.ceil($('#canvas_hum').width() * config.gaugeScaling);
params.section = [steelseries.Section(0, 20, 'rgba(139, 117, 0, 0.5)'),
steelseries.Section(20, 40, 'rgba(180, 152, 4, 0.3)'),
steelseries.Section(40, 60, 'rgba(170, 212, 4, 0.38)'),
steelseries.Section(60, 80, 'rgba(0, 180, 18,0.3)'),
steelseries.Section(80, 100, 'rgba(0, 180, 18, 0.5)')];
params.area = cache.areas;
params.maxValue = 100;
params.thresholdVisible = false;
params.gaugeType = steelseries.GaugeType.TYPE4;
params.titleString = cache.title;
params.unitString = 'RH%';
ssGauge = new steelseries.Radial('canvas_hum', params);
ssGauge.setValue(cache.value);
// over-ride CSS applied size?
if (config.gaugeScaling !== 1) {
$('#canvas_hum').css({width: params.size + 'px', height: params.size + 'px'});
}
// add a shadow to the gauge
if (config.showGaugeShadow) {
$('#canvas_hum').css(gaugeShadow(params.size));
}
// subcribe to data updates
$.subscribe('gauges.dataUpdated', update);
$.subscribe('gauges.graphUpdate', updateGraph);
} else {
// cannot draw gauge, return null
return null;
}
function update() {
var radio;
// Argument length === 2 when called from event handler
if (arguments.length === 1) {
radio = arguments[0];
}
//if rad isn't specified, just use existing value
var sel = (typeof radio === 'undefined' ? cache.selected : radio.value),
tip;
if (sel === 'out') {
cache.value = extractDecimal(data.hum);
cache.areas = [steelseries.Section(+extractDecimal(data.humTL), +extractDecimal(data.humTH), gaugeGlobals.minMaxArea)];
cache.title = strings.hum_title_out;
cache.popupImg = 0;
} else {
cache.value = extractDecimal(data.inhum);
if (data.inhumTL && data.inhumTH) {
cache.areas = [steelseries.Section(+extractDecimal(data.inhumTL), +extractDecimal(data.inhumTH), gaugeGlobals.minMaxArea)];
} else {
cache.areas = [];
}
cache.title = strings.hum_title_in;
cache.popupImg = 1;
}
if (cache.selected !== sel) {
cache.selected = sel;
//Change gauge title
ssGauge.setTitleString(cache.title);
if (config.showPopupGraphs && config.tipImgs[4][cache.popupImg] !== null) {
var cacheDefeat = '?' + $('#imgtip4_img').attr('src').split('?')[1];
$('#imgtip4_img').attr('src', config.imgPathURL + config.tipImgs[4][cache.popupImg] + cacheDefeat);
}
}
ssGauge.setArea(cache.areas);
ssGauge.setValueAnimated(cache.value);
if (ddimgtooltip.showTips) {
//update tooltip
if (cache.selected === 'out') {
tip = strings.hum_out_info + ':' +
'
' +
'- ' + strings.minimum_info + ': ' + extractDecimal(data.humTL) + '% ' + strings.at + ' ' + data.ThumTL +
' | ' + strings.maximum_info + ': ' + extractDecimal(data.humTH) + '% ' + strings.at + ' ' + data.ThumTH;
} else if (data.inhumTL && data.inhumTH) {
// we have indoor high/low data
tip = strings.hum_in_info + ':' +
'
' +
'- ' + strings.minimum_info + ': ' + extractDecimal(data.inhumTL) + '% ' + strings.at + ' ' + data.TinhumTL +
' | ' + strings.maximum_info + ': ' + extractDecimal(data.inhumTH) + '% ' + strings.at + ' ' + data.TinhumTH;
} else {
// no indoor high/low data
tip = strings.hum_in_info + ': ' + extractDecimal(data.inhum) + '%';
}
$('#imgtip4_txt').html(tip);
}
} // End of update()
function updateGraph(evnt, cacheDefeat) {
if (config.tipImgs[4][cache.popupImg] !== null) {
$('#imgtip4_img').attr('src', config.imgPathURL + config.tipImgs[4][cache.popupImg] + cacheDefeat);
}
}
return {
data : cache,
update: update,
gauge : ssGauge
};
} // End of init()
return {
// Get the Singleton instance if one exists
// or create one if it doesn't
getInstance: function () {
if (!instance) {
instance = init();
}
return instance;
}
};
})(),
singleBaro = (function () {
var instance; // Stores a reference to the Singleton
var ssGauge; // Stores a reference to the SS Gauge
var cache = {}; // Stores various config values and parameters
function init() {
var params = $.extend(true, {}, commonParams);
// define pressure/barometer gauge start values
cache.sections = [];
cache.areas = [];
cache.minValue = gaugeGlobals.baroScaleDefMinhPa;
cache.maxValue = gaugeGlobals.baroScaleDefMaxhPa;
cache.value = cache.minValue + 0.0001;
cache.title = strings.baro_title;
cache.lcdDecimals = 1;
cache.scaleDecimals = 0;
cache.labelNumberFormat = gaugeGlobals.labelFormat;
// create pressure/barometric radial gauge
if ($('#canvas_baro').length) {
params.size = Math.ceil($('#canvas_baro').width() * config.gaugeScaling);
params.section = cache.sections;
params.area = cache.areas;
params.minValue = cache.minValue;
params.maxValue = cache.maxValue;
params.niceScale = false;
params.thresholdVisible = false;
params.gaugeType = steelseries.GaugeType.TYPE4;
params.titleString = cache.title;
params.unitString = data.pressunit;
params.lcdDecimals = cache.lcdDecimals;
params.trendVisible = gaugeGlobals.pressureTrendVisible;
params.labelNumberFormat = cache.labelNumberFormat;
params.fractionalScaleDecimals = cache.scaleDecimals;
ssGauge = new steelseries.Radial('canvas_baro', params);
ssGauge.setValue(cache.value);
// over-ride CSS applied size?
if (config.gaugeScaling !== 1) {
$('#canvas_baro').css({width: params.size + 'px', height: params.size + 'px'});
}
// add a shadow to the gauge
if (config.showGaugeShadow) {
$('#canvas_baro').css(gaugeShadow(params.size));
}
// subcribe to data updates
$.subscribe('gauges.dataUpdated', update);
$.subscribe('gauges.graphUpdate', updateGraph);
} else {
// cannot draw gauge, return null
return null;
}
function update() {
var tip, t1, dps;
cache.recLow = +extractDecimal(data.pressL);
cache.recHigh = +extractDecimal(data.pressH);
cache.todayLow = +extractDecimal(data.pressTL);
cache.todayHigh = +extractDecimal(data.pressTH);
cache.value = +extractDecimal(data.press);
// Convert the WD change over 3 hours to an hourly rate
cache.trendVal = +extractDecimal(data.presstrendval) / (config.weatherProgram === 2 ? 3 : 1);
if (data.pressunit === 'hPa' || data.pressunit === 'mb') {
// min range 990-1030 - steps of 10 hPa
cache.minValue = Math.min(Math.floor((cache.recLow - 2) / 10) * 10, gaugeGlobals.baroScaleDefMinhPa);
cache.maxValue = Math.max(Math.ceil((cache.recHigh + 2) / 10) * 10, gaugeGlobals.baroScaleDefMaxhPa);
dps = 1; // 1 decimal place
} else if (data.pressunit === 'kPa') {
// min range 99-105 - steps of 1 kPa
cache.minValue = Math.min(Math.floor(cache.recLow - 0.2), 99);
cache.maxValue = Math.max(Math.ceil(cache.recHigh + 0.2), 105);
dps = 2;
} else {
// inHg: min range 29.5-30.5 - steps of 0.5 inHg
cache.minValue = Math.min(Math.floor((cache.recLow - 0.1) * 2) / 2, gaugeGlobals.baroScaleDefMininHg);
cache.maxValue = Math.max(Math.ceil((cache.recHigh + 0.1) * 2) / 2, gaugeGlobals.baroScaleDefMaxinHg);
dps = 3;
}
cache.trendValRnd = cache.trendVal.toFixed(dps);
cache.todayLowRnd = cache.todayLow.toFixed(dps);
cache.todayHighRnd = cache.todayHigh.toFixed(dps);
if (cache.minValue !== ssGauge.getMinValue() || cache.maxValue !== ssGauge.getMaxValue()) {
ssGauge.setMinValue(cache.minValue);
ssGauge.setMaxValue(cache.maxValue);
ssGauge.setValue(cache.minValue);
}
if (cache.recHigh === cache.todayHigh && cache.recLow === cache.todayLow) {
// VWS does not provide record hi/lo values
cache.sections = [];
cache.areas = [steelseries.Section(cache.todayLow, cache.todayHigh, gaugeGlobals.minMaxArea)];
} else {
cache.sections = [
steelseries.Section(cache.minValue, cache.recLow, 'rgba(255,0,0,0.5)'),
steelseries.Section(cache.recHigh, cache.maxValue, 'rgba(255,0,0,0.5)')
];
cache.areas = [
steelseries.Section(cache.minValue, cache.recLow, 'rgba(255,0,0,0.5)'),
steelseries.Section(cache.recHigh, cache.maxValue, 'rgba(255,0,0,0.5)'),
steelseries.Section(cache.todayLow, cache.todayHigh, gaugeGlobals.minMaxArea)
];
}
if (gaugeGlobals.pressureTrendVisible) {
// Use the baroTrend rather than simple arithmetic test - steady is more/less than zero!
t1 = baroTrend(cache.trendVal, data.pressunit, false);
if (t1 === -9999) {
// trend value isn't currently available
cache.trend = steelseries.TrendState.OFF;
} else if (t1 > 0) {
cache.trend = steelseries.TrendState.UP;
} else if (t1 < 0) {
cache.trend = steelseries.TrendState.DOWN;
} else {
cache.trend = steelseries.TrendState.STEADY;
}
ssGauge.setTrend(cache.trend);
}
ssGauge.setArea(cache.areas);
ssGauge.setSection(cache.sections);
ssGauge.setValueAnimated(cache.value);
if (ddimgtooltip.showTips) {
// update tooltip
tip = strings.baro_info + ':' +
'
' +
'- ' + strings.minimum_info + ': ' + cache.todayLowRnd + ' ' + data.pressunit + ' ' + strings.at + ' ' + data.TpressTL +
' | ' + strings.maximum_info + ': ' + cache.todayHighRnd + ' ' + data.pressunit + ' ' + strings.at + ' ' + data.TpressTH;
if (cache.trendVal !== -9999) {
tip += '
' +
'- ' + strings.baro_trend_info + ': ' + baroTrend(cache.trendVal, data.pressunit, true) + ' ' +
(cache.trendValRnd > 0 ? '+' : '') + cache.trendValRnd + ' ' + data.pressunit + '/h';
}
$('#imgtip5_txt').html(tip);
}
} // End of update()
function updateGraph(evnt, cacheDefeat) {
if (config.tipImgs[5] !== null) {
$('#imgtip5_img').attr('src', config.imgPathURL + config.tipImgs[5] + cacheDefeat);
}
}
return {
data : cache,
update: update,
gauge : ssGauge
};
} // End of init()
return {
// Get the Singleton instance if one exists
// or create one if it doesn't
getInstance: function () {
if (!instance) {
instance = init();
}
return instance;
}
};
})(),
singleWind = (function () {
var instance; // Stores a reference to the Singleton
var ssGauge; // Stores a reference to the SS Gauge
var cache = {}; // Stores various config values and parameters
function init() {
var params = $.extend(true, {}, commonParams);
// define wind gauge start values
cache.maxValue = gaugeGlobals.windScaleDefMaxKph;
cache.areas = [];
cache.maxMeasured = 0;
cache.value = 0.0001;
cache.title = strings.wind_title;
// create wind speed radial gauge
if ($('#canvas_wind').length) {
params.size = Math.ceil($('#canvas_wind').width() * config.gaugeScaling);
params.area = cache.areas;
params.maxValue = cache.maxValue;
params.gaugeType = steelseries.GaugeType.TYPE4;
params.niceScale = false;
params.thresholdVisible = false;
params.maxMeasuredValueVisible = true;
params.titleString = cache.title;
params.unitString = data.windunit;
ssGauge = new steelseries.Radial('canvas_wind', params);
ssGauge.setMaxMeasuredValue(cache.maxMeasured);
ssGauge.setValue(cache.value);
// over-ride CSS applied size?
if (config.gaugeScaling !== 1) {
$('#canvas_wind').css({width: params.size + 'px', height: params.size + 'px'});
}
// add a shadow to the gauge
if (config.showGaugeShadow) {
$('#canvas_wind').css(gaugeShadow(params.size));
}
// subcribe to data updates
$.subscribe('gauges.dataUpdated', update);
$.subscribe('gauges.graphUpdate', updateGraph);
} else {
// cannot draw gauge, return null
return null;
}
function update() {
var tip;
cache.value = extractDecimal(data.wlatest);
cache.average = extractDecimal(data.wspeed);
cache.gust = extractDecimal(data.wgust);
cache.maxGustToday = extractDecimal(data.wgustTM);
cache.maxAvgToday = extractDecimal(data.windTM);
switch (data.windunit) {
case 'mph':
case 'kts':
cache.maxValue = Math.max(Math.ceil(cache.maxGustToday / 10) * 10, gaugeGlobals.windScaleDefMaxMph);
break;
case 'm/s':
cache.maxValue = Math.max(Math.ceil(cache.maxGustToday / 5) * 5, gaugeGlobals.windScaleDefMaxMs);
break;
default:
cache.maxValue = Math.max(Math.ceil(cache.maxGustToday / 20) * 20, gaugeGlobals.windScaleDefMaxKmh);
}
cache.areas = [
steelseries.Section(0, +cache.average, gaugeGlobals.windAvgArea),
steelseries.Section(+cache.average, +cache.gust, gaugeGlobals.minMaxArea)
];
if (cache.maxValue !== ssGauge.getMaxValue()) {
ssGauge.setMaxValue(cache.maxValue);
}
ssGauge.setArea(cache.areas);
ssGauge.setMaxMeasuredValue(cache.maxGustToday);
ssGauge.setValueAnimated(cache.value);
if (ddimgtooltip.showTips) {
// update tooltip
tip = strings.tenminavgwind_info + ': ' + cache.average + ' ' + data.windunit + ' | ' +
strings.maxavgwind_info + ': ' + cache.maxAvgToday + ' ' + data.windunit + '
' +
strings.tenmingust_info + ': ' + cache.gust + ' ' + data.windunit + ' | ' +
strings.maxgust_info + ': ' + cache.maxGustToday + ' ' + data.windunit + ' ' +
strings.at + ' ' + data.TwgustTM + ' ' + strings.bearing_info + ': ' + data.bearingTM +
(isNaN(parseFloat(data.bearingTM)) ? '' : '° (' + getord(+data.bearingTM) + ')');
$('#imgtip6_txt').html(tip);
}
} // End of update()
function updateGraph(evnt, cacheDefeat) {
if (config.tipImgs[6] !== null) {
$('#imgtip6_img').attr('src', config.imgPathURL + config.tipImgs[6] + cacheDefeat);
}
}
return {
data : cache,
update: update,
gauge : ssGauge
};
} // End of init()
return {
// Get the Singleton instance if one exists
// or create one if it doesn't
getInstance: function () {
if (!instance) {
instance = init();
}
return instance;
}
};
})(), // End of singleWind()
singleDir = (function () {
var instance;
var ssGauge;
var cache = {};
function init() {
var params = $.extend(true, {}, commonParams);
cache.valueLatest = 0;
cache.valueAverage = 0;
cache.titles = [strings.latest_web, strings.tenminavg_web];
if ($('#canvas_dir').length) {
params.size = Math.ceil($('#canvas_dir').width() * config.gaugeScaling);
params.pointerTypeLatest = gaugeGlobals.pointer;
params.pointerTypeAverage = gaugeGlobals.dirAvgPointer;
params.pointerColorAverage = gaugeGlobals.dirAvgPointerColour;
params.degreeScale = true;
params.pointSymbols = strings.compass;
params.roseVisible = false;
params.lcdTitleStrings = cache.titles;
params.useColorLabels = false;
ssGauge = new steelseries.WindDirection('canvas_dir', params);
ssGauge.setValueAverage(+cache.valueAverage);
ssGauge.setValueLatest(+cache.valueLatest);
if (config.gaugeScaling !== 1) {
$('#canvas_dir').css({width: params.size + 'px', height: params.size + 'px'});
}
if (config.showGaugeShadow) {
$('#canvas_dir').css(gaugeShadow(params.size));
}
$.subscribe('gauges.dataUpdated', update);
$.subscribe('gauges.graphUpdate', updateGraph);
} else {
return null;
}
function update() {
var windSpd, windGst, range, tip, i,
rosePoints = 0,
roseMax = 0,
roseSectionAngle = 0,
roseAreas = [];
cache.valueLatest = extractInteger(data.bearing);
cache.valueAverage = extractInteger(data.avgbearing);
cache.bearingFrom = extractInteger(data.BearingRangeFrom10);
cache.bearingTo = extractInteger(data.BearingRangeTo10);
ssGauge.setValueAnimatedAverage(+cache.valueAverage);
if (cache.valueAverage === 0) {
cache.valueLatest = 0;
}
ssGauge.setValueAnimatedLatest(+cache.valueLatest);
if (config.showWindVariation) {
windSpd = +extractDecimal(data.wspeed);
windGst = +extractDecimal(data.wgust);
switch (data.windunit.toLowerCase()) {
case 'mph':
cache.avgKnots = 0.868976242 * windSpd;
cache.gstKnots = 0.868976242 * windGst;
break;
case 'kts':
cache.avgKnots = windSpd;
cache.gstKnots = windGst;
break;
case 'm/s':
cache.avgKnots = 1.94384449 * windSpd;
cache.gstKnots = 1.94384449 * windGst;
break;
case 'km/h':
cache.avgKnots = 0.539956803 * windSpd;
cache.gstKnots = 0.539956803 * windGst;
break;
// no default
}
cache.avgKnots = Math.round(cache.avgKnots);
cache.gstKnots = Math.round(cache.gstKnots);
if (config.showWindMetar) {
ssGauge.VRB = ' - METAR: ' + ('0' + data.avgbearing).slice(-3) + ('0' + cache.avgKnots).slice(-2) +
'G' + ('0' + cache.gstKnots).slice(-2) + 'KT ';
} else {
ssGauge.VRB = '';
}
if (windSpd > 0) {
range = (+cache.bearingTo < +cache.bearingFrom ? 360 + (+cache.bearingTo) : +cache.bearingTo) - (+cache.bearingFrom);
if (cache.avgKnots < 3) {
if (config.showRoseOnDirGauge) {
ssGauge.setSection([steelseries.Section(cache.bearingFrom, cache.bearingTo, gaugeGlobals.windVariationSector)]);
ssGauge.setSection([]);
} else {
ssGauge.setSection([steelseries.Section(cache.bearingFrom, cache.bearingTo, gaugeGlobals.minMaxArea)]);
ssGauge.setArea([]);
}
} else if (config.showRoseOnDirGauge) {
ssGauge.setSection([steelseries.Section(cache.bearingFrom, cache.bearingTo, gaugeGlobals.windVariationSector)]);
} else {
ssGauge.setSection([]);
ssGauge.setArea([steelseries.Section(cache.bearingFrom, cache.bearingTo, gaugeGlobals.minMaxArea)]);
}
if (config.showWindMetar) {
if ((range < 60 && range > 0) || range === 0 && cache.bearingFrom === cache.valueAverage) {
ssGauge.VRB += ' STDY';
} else if (cache.avgKnots < 3) {
ssGauge.VRB += ' VRB';
} else {
ssGauge.VRB += ' ' + cache.bearingFrom + 'V' + cache.bearingTo;
}
}
} else {
if (config.showWindMetar) {
ssGauge.VRB = ' - METAR: 00000KT';
}
ssGauge.setSection([]);
if (!config.showRoseOnDirGauge) {
ssGauge.setArea([]);
}
}
} else {
ssGauge.VRB = '';
}
if (config.showRoseOnDirGauge && data.WindRoseData) {
rosePoints = data.WindRoseData.length;
roseSectionAngle = 360 / rosePoints;
for (i = 0; i < rosePoints; i++) {
roseMax = Math.max(roseMax, data.WindRoseData[i]);
}
if (roseMax > 0) {
for (i = 0; i < rosePoints; i++) {
roseAreas[i] = steelseries.Section(
i * roseSectionAngle - roseSectionAngle / 2,
(i + 1) * roseSectionAngle - roseSectionAngle / 2,
'rgba(' + gradient('2020D0', 'D04040', data.WindRoseData[i] / roseMax) + ',' +
(data.WindRoseData[i] / roseMax).toFixed(2) + ')'
);
}
}
ssGauge.setArea(roseAreas);
}
if (ddimgtooltip.showTips) {
tip = strings.latest_title + ' ' + strings.bearing_info + ': ' + cache.valueLatest + '° (' + getord(+cache.valueLatest) + ')' +
ssGauge.VRB + '
' + strings.tenminavg_web + ' ' + strings.bearing_info + ': ' + cache.valueAverage + '° (' +
getord(+cache.valueAverage) + '), ' + strings.dominant_bearing + ': ' + data.domwinddir;
if (!config.showRoseGauge) {
tip += '
' + strings.windruntoday + ': ' + data.windrun + ' ' + displayUnits.windrun;
}
$('#imgtip7_txt').html(tip);
}
}
function updateGraph(evnt, cacheDefeat) {
if (config.tipImgs[7] !== null) {
$('#imgtip7_img').attr('src', config.imgPathURL + config.tipImgs[7] + cacheDefeat);
}
}
return {
data : cache,
update: update,
gauge : ssGauge
};
}
return {
getInstance: function () {
if (!instance) {
instance = init();
}
return instance;
}
};
})(),
singleRose = (function () {
var instance;
var ssGauge;
var buffers = {};
var cache = {};
var ctxRoseCanvas;
cache.firstRun = true;
cache.odoDigits = 5;
function init() {
var div, roseCanvas;
if ($('#canvas_rose').length) {
cache.gaugeSize = Math.ceil($('#canvas_rose').width() * config.gaugeScaling);
cache.gaugeSize2 = cache.gaugeSize / 2;
cache.showOdo = config.showRoseGaugeOdo || false;
cache.compassString = strings.compass;
div = document.createElement('div');
div.style.display = 'none';
document.body.appendChild(div);
cache.plotSize = Math.floor(cache.gaugeSize * 0.68);
cache.plotSize2 = cache.plotSize / 2;
buffers.plot = document.createElement('canvas');
buffers.plot.width = cache.plotSize;
buffers.plot.height = cache.plotSize;
buffers.plot.id = 'rosePlot';
buffers.ctxPlot = buffers.plot.getContext('2d');
div.appendChild(buffers.plot);
buffers.frame = document.createElement('canvas');
buffers.frame.width = cache.gaugeSize;
buffers.frame.height = cache.gaugeSize;
buffers.ctxFrame = buffers.frame.getContext('2d');
steelseries.drawFrame(buffers.ctxFrame, gaugeGlobals.frameDesign, cache.gaugeSize2, cache.gaugeSize2, cache.gaugeSize, cache.gaugeSize);
buffers.background = document.createElement('canvas');
buffers.background.width = cache.gaugeSize;
buffers.background.height = cache.gaugeSize;
buffers.ctxBackground = buffers.background.getContext('2d');
steelseries.drawBackground(buffers.ctxBackground, gaugeGlobals.background, cache.gaugeSize2,
cache.gaugeSize2, cache.gaugeSize, cache.gaugeSize);
/*
if (g_imgSmall !== null) {
var drawSize = g_size * 0.831775;
var x = (g_size - drawSize) / 2;
buffers.ctxBackground.drawImage(g_imgSmall, x, x, cache.gaugeSize, cache.gaugeSize);
}
*/
drawCompassPoints(buffers.ctxBackground, cache.gaugeSize);
buffers.foreground = document.createElement('canvas');
buffers.foreground.width = cache.gaugeSize;
buffers.foreground.height = cache.gaugeSize;
buffers.ctxForeground = buffers.foreground.getContext('2d');
steelseries.drawForeground(buffers.ctxForeground, gaugeGlobals.foreground, cache.gaugeSize, cache.gaugeSize, false);
roseCanvas = document.getElementById('canvas_rose');
ctxRoseCanvas = roseCanvas.getContext('2d');
if (config.gaugeScaling !== 1) {
$('#canvas_rose').css({width: cache.gaugeSize + 'px', height: cache.gaugeSize + 'px'});
}
roseCanvas.width = cache.gaugeSize;
roseCanvas.height = cache.gaugeSize;
if (config.showGaugeShadow) {
$('#canvas_rose').css(gaugeShadow(cache.gaugeSize));
}
ctxRoseCanvas.drawImage(buffers.frame, 0, 0);
ctxRoseCanvas.drawImage(buffers.background, 0, 0);
ctxRoseCanvas.drawImage(buffers.foreground, 0, 0);
if (cache.showOdo) {
cache.odoHeight = Math.ceil(cache.gaugeSize * 0.08);
cache.odoWidth = Math.ceil(Math.floor(cache.odoHeight * 0.68) * cache.odoDigits);
buffers.Odo = document.createElement('canvas');
$(buffers.Odo).attr({
id : 'canvas_odo',
width : cache.odoWidth,
height: cache.odoHeight
});
$(buffers.Odo).css({
position: 'absolute',
top : Math.ceil(cache.gaugeSize * 0.7 + $('#canvas_rose').position().top) + 'px',
left : Math.ceil((cache.gaugeSize - cache.odoWidth) / 2 + $('#canvas_rose').position().left) + 'px'
});
$(buffers.Odo).insertBefore('#canvas_rose');
ssGauge = new steelseries.Odometer('canvas_odo', {
height : cache.odoHeight,
digits : cache.odoDigits - 1,
valueForeColor: "rgb(255, 255, 255)",
valueBackColor: "rgb(0, 0, 0)",
decimalForeColor: "rgb(255, 0, 0)",
decimalBackColor: "rgb(255, 255, 255)",
decimals: 1
});
}
$.subscribe('gauges.dataUpdated', update);
$.subscribe('gauges.graphUpdate', updateGraph);
} else {
return null;
}
cache.firstRun = false;
function update() {
var rose, offset;
if (ctxRoseCanvas && !cache.firstRun) {
ctxRoseCanvas.clearRect(0, 0, cache.gaugeSize, cache.gaugeSize);
buffers.ctxPlot.clearRect(0, 0, cache.plotSize, cache.plotSize);
rose = new RGraph.Rose('rosePlot', data.WindRoseData);
rose.Set('chart.strokestyle', 'black');
rose.Set('chart.background.axes.color', 'gray');
rose.Set('chart.colors.alpha', 0.5);
rose.Set('chart.colors', ['Gradient(#408040:red:#7070A0)']);
rose.Set('chart.margin', Math.ceil(40 / data.WindRoseData.length));
rose.Set('chart.title', cache.gaugeTitle);
rose.Set('chart.title.size', Math.ceil(0.05 * cache.plotSize));
rose.Set('chart.title.bold', false);
rose.Set('chart.title.color', gaugeGlobals.background.labelColor.getRgbColor());
rose.Set('chart.gutter.top', 0.2 * cache.plotSize);
rose.Set('chart.gutter.bottom', 0.2 * cache.plotSize);
rose.Set('chart.tooltips.effect', 'snap');
rose.Set('chart.labels.axes', '');
rose.Set('chart.background.circles', true);
rose.Set('chart.background.grid.spokes', 16);
rose.Set('chart.radius', cache.plotSize2);
rose.Draw();
ctxRoseCanvas.drawImage(buffers.frame, 0, 0);
ctxRoseCanvas.drawImage(buffers.background, 0, 0);
offset = Math.floor(cache.gaugeSize2 - cache.plotSize2);
ctxRoseCanvas.drawImage(buffers.plot, offset, offset);
ctxRoseCanvas.drawImage(buffers.foreground, 0, 0);
if (cache.showOdo) {
ssGauge.setValueAnimated(extractDecimal(data.windrun));
}
if (ddimgtooltip.showTips) {
$('#imgtip10_txt').html(strings.dominant_bearing + ': ' + data.domwinddir + '
' +
strings.windruntoday + ': ' + data.windrun + ' ' + displayUnits.windrun);
}
}
}
function updateGraph(evnt, cacheDefeat) {
if (config.tipImgs[10] !== null) {
$('#imgtip10_img').attr('src', config.imgPathURL + config.tipImgs[10] + cacheDefeat);
}
}
function drawCompassPoints(ctx, size) {
ctx.save();
ctx.font = 0.08 * size + 'px serif';
ctx.fillStyle = gaugeGlobals.background.labelColor.getRgbColor();
ctx.textAlign = 'center';
ctx.textBaseline = 'middle';
for (var i = 0; i < 4; i++) {
ctx.translate(size / 2, size * 0.125);
ctx.fillText(cache.compassString[i * 2], 0, 0, size);
ctx.translate(-size / 2, -size * 0.125);
ctx.translate(size / 2, size / 2);
ctx.rotate(Math.PI / 2);
ctx.translate(-size / 2, -size / 2);
}
ctx.restore();
}
function setTitle(newTitle) {
cache.gaugeTitle = newTitle;
}
function setCompassString(newStr) {
cache.compassString = newStr;
if (!cache.firstRun) {
steelseries.drawBackground(buffers.ctxBackground, gaugeGlobals.background, cache.gaugeSize2, cache.gaugeSize2,
cache.gaugeSize, cache.gaugeSize);
drawCompassPoints(buffers.ctxBackground, cache.gaugeSize);
}
}
return {
update : update,
gauge : ssGauge,
drawCompassPoints: drawCompassPoints,
setTitle : setTitle,
setCompassString : setCompassString
};
}
return {
getInstance: function () {
if (!instance) {
instance = init();
}
return instance;
}
};
})(),
singleUV = (function () {
var instance; // Stores a reference to the Singleton
var ssGauge; // Stores a reference to the SS Gauge
var cache = {}; // Stores various config values and parameters
function init() {
var params = $.extend(true, {}, commonParams);
// define UV start values
cache.value = 0.0001;
cache.sections = [
steelseries.Section(0, 2.9, '#289500'),
steelseries.Section(2.9, 5.8, '#f7e400'),
steelseries.Section(5.8, 7.8, '#f85900'),
steelseries.Section(7.8, 10.9, '#d8001d'),
steelseries.Section(10.9, 20, '#6b49c8')
];
// Define value gradient for UV
cache.gradient = new steelseries.gradientWrapper(0, 16,
[0, 0.1, 0.19, 0.31, 0.45, 0.625, 1],
[
new steelseries.rgbaColor(0, 200, 0, 1),
new steelseries.rgbaColor(0, 200, 0, 1),
new steelseries.rgbaColor(255, 255, 0, 1),
new steelseries.rgbaColor(248, 89, 0, 1),
new steelseries.rgbaColor(255, 0, 0, 1),
new steelseries.rgbaColor(255, 0, 144, 1),
new steelseries.rgbaColor(153, 140, 255, 1)
]
);
cache.useSections = false;
cache.useValueGradient = true;
// create UV bargraph gauge
if ($('#canvas_uv').length) {
params.size = Math.ceil($('#canvas_uv').width() * config.gaugeScaling);
params.gaugeType = steelseries.GaugeType.TYPE1;
params.maxValue = gaugeGlobals.uvScaleDefMax;
params.titleString = strings.uv_title;
params.niceScale = false;
params.section = cache.sections;
params.useSectionColors = cache.useSections;
params.valueGradient = cache.gradient;
params.useValueGradient = cache.useValueGradient;
params.lcdDecimals = gaugeGlobals.uvLcdDecimals;
ssGauge = new steelseries.RadialBargraph('canvas_uv', params);
ssGauge.setValue(cache.value);
// over-ride CSS applied size?
if (config.gaugeScaling !== 1) {
$('#canvas_uv').css({width: params.size + 'px', height: params.size + 'px'});
}
// add a shadow to the gauge
if (config.showGaugeShadow) {
$('#canvas_uv').css(gaugeShadow(params.size));
}
// subcribe to data updates
$.subscribe('gauges.dataUpdated', update);
$.subscribe('gauges.graphUpdate', updateGraph);
} else {
// cannot draw gauge, return null
return null;
}
function update() {
var tip, indx;
cache.value = extractDecimal(data.UV);
if (+cache.value === 0) {
indx = 0;
} else if (cache.value < 2.5) {
indx = 1;
} else if (cache.value < 5.5) {
indx = 2;
} else if (cache.value < 7.5) {
indx = 3;
} else if (cache.value < 10.5) {
indx = 4;
} else {
indx = 5;
}
if (cache.value > ssGauge.getMaxValue()) {
ssGauge.setMaxValue(Math.ceil(cache.value) + Math.ceil(cache.value) % 2);
}
cache.risk = strings.uv_levels[indx];
cache.headLine = strings.uv_headlines[indx];
cache.detail = strings.uv_details[indx];
ssGauge.setUnitString(cache.risk);
ssGauge.setValueAnimated(cache.value);
if (ddimgtooltip.showTips) {
// update tooltip
tip = '' + strings.uv_title + ': ' + cache.value + ' - ' + strings.solar_maxToday + ': ' + data.UVTH + '
';
tip += '' + cache.headLine + '
';
tip += cache.detail;
$('#imgtip8_txt').html(tip);
}
} // End of update()
function updateGraph(evnt, cacheDefeat) {
if (config.tipImgs[8] !== null) {
$('#imgtip8_img').attr('src', config.imgPathURL + config.tipImgs[8] + cacheDefeat);
}
}
return {
update: update,
gauge : ssGauge
};
} // End of init()
return {
// Get the Singleton instance if one exists
// or create one if it doesn't
getInstance: function () {
if (!instance) {
instance = init();
}
return instance;
}
};
})(),
singleSolar = (function () {
var instance; // Stores a reference to the Singleton
var ssGauge; // Stores a reference to the SS Gauge
var cache = {}; // Stores various config values and parameters
function init() {
var params = $.extend(true, {}, commonParams);
// define Solar start values
cache.value = 0.0001;
cache.sections = [
steelseries.Section(0, 200, 'rgba(47, 47, 47, 0.3)'),
steelseries.Section(200, 600, 'rgba(254, 251, 184, 0.3)'),
steelseries.Section(600, 800, 'rgba(232, 220, 56, 0.3)'),
steelseries.Section(800, 1000, 'rgba(255, 246, 24,0.3)'),
steelseries.Section(1000, 1800, 'rgba(255, 246, 24, 0.5)')
];
// create Solar gauge
if ($('#canvas_solar').length) {
params.size = Math.ceil($('#canvas_solar').width() * config.gaugeScaling);
params.section = cache.sections;
params.maxValue = gaugeGlobals.solarGaugeScaleMax;
params.titleString = strings.solar_title;
params.gaugeType = steelseries.GaugeType.TYPE4;
params.unitString = 'Wm\u207B\u00B2';
params.niceScale = false;
params.thresholdVisible = false;
params.lcdDecimals = 0;
if (config.showSunshineLed) {
params.userLedVisible = true;
params.userLedColor = steelseries.LedColor.YELLOW_LED;
}
ssGauge = new steelseries.Radial('canvas_solar', params);
ssGauge.setValue(cache.value);
// over-ride CSS applied size?
if (config.gaugeScaling !== 1) {
$('#canvas_solar').css({width: params.size + 'px', height: params.size + 'px'});
}
// add a shadow to the gauge
if (config.showGaugeShadow) {
$('#canvas_solar').css(gaugeShadow(params.size));
}
// subcribe to data updates
$.subscribe('gauges.dataUpdated', update);
$.subscribe('gauges.graphUpdate', updateGraph);
} else {
// cannot draw gauge, return null
return null;
}
function update() {
var tip, percent;
cache.value = +extractInteger(data.SolarRad);
cache.maxToday = extractInteger(data.SolarTM);
cache.currMaxValue = +extractInteger(data.CurrentSolarMax);
percent = (+cache.currMaxValue === 0 ? '--' : Math.round(+cache.value / +cache.currMaxValue * 100));
// Set a section (100 units wide) to show current theoretical max value
if (data.CurrentSolarMax !== 'N/A') {
ssGauge.setArea([steelseries.Section(cache.currMaxValue, Math.min(cache.currMaxValue + 100,
gaugeGlobals.solarGaugeScaleMax), 'rgba(220,0,0,0.5)')]);
}
// Need to rescale the gauge?
cache.maxValue = Math.max(
Math.ceil(cache.value / 100) * 100,
Math.ceil(cache.currMaxValue / 100) * 100,
Math.ceil(cache.maxToday / 100) * 100,
gaugeGlobals.solarGaugeScaleMax);
if (cache.maxValue !== ssGauge.getMaxValue()) {
ssGauge.setMaxValue(cache.maxValue);
}
// Set the values
ssGauge.setMaxMeasuredValue(cache.maxToday);
ssGauge.setValueAnimated(cache.value);
if (config.showSunshineLed) {
ssGauge.setUserLedOnOff(percent !== '--' &&
percent >= gaugeGlobals.sunshineThresholdPct &&
+cache.value >= gaugeGlobals.sunshineThreshold);
}
if (ddimgtooltip.showTips) {
// update tooltip
tip = '' + strings.solar_title + ': ' + cache.value + ' W/m²';
if (typeof data.SolarTM !== 'undefined') {
tip += '
' + strings.solar_maxToday + ': ' + cache.maxToday + ' W/m²';
}
$('#imgtip9_txt').html(tip);
}
} // End of update()
function updateGraph(evnt, cacheDefeat) {
if (config.tipImgs[9] !== null) {
$('#imgtip9_img').attr('src', config.imgPathURL + config.tipImgs[9] + cacheDefeat);
}
}
return {
update: update,
gauge : ssGauge
};
} // End of init()
return {
// Get the Singleton instance if one exists
// or create one if it doesn't
getInstance: function () {
if (!instance) {
instance = init();
}
return instance;
}
};
})(),
singleCloudBase = (function () {
var instance; // Stores a reference to the Singleton
var ssGauge; // Stores a reference to the SS Gauge
var cache = {}; // Stores various config values and parameters
function init() {
var params = $.extend(true, {}, commonParams);
cache.sections = createCloudBaseSections(true);
cache.value = 0.0001;
cache.maxValue = gaugeGlobals.cloudScaleDefMaxm;
// create Cloud base radial gauge
if ($('#canvas_cloud').length) {
params.size = Math.ceil($('#canvas_cloud').width() * config.gaugeScaling);
params.section = cache.sections;
params.maxValue = cache.maxValue;
params.titleString = strings.cloudbase_title;
params.unitString = strings.metres;
params.thresholdVisible = false;
params.lcdDecimals = 0;
ssGauge = new steelseries.Radial('canvas_cloud', params);
ssGauge.setValue(cache.value);
// over-ride CSS applied size?
if (config.gaugeScaling !== 1) {
$('#canvas_cloud').css({width: params.size + 'px', height: params.size + 'px'});
}
// add a shadow to the gauge
if (config.showGaugeShadow) {
$('#canvas_cloud').css(gaugeShadow(params.size));
}
// subcribe to data updates
$.subscribe('gauges.dataUpdated', update);
$.subscribe('gauges.graphUpdate', updateGraph);
} else {
// cannot draw gauge, return null
return null;
}
function update() {
cache.value = extractInteger(data.cloudbasevalue);
if (data.cloudbaseunit === 'm') {
// adjust metre gauge in jumps of 1000 metres, don't downscale during the session
cache.maxValue = Math.max(Math.ceil(cache.value / 1000) * 1000, gaugeGlobals.cloudScaleDefMaxm, cache.maxValue);
if (cache.value <= 1000 && config.roundCloudbaseVal) {
// and round the value to the nearest 10 m
cache.value = Math.round(cache.value / 10) * 10;
} else if (config.roundCloudbaseVal) {
// and round the value to the nearest 50 m
cache.value = Math.round(cache.value / 50) * 50;
}
} else {
// adjust feet gauge in jumps of 2000 ft, don't downscale during the session
cache.maxValue = Math.max(Math.ceil(cache.value / 2000) * 2000, gaugeGlobals.cloudScaleDefMaxft, cache.maxValue);
if (cache.value <= 2000 && config.roundCloudbaseVal) {
// and round the value to the nearest 50 ft
cache.value = Math.round(cache.value / 50) * 50;
} else if (config.roundCloudbaseVal) {
// and round the value to the nearest 100 ft
cache.value = Math.round(cache.value / 100) * 100;
}
}
if (cache.maxValue !== ssGauge.getMaxValue()) {
if (ssGauge.getMaxValue() > cache.maxValue) {
// Gauge currently showing more than our max (nice scale effct),
// so reset our max to match
cache.maxValue = ssGauge.getMaxValue();
} else {
// Gauge scale is too low, increase it.
// First set the pointer back to zero so we get a nice animation
ssGauge.setValue(0);
// and redraw the gauge with teh new scale
ssGauge.setMaxValue(cache.maxValue);
}
}
ssGauge.setValueAnimated(cache.value);
if (config.showPopupData) {
// static tooltip on cloud gauge
$('#imgtip11_txt').html('' + strings.cloudbase_popup_title + '
' + strings.cloudbase_popup_text);
}
} // End of update()
function updateGraph(evnt, cacheDefeat) {
if (config.tipImgs[11] !== null) {
$('#imgtip11_img').attr('src', config.imgPathURL + config.tipImgs[11] + cacheDefeat);
}
}
return {
data : cache,
update: update,
gauge : ssGauge
};
} // End of init()
return {
// Get the Singleton instance if one exists
// or create one if it doesn't
getInstance: function () {
if (!instance) {
instance = init();
}
return instance;
}
};
})(),
getRealtime = function () {
var url = config.realTimeURL;
if ($.active > 0) {
// kill any outstanding requests
jqXHR.abort();
}
if (config.longPoll) {
url += '?timestamp=' + timestamp;
}
jqXHR = $.ajax({url : url,
cache : (config.longPoll),
dataType: 'json',
timeout : config.longPoll ? (Math.min(config.realtimeInterval, 20) + 21) * 1000 : 21000 // 21 second time-out by default
}).done(function (data) {
checkRtResp(data);
}).fail(function (xhr, status, err) {
checkRtError(xhr, status, err);
});
},
//
// checkRtResp() called by the Ajax fetch once data has been downloaded
//
checkRtResp = function (response) {
var delay;
statusTimer.reset(config.longPoll ? 1 : config.realtimeInterval);
if (config.longPoll && response.status !== 'OK') {
checkRtError(null, 'PHP Error', response.status);
} else {
if (processData(response)) {
delay = ajaxDelay;
} else {
delay = 5;
}
if (delay > 0) {
downloadTimer = setTimeout(getRealtime, delay * 1000);
} else {
getRealtime();
}
}
},
//
// checkRtError() called by the Ajax fetch if an error occurs during the fetching realtimegauges.txt
//
checkRtError = function (xhr, status, error) {
if (xhr == null || xhr.statusText !== 'abort') {
clearTimeout(downloadTimer);
ledIndicator.setLedOnOff(false);
ledIndicator.setTitle(strings.led_title_unknown);
statusScroller.setText(status + ': ' + error);
downloadTimer = setTimeout(getRealtime, 5000);
}
},
//
// processData() massages the data returned in realtimegauges.txt, and posts a gauges.dataUpdated event to update the page
//
processData = function (dataObj) {
var str, dt, tm, today, now, then, tmp, elapsedMins, retVal;
if (config.longPoll) {
timestamp = dataObj.timestamp;
data = dataObj.data;
} else {
data = dataObj;
}
createSummary(data);
if (typeof data.ver !== 'undefined' && data.ver >= realtimeVer) {
try {
str = data.LastRainTipISO.split(' ');
dt = str[0].replace(/\//g, '-').split('-');
tm = str[1].split(':');
today = new Date();
today.setHours(0, 0, 0, 0);
if (typeof data.dateFormat === 'undefined') {
data.dateFormat = 'y/m/d';
} else {
data.dateFormat = data.dateFormat.replace('%', '');
}
if (data.dateFormat === 'y/m/d') {
then = new Date(dt[0], dt[1] - 1, dt[2], tm[0], tm[1], 0, 0);
} else if (data.dateFormat === 'd/m/y') {
then = new Date(dt[2], dt[1] - 1, dt[0], tm[0], tm[1], 0, 0);
} else {
then = new Date(dt[2], dt[0] - 1, dt[1], tm[0], tm[1], 0, 0);
}
if (then.getTime() >= today.getTime()) {
data.LastRained = strings.LastRainedT_info + ' ' + str[1];
} else if (then.getTime() + 86400000 >= today.getTime()) {
data.LastRained = strings.LastRainedY_info + ' ' + str[1];
} else {
data.LastRained = then.getDate().toString() + ' ' + strings.months[then.getMonth()] + ' ' + strings.at + ' ' + str[1];
}
} catch (e) {
data.LastRained = data.LastRainTipISO;
}
if (data.tempunit.length > 1) {
data.tempunit = data.tempunit.replace(/&\S*;/, '°');
} else {
data.tempunit = '°' + data.tempunit;
}
// Check for station off-line
now = Date.now();
tmp = data.timeUTC.split(',');
sampleDate = Date.UTC(tmp[0], tmp[1] - 1, tmp[2], tmp[3], tmp[4], tmp[5]);
if (now - sampleDate > config.stationTimeout * 60 * 1000) {
elapsedMins = Math.floor((now - sampleDate) / (1000 * 60));
ledIndicator.setLedColor(steelseries.LedColor.RED_LED);
ledIndicator.setTitle(strings.led_title_offline);
ledIndicator.blink(true);
if (elapsedMins < 120) {
tm = elapsedMins.toString() + ' ' + strings.StatusMinsAgo;
} else if (elapsedMins < 2 * 24 * 60) {
tm = Math.floor(elapsedMins / 60).toString() + ' ' + strings.StatusHoursAgo;
} else {
tm = Math.floor(elapsedMins / (60 * 24)).toString() + ' ' + strings.StatusDaysAgo;
}
data.forecast = strings.led_title_offline + ' ' + strings.StatusLastUpdate + ' ' + tm;
} else if (+data.SensorContactLost === 1) {
ledIndicator.setLedColor(steelseries.LedColor.RED_LED);
ledIndicator.setTitle(strings.led_title_lost);
ledIndicator.blink(true);
data.forecast = strings.led_title_lost;
} else {
ledIndicator.setLedColor(steelseries.LedColor.GREEN_LED);
ledIndicator.setTitle(strings.led_title_ok + '. ' + strings.StatusLastUpdate + ': ' + data.date);
ledIndicator.blink(false);
ledIndicator.setLedOnOff(true);
data.forecast = strings.StatusLastUpdate + ': ' + data.date;
}
data.forecast = $('').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, '');
};