Thành viên:Just Limorina/Gadget-clock.js
Giao diện
Chú ý: Sau khi lưu thay đổi trang, bạn phải xóa bộ nhớ đệm của trình duyệt để nhìn thấy các thay đổi. Google Chrome, Firefox, Internet Explorer và Safari: Giữ phím ⇧ Shift và nhấn nút Reload/Tải lại trên thanh công cụ của trình duyệt. Để biết chi tiết và hướng dẫn cho các trình duyệt khác, xem Trợ giúp:Xóa bộ nhớ đệm.
////////////////////////////////////////////////////////////////////////////////
//
// THIS CODE IS NOT APPROVED FOR USE IN/ON ANY OTHER UI ELEMENT OR PRODUCT COMPONENT.
// Copyright (c) 2009 Microsoft Corporation. All rights reserved.
//
////////////////////////////////////////////////////////////////////////////////
var clockThemes = new Array("trad", "system", "cronometer", "diner", "flower", "modern", "square", "novelty");
var newPositionMinutes = 0;
var currentPositionMinutes = 0;
var newPositionHours = 0;
var currentPositionHours = 0;
var midClockNameFontHeight = 8;
var maxClockNameWidth = 60;
var posClockNameTop = 75;
var clockPartsWidth;
var clockPartsHeight;
var clockPartsTop;
var clockPartsLeft;
var date;
var intervalTime;
var newTimeOut;
var clockFont;
var clockFontColor;
var clockFontSize;
////////////////////////////////////////////////////////////////////////////////
//
// load initial settings
//
////////////////////////////////////////////////////////////////////////////////
function loadMain()
{
settingsChanged();
System.Gadget.settingsUI = "settings.html";
System.Gadget.onSettingsClosed = settingsClosed;
System.Gadget.visibilityChanged = visibilityChanged;
h.addShadow("grey", 2, 40, 2, 2);
m.addShadow("grey", 2, 40, 2, 2);
s.addShadow("grey", 2, 40, 2, 2);
}
////////////////////////////////////////////////////////////////////////////////
//
// set theme images
//
////////////////////////////////////////////////////////////////////////////////
function setImages()
{
var curTheme = clockThemes[mySetting.themeID];
clockBg.src = "url(images/" + curTheme + ".png)";
h.src = "images/" + curTheme + "_h.png";
m.src = "images/" + curTheme + "_m.png";
s.src = "images/" + curTheme + "_s.png";
dot.src = "images/" + curTheme + "_dot.png";
}
////////////////////////////////////////////////////////////////////////////////
//
// calculate current time
//
////////////////////////////////////////////////////////////////////////////////
function timePerInterval()
{
refreshDate();
with (date)
{
hours = getHours();
minutes = getMinutes();
seconds = getSeconds();
}
var rotationHours = hours;
if (hours > 12)
{
rotationHours = hours - 12;
}
h.Rotation = (rotationHours * 30) + (minutes / 2);
m.Rotation = (minutes * 6) + (seconds / 10);
if (mySetting.secondsEnabled)
{
s.Rotation = (seconds * 6);
var secondOffset = secondTimeOffset();
if (secondOffset > 0)
{
newTimeOut = setTimeout("timePerInterval()", secondOffset);
}
else
{
timePerInterval();
}
}
else
{
var minuteOffset = minuteTimeOffset();
if (minuteOffset > 0)
{
newTimeOut = setTimeout("timePerInterval()", minuteOffset);
}
else
{
timePerInterval();
}
}
}
////////////////////////////////////////////////////////////////////////////////
//
//
////////////////////////////////////////////////////////////////////////////////
function visibilityChanged()
{
if (System.Gadget.visible)
{
if (!newTimeOut)
{
timePerInterval();
}
}
else
{
clearTimeout(newTimeOut);
newTimeOut = null;
}
}
////////////////////////////////////////////////////////////////////////////////
//
// updates the tooltip with the current time
//
////////////////////////////////////////////////////////////////////////////////
function updateTooltip()
{
refreshDate();
highlights.title = clockTime.alt = date.toLocaleTimeString();
}
////////////////////////////////////////////////////////////////////////////////
//
// updates the date object with the current system time
//
////////////////////////////////////////////////////////////////////////////////
function refreshDate()
{
if (mySetting.timeZoneIndex != -1 && getValidTimeZone(mySetting.timeZoneIndex) != -1)
{
date = new Date(System.Time.getLocalTime(zones.item(mySetting.timeZoneIndex)));
}
else
{
date = new Date(System.Time.getLocalTime(System.Time.currentTimeZone));
}
}
////////////////////////////////////////////////////////////////////////////////
//
// settings event closed
//
////////////////////////////////////////////////////////////////////////////////
function settingsClosed(event)
{
if (event.closeAction == event.Action.commit)
{
settingsChanged();
}
}
////////////////////////////////////////////////////////////////////////////////
//
// set clock to the new settings
//
////////////////////////////////////////////////////////////////////////////////
function settingsChanged()
{
mySetting.load();
if (mySetting.timeZoneIndex != -1 && zonesCount == 0)
{
updateTimeZones();
}
var topPX = 0;
var leftPX = 0;
clockFont = "Segoe UI, Tahoma, Sans-Serif";
clockFontColor = "#000000";
clockFontSize = 10;
var curTheme = clockThemes[getValidThemeID(mySetting.themeID)];
switch (curTheme)
{
case "trad":
clockFont = "Constantia, " + clockFont;
clockFontColor = "#2F2E2E";
topPX += -3;
leftPX += -1;
maxClockNameWidth = 66;
clockPartsWidth = 13;
clockPartsHeight = 129;
clockPartsTop = -1;
clockPartsLeft = 57;
break;
case "system":
clockFont = "Arial Narrow, " + clockFont;
clockFontColor = "#666666";
topPX += 3;
leftPX += 1;
maxClockNameWidth = 72;
clockPartsWidth = 13;
clockPartsHeight = 129;
clockPartsTop = 0;
clockPartsLeft = 58;
break;
case "cronometer":
clockFont = "Arial Narrow, " + clockFont;
clockFontColor = "#FF0000";
topPX += 6;
maxClockNameWidth = 70;
clockPartsWidth = 13;
clockPartsHeight = 129;
clockPartsTop = -1;
clockPartsLeft = 57;
break;
case "diner":
clockFont = "Segoe Script Bold, " + clockFont;
clockFontColor = "#D3D9E3";
clockFontSize = 9;
maxClockNameWidth = 56;
clockPartsWidth = 13;
clockPartsHeight = 129;
clockPartsTop = -1;
clockPartsLeft = 58;
break;
case "flower":
clockFont = "Arial Rounded MT Bold, " + clockFont;
clockFontColor="#FE8E08";
clockFontSize = 9;
topPX += 2;
leftPX += 2;
maxClockNameWidth = 71;
clockPartsWidth = 13;
clockPartsHeight = 129;
clockPartsTop = 0;
clockPartsLeft = 59;
break;
case "modern":
clockFont = "Arial Narrow, " + clockFont;
clockFontColor = "#FFFFFF";
topPX += 3;
maxClockNameWidth = 74;
clockPartsWidth = 13;
clockPartsHeight = 129;
clockPartsTop = -1;
clockPartsLeft = 58;
break;
case "square":
clockFont = "Calibri, " + clockFont;
clockFontColor = "#000000";
clockFontSize = 9;
maxClockNameWidth = 70;
clockPartsWidth = 13;
clockPartsHeight = 129;
clockPartsTop = -1;
clockPartsLeft = 57;
break;
case "novelty":
clockFont = "Calibri Bold, " + clockFont;
clockFontColor = "#6dadff";
clockFontSize = 10;
topPX += 18;
maxClockNameWidth = 60;
clockPartsWidth = 7;
clockPartsHeight = 81;
clockPartsTop = 46;
clockPartsLeft = 59;
break;
}
dot.style.width = h.style.width = m.style.width = s.style.width = clockPartsWidth;
dot.style.height = h.style.height = m.style.height = s.style.height = clockPartsHeight;
dot.style.top = h.style.top = m.style.top = s.style.top = clockPartsTop;
dot.style.left = h.style.left = m.style.left = s.style.left = clockPartsLeft;
setImages();
with (clockNamePosition.style)
{
top = posClockNameTop + topPX + "px";
left = leftPX + "px";
visibility = "hidden";
}
if (mySetting.clockName.length > 0)
{
with (clockName.style)
{
width = maxClockNameWidth + "px";
fontFamily = clockFont;
color = clockFontColor;
fontSize = clockFontSize + "pt";
}
clockName.innerText = mySetting.clockName;
with (clockNamePosition.style)
{
top = parseInt(top) + midClockNameFontHeight - Math.floor(clockName.offsetHeight / 2) + "px";
visibility = "visible";
}
}
clearTimeout(newTimeOut);
if (mySetting.secondsEnabled)
{
s.style.visibility = "visible";
dot.style.visibility = "hidden";
}
else
{
s.style.visibility = "hidden";
dot.style.visibility = "visible";
}
timePerInterval();
}
////////////////////////////////////////////////////////////////////////////////
//
// calculates how many milliseconds remain until the start of the next second
//
////////////////////////////////////////////////////////////////////////////////
function secondTimeOffset()
{
return 1000 - new Date().getMilliseconds();
}
////////////////////////////////////////////////////////////////////////////////
//
// calculates how many milliseconds remain until the start of the next minute
//
////////////////////////////////////////////////////////////////////////////////
function minuteTimeOffset()
{
var d = new Date();
return ((60 - d.getSeconds()) * 1000) - d.getMilliseconds();
}
////////////////////////////////////////////////////////////////////////////////
//
// THIS CODE IS NOT APPROVED FOR USE IN/ON ANY OTHER UI ELEMENT OR PRODUCT COMPONENT.
// Copyright (c) 2009 Microsoft Corporation. All rights reserved.
//
////////////////////////////////////////////////////////////////////////////////
var L_SELECT_TZ_TEXT = "Current computer time";
var L_PREVIOUS_TEXT = "Previous";
var L_NEXT_TEXT = "Next";
var imagePath = "images/";
var imageArray = new Array("trad_settings.png", "system_settings.png", "cronometer_settings.png", "diner_settings.png", "flower_settings.png", "modern_settings.png", "square_settings.png", "novelty_settings.png");
var imageIndex = 0;
var INF_BIAS = 1000; // BIAS max-val = 720, min-val = -780
var INF_DSTBIAS = 1000; // DSTBIAS max = 60, min = -60
var BIAS_ABSENT = 1001;
var DSTBIAS_ABSENT = 1001;
var ZERO_BIAS = 1002;
var ZERO_DSTBIAS = 1002;
var mySetting = new clockSettings();
////////////////////////////////////////////////////////////////////////////////
//
// load clock settings
//
////////////////////////////////////////////////////////////////////////////////
function loadSettings()
{
var pageDir = document.getElementsByTagName("html")[0].dir;
if (pageDir == "rtl")
{
settingsButtonTable.dir = "rtl";
var temp = settingsButtonLeftCell.innerHTML;
settingsButtonLeftCell.innerHTML = settingsButtonRightCell.innerHTML;
settingsButtonRightCell.innerHTML = temp;
temp = settingsImageLeft.onmousedown;
settingsImageLeft.onmousedown = settingsImageRight.onmousedown;
settingsImageRight.onmousedown = temp;
temp = settingsLeftAnchor.onkeypress;
settingsLeftAnchor.onkeypress = settingsRightAnchor.onkeypress;
settingsRightAnchor.onkeypress = temp;
settingsImageLeft.alt = L_NEXT_TEXT;
settingsImageRight.alt = L_PREVIOUS_TEXT;
settingsLeftAnchor.title = L_NEXT_TEXT;
settingsRightAnchor.title = L_PREVIOUS_TEXT;
}
else
{
settingsImageLeft.alt = L_PREVIOUS_TEXT;
settingsImageRight.alt = L_NEXT_TEXT;
settingsLeftAnchor.title = L_PREVIOUS_TEXT;
settingsRightAnchor.title = L_NEXT_TEXT;
}
mySetting.load();
loadTimeZones();
imageIndex = mySetting.themeID;
settingsUpdateIndex();
clockName.value = mySetting.clockName;
with (timeZoneIndex)
{
value = getValidTimeZone(mySetting.timeZoneIndex);
title = options[selectedIndex].text;
}
secondsEnabled.checked = mySetting.secondsEnabled;
System.Gadget.onSettingsClosing = settingsClosing;
}
////////////////////////////////////////////////////////////////////////////////
//
//
////////////////////////////////////////////////////////////////////////////////
function settingsUpdateImage(img, state)
{
img.src = imagePath + "settings_" + img.src.split("_")[1] + "_" + state + ".png";
}
////////////////////////////////////////////////////////////////////////////////
//
//
////////////////////////////////////////////////////////////////////////////////
function settingsButtonBack()
{
if (event.keyCode == 32 || event.button == 1)
{
imageIndex--;
if (imageIndex < 0)
{
imageIndex = imageArray.length - 1;
}
settingsUpdateIndex();
}
}
////////////////////////////////////////////////////////////////////////////////
//
//
////////////////////////////////////////////////////////////////////////////////
function settingsButtonForward()
{
if (event.keyCode == 32 || event.button == 1)
{
imageIndex++;
if (imageIndex == imageArray.length)
{
imageIndex = 0;
}
settingsUpdateIndex();
}
}
////////////////////////////////////////////////////////////////////////////////
//
//
////////////////////////////////////////////////////////////////////////////////
function settingsUpdateIndex()
{
mySetting.themeID = imageIndex;
settingsImagePreview.src = imagePath + imageArray[imageIndex];
currentIndex.innerHTML = imageIndex + 1;
maxIndex.innerHTML = imageArray.length;
}
////////////////////////////////////////////////////////////////////////////////
//
// settings event closing
//
////////////////////////////////////////////////////////////////////////////////
function settingsClosing(event)
{
if (event.closeAction == event.Action.commit)
{
saveSettings();
}
}
////////////////////////////////////////////////////////////////////////////////
//
// create clock object
//
////////////////////////////////////////////////////////////////////////////////
function clockSettings()
{
this.save = saveSettingToDisk;
this.load = loadSettingFromDisk;
this.themeID = 0;
this.clockName = "";
this.timeZoneIndex = -1;
this.timeZoneBias = INF_BIAS;
this.timeZoneDSTBias = INF_DSTBIAS;
this.timeZoneName = "";
this.secondsEnabled = false;
}
////////////////////////////////////////////////////////////////////////////////
//
// load the information from disk
//
////////////////////////////////////////////////////////////////////////////////
function loadSettingFromDisk()
{
if (System.Gadget.Settings.read("SettingsExist"))
{
this.clockName = unescape(System.Gadget.Settings.readString("clockName"));
this.themeID = getValidThemeID(System.Gadget.Settings.read("themeID"));
this.secondsEnabled = System.Gadget.Settings.read("secondsEnabled");
this.timeZoneIndex = parseInt(System.Gadget.Settings.read("timeZoneIndex"));
this.timeZoneBias = parseInt(System.Gadget.Settings.read("timeZoneBias") || BIAS_ABSENT);
this.timeZoneDSTBias = parseInt(System.Gadget.Settings.read("timeZoneDSTBias") || DSTBIAS_ABSENT);
this.timeZoneName = unescape(System.Gadget.Settings.readString("timeZoneName") || "");
if( this.timeZoneBias == ZERO_BIAS )
{
this.timeZoneBias = 0;
}
if( this.timeZoneDSTBias == ZERO_DSTBIAS )
{
this.timeZoneDSTBias = 0;
}
if ( this.timeZoneBias == INF_BIAS || this.timeZoneDSTBias == INF_DSTBIAS || this.timeZoneBias == BIAS_ABSENT || this.timeZoneDSTBias == DSTBIAS_ABSENT ) // Either setting not present (var_ABSENT) OR set to current timezone (INF_var)
{
if ( ( this.timeZoneBias == BIAS_ABSENT || this.timeZoneDSTBias == DSTBIAS_ABSENT ) && this.timeZoneIndex != -1 ) // setting not present (var_ABSENT), clear clockName
{
this.clockName = "";
}
this.timeZoneIndex = -1;
this.timeZoneBias = INF_BIAS;
this.timeZoneDSTBias = INF_DSTBIAS;
}
else //both BIAS and DSTBIAS have a valid value
{
AdjustTimeZoneIndex( this );
}
}
}
////////////////////////////////////////////////////////////////////////////////
//
// Adjust timezone index based on values of Bias, DSTBias and Zonename
//
////////////////////////////////////////////////////////////////////////////////
function AdjustTimeZoneIndex( settingsObject )
{
var indexL1Match, indexL2Match, currentTimeZone;
var storedTimeZoneName, OMTimezoneName;
indexL1Match = indexL2Match = -1;
zones = System.Time.timeZones;
zonesCount = zones.count;
for (var i = 0; i < zonesCount; i++)
{
currentTimeZone = zones.item(i);
if ( currentTimeZone.bias == settingsObject.timeZoneBias && currentTimeZone.DSTBias == settingsObject.timeZoneDSTBias )
{
indexL1Match = i;
storedTimeZoneName = settingsObject.timeZoneName.replace( "GMT", "UTC" );
OMTimezoneName = currentTimeZone.displayName.replace( "GMT", "UTC" );
if ( storedTimeZoneName == OMTimezoneName )
{
indexL2Match = i;
break;
}
}
}
if ( indexL2Match !== -1 ) // All values match
{
settingsObject.timeZoneIndex = indexL2Match;
}
else if ( indexL1Match !== -1 ) // BIAS and DSTBIAS match, no match for name; use last pair from the list
{
settingsObject.timeZoneIndex = indexL1Match;
}
else // Clear settings, since saved (Bias,DSTbias) pair doesnt exist in timezones collection
{
if ( settingsObject.timeZoneIndex !== -1 )
{
settingsObject.clockName = "";
}
settingsObject.timeZoneIndex = -1;
settingsObject.timeZoneBias = INF_BIAS;
settingsObject.timeZoneDSTBias = INF_DSTBIAS;
settingsObject.timeZoneName = "";
}
if ( settingsObject.timeZoneIndex !== -1 ) // update timezone name
{
settingsObject.timeZoneName = zones.item(settingsObject.timeZoneIndex).displayName;
}
}
////////////////////////////////////////////////////////////////////////////////
//
// save information to disk
//
////////////////////////////////////////////////////////////////////////////////
function saveSettingToDisk()
{
System.Gadget.Settings.write("SettingsExist", true);
System.Gadget.Settings.writeString("clockName", escape(this.clockName));
System.Gadget.Settings.write("themeID", this.themeID);
System.Gadget.Settings.write("timeZoneIndex", this.timeZoneIndex);
if( this.timeZoneBias == 0 )
{
System.Gadget.Settings.write("timeZoneBias", ZERO_BIAS);
}
else
{
System.Gadget.Settings.write("timeZoneBias", this.timeZoneBias);
}
if( this.timeZoneDSTBias == 0 )
{
System.Gadget.Settings.write("timeZoneDSTBias", ZERO_DSTBIAS);
}
else
{
System.Gadget.Settings.write("timeZoneDSTBias", this.timeZoneDSTBias);
}
System.Gadget.Settings.writeString("timeZoneName", escape(this.timeZoneName));
System.Gadget.Settings.write("secondsEnabled", this.secondsEnabled);
}
////////////////////////////////////////////////////////////////////////////////
//
// save clock settings
//
////////////////////////////////////////////////////////////////////////////////
function saveSettings()
{
mySetting.clockName = trim(clockName.value, "both");
mySetting.timeZoneIndex = getValidTimeZone(timeZoneIndex.value);
if( mySetting.timeZoneIndex !== -1 )
{
zones = System.Time.timeZones;
mySetting.timeZoneBias = zones.item(mySetting.timeZoneIndex).bias;
mySetting.timeZoneDSTBias = zones.item(mySetting.timeZoneIndex).DSTBias;
mySetting.timeZoneName = zones.item(mySetting.timeZoneIndex).displayName;
}
else
{
mySetting.timeZoneBias = INF_BIAS;
mySetting.timeZoneDSTBias = INF_DSTBIAS;
mySetting.timeZoneName = "";
}
mySetting.secondsEnabled = secondsEnabled.checked;
mySetting.save();
}
///////////////////////////////////////////////////////////////////////////////
//
// load time zones
//
////////////////////////////////////////////////////////////////////////////////
function loadTimeZones()
{
updateTimeZones(true);
timeZoneIndex.options[0] = new Option(L_SELECT_TZ_TEXT, "-1");
for (var i = 0; i < e.length; i++)
{
timeZoneIndex.options[i + 1] = new Option(e[i][eZone], e[i][eItem], null, (e[i][eItem] == mySetting.timeZoneIndex));
timeZoneIndex.options[i + 1].title = e[i][eZone];
}
}
////////////////////////////////////////////////////////////////////////////////
//
// trim white space
//
////////////////////////////////////////////////////////////////////////////////
function trim(stringIn, removeFrom)
{
var stringOut = "";
stringIn = stringIn.toString();
if (stringIn.length > 0)
{
switch (removeFrom)
{
case "left":
stringOut = stringIn.replace(/^\s+/g, "");
break;
case "right":
stringOut = stringIn.replace(/\s+$/g, "");
break;
case "both":
default:
stringOut = stringIn.replace(/^\s+|\s+$/g, "");
}
}
return stringOut;
}
////////////////////////////////////////////////////////////////////////////////
//
// check to see if theme index within array
//
////////////////////////////////////////////////////////////////////////////////
function getValidThemeID(index)
{
if (parseInt(index) > -1 && parseInt(index) < clockThemes.length)
{
return parseInt(index);
}
else
{
return 0;
}
}
var e = new Array();
var eItem = 0;
var eZone = 1;
var eOffset = 2;
var zones = null;
var zonesCount = 0;
////////////////////////////////////////////////////////////////////////////////
//
// update time zones
//
////////////////////////////////////////////////////////////////////////////////
function updateTimeZones(sortName)
{
zones = System.Time.timeZones;
zonesCount = zones.count;
if (sortName)
{
var zoneArray = new Array();
for (var i = 0; i < zonesCount; i++)
{
zoneArray[i] = [i, zones.item(i).displayName, zones.item(i).bias];
}
var zoneArrayTemp1 = [];
zoneArrayTemp1.push(zoneArray[0]);
for (var i = 1; i < zoneArray.length; i++)
{
for (var j = 0; j < zoneArrayTemp1.length; j++)
{
if (zoneArray[i][eOffset] >= zoneArrayTemp1[j][eOffset])
{
for (var k = zoneArrayTemp1.length - 1; k >= j; k--)
{
zoneArrayTemp1[k + 1] = zoneArrayTemp1[k];
}
zoneArrayTemp1[j] = zoneArray[i];
if (zoneArrayTemp1[j + 1][eOffset] == zoneArrayTemp1[j][eOffset])
{
var tempArray1 = [];
var tempArray2 = [];
for (var l = j; l < zoneArrayTemp1.length; l++)
{
if (zoneArrayTemp1[j][eOffset] != zoneArrayTemp1[l][eOffset])
{
break;
}
tempArray1[zoneArrayTemp1[l][eZone]] = zoneArrayTemp1[l][eItem];
tempArray2[tempArray2.length] = zoneArrayTemp1[l][eZone];
}
if (tempArray2.length > 1)
{
tempArray2.sort();
for (var l = 0; l < tempArray2.length; l++)
{
zoneArrayTemp1[j + l][0] = tempArray1[tempArray2[l]];
zoneArrayTemp1[j + l][1] = tempArray2[l];
}
}
}
break;
}
}
}
zoneArrayTemp1.length--;
var zoneArrayTemp2 = [];
zoneArrayTemp2.push(zoneArray[0]);
for (var i = 1; i < zoneArray.length; i++)
{
for (var j = 0; j < zoneArrayTemp2.length; j++)
{
if (zoneArray[i][eOffset] <= zoneArrayTemp2[j][eOffset])
{
for (var k = zoneArrayTemp2.length - 1; k >= j; k--)
{
zoneArrayTemp2[k + 1] = zoneArrayTemp2[k];
}
zoneArrayTemp2[j] = zoneArray[i];
if (zoneArrayTemp2[j + 1][eOffset] == zoneArrayTemp2[j][eOffset])
{
var tempArray1 = [];
var tempArray2 = [];
for (var l = j; l < zoneArrayTemp2.length; l++)
{
if (zoneArrayTemp2[j][eOffset] != zoneArrayTemp2[l][eOffset])
{
break;
}
tempArray1[zoneArrayTemp2[l][eZone]] = zoneArrayTemp2[l][eItem];
tempArray2[tempArray2.length] = zoneArrayTemp2[l][eZone];
}
if (tempArray2.length > 1)
{
tempArray2.sort(compareDisplayName);
for (var l = 0; l < tempArray2.length; l++)
{
zoneArrayTemp2[j + l][0] = tempArray1[tempArray2[l]];
zoneArrayTemp2[j + l][1] = tempArray2[l];
}
}
}
break;
}
}
}
zoneArrayTemp2.reverse();
e = zoneArrayTemp1.concat(zoneArrayTemp2);
}
}
////////////////////////////////////////////////////////////////////////////////
//
//
////////////////////////////////////////////////////////////////////////////////
function compareDisplayName(string1, string2)
{
for (var i = 0; i < Math.min(string1.length, string2.length); i++)
{
if (string1.charAt(i) != string2.charAt(i))
{
return (string1.charAt(i) < string2.charAt(i) ? 1 : -1);
}
}
return 0;
}
////////////////////////////////////////////////////////////////////////////////
//
// get current local time
//
////////////////////////////////////////////////////////////////////////////////
function getCurrentTimeZone()
{
if (zonesCount > 0)
{
var curZone = System.Time.currentTimeZone;
for (var i = 0; i < zonesCount; i++)
{
if (zones.item(i).standardDisplayName == curZone.standardDisplayName)
{
return i;
}
}
}
return -1;
}
////////////////////////////////////////////////////////////////////////////////
//
// check to see if time zone within array
//
////////////////////////////////////////////////////////////////////////////////
function getValidTimeZone(index)
{
if (parseInt(index) > -1 && parseInt(index) < zonesCount)
{
return parseInt(index);
}
else
{
return -1;
}
}