Bước tới nội dung

Thành viên:Just Limorina/Gadget-clock.js

Bách khoa toàn thư mở Wikipedia

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;
	}
}
Lấy từ “https://vi.wikipedia.org/w/index.php?title=Thành_viên:Just_Limorina/Gadget-clock.js&oldid=70135579”