Type.registerNamespace('SportsDo');
Type.registerNamespace('SportsDo.Mapping');

// remove and user $addHandler
SportsDo.attachEventListener = function (target, evt, func, priority) {
    if(typeof evts[evt] == 'undefined')
    {
        evts[evt] = [];

        if (window.attachEvent) 
        {
            target.attachEvent("on" + evt, SportsDo.eventHandler);
        } 
        else
        {
            target.addEventListener(evt, SportsDo.eventHandler , false);
        }
    }
    evts[evt].push([priority, func]);
}

function loadJsCssFile(filename, filetype){
 if (filetype=="js"){ //if filename is a external JavaScript file
  var fileref=document.createElement('script')
  fileref.setAttribute("type","text/javascript")
  fileref.setAttribute("src", filename)
 }
 else if (filetype=="css"){ //if filename is an external CSS file
  var fileref=document.createElement("link")
  fileref.setAttribute("rel", "stylesheet")
  fileref.setAttribute("type", "text/css")
  fileref.setAttribute("href", filename)
 }
 if (typeof fileref!="undefined")
  document.getElementsByTagName("head")[0].appendChild(fileref)
}

var centerOnViewerLocationMap = null;
var centerOnViewerLocationMapZoom = null;
var autoLocateCallback = null;
function SetAutoLocateViewport(latitude, longitude, lvl, bl, msg) {
  if (centerOnViewerLocationMap != null && latitude != null && longitude != null) {
    centerOnViewerLocationMap.setMapCenter(new $SLatLng(latitude, longitude), centerOnViewerLocationMapZoom);
  } else if (window["autoLocateCallback"] != null) {
    autoLocateCallback(latitude, longitude, lvl, bl, msg);
  }
}

SportsDo.FindViewersLocation = function(callback) {
  autoLocateCallback = callback;
  centerOnViewerLocationMap = null;
  centerOnViewerLocationMapZoom = null;
  // var api = new SportsDoApi("centerOnViewerLocation", "locate", null, null, "http://maps.live.com/WiFiIPService/", null);
  // api.startRequest();
}

SportsDo.FindViewersLocationOnMap = function(map, mapZoom) {
  autoLocateCallback = null;
  centerOnViewerLocationMap = map;
  centerOnViewerLocationMapZoom = mapZoom;
  // var api = new SportsDoApi("centerOnViewerLocation", "locate", null, null, "http://maps.live.com/WiFiIPService/", null);
  // api.startRequest();
}

SportsDo.createMap = function(mapid, provider, mapType, mapMode, latitude, longitude, zoom, datasource, options) {
    if (typeof showmap != "undefined") {
      return showmap(mapid, provider, mapType, mapMode, latitude, longitude, zoom, datasource);
    } else {
      return SportsDo.Mapping.createMap(mapid, provider, mapType, mapMode, latitude, longitude, zoom, datasource, options);
    }
}

var evts = [];
// remove and user $addHandler
SportsDo.addListener = function(evt, func, priority)
{
    if(typeof evts[evt] == 'undefined')
    {
        evts[evt] = [];

        if (window.attachEvent) 
        { 
            window.attachEvent("on" + evt, SportsDo.eventHandler);
        } 
        else
        {
            window.addEventListener(evt, SportsDo.eventHandler , false);
        }
    }
    
    if (priority == null) {
        priority = 1;
    }
    evts[evt].push([priority, func]);
}

SportsDo.eventHandler = function(evt)
{
    var evt = (!evt) ? window.event : evt;
    evts[evt.type].sort(SportsDo.compare);
    for(var i=0; i<evts[evt.type].length; i++)
    {
        var evnt = evts[evt.type][i][1];
        if (evnt != null)
          evnt();
    }
}

SportsDo.Mapping.ResizeMap = function(mainId, mapId) {
    var mainHeight = parseInt(document.getElementById(mainId).height);
    var mapHeight = parseInt(document.getElementById(mapId).style.height);
    var newHeight = mainHeight - 30;
    if(!isNaN(mainHeight) && !isNaN(mapHeight) && (mapHeight!=newHeight))
    {
        document.getElementById(mapId).style.height = newHeight + "px";
    }
}

SportsDo.compare = function(a, b) {
    return a[0] - b[0];
}

var hD="0123456789ABCDEF";
SportsDo.d2h = function(d) {
    var h = hD.substr(d&15,1);
    while(d>15) {d>>=4;h=hD.substr(d&15,1)+h;}
    return h;
}

SportsDo.h2d = function(h) {return parseInt(h,16);} 

SportsDo.colorHex2Decimal = function(h) {
    if (h.indexOf(0 == '#')) {
        var rgb = [];
        rgb[0] = SportsDo.h2d(h.substring(1, 2));
        rgb[1] = SportsDo.h2d(h.substring(3, 4));
        rgb[2] = SportsDo.h2d(h.substring(5, 6));
        
        return rgb;
    }
    
    return null;
}

SportsDo.formatTime = function(date, format) {
  var result;
  result = format.replace(new RegExp("hh", "g"), date.getUTCHours() < 10 ? "0" + date.getUTCHours() : date.getUTCHours());
  result = result.replace(new RegExp("mm", "g"), date.getMinutes() < 10 ? "0" + date.getMinutes() : date.getMinutes());
  result = result.replace(new RegExp("ss", "g"), date.getSeconds() < 10 ? "0" + date.getSeconds() : date.getSeconds());
  return result;
}

// function to create an XMLHttpClient in a cross-browser manner
SportsDo.initXMLHttpClient = function() {
    var xmlhttp;
    try {
        // Mozilla / Safari / IE7
        xmlhttp = new XMLHttpRequest();
    } catch (e) {
        // IE
        var XMLHTTP_IDS = new Array('MSXML2.XMLHTTP.5.0',
                                 'MSXML2.XMLHTTP.4.0',
                                 'MSXML2.XMLHTTP.3.0',
                                 'MSXML2.XMLHTTP',
                                 'Microsoft.XMLHTTP' );
        var success = false;
        for (var i=0;i < XMLHTTP_IDS.length && !success; i++) {
          try {
            xmlhttp = new ActiveXObject(XMLHTTP_IDS[i]);
            success = true;
          } catch (e) {}
        }
        if (!success) {
          throw new Error('Unable to create XMLHttpRequest.');
        }
    }
    
    return xmlhttp;
}

SportsDo.makeAsyncRequest = function(req, page, onComplete) {
  req.onreadystatechange = function() {
    if (req.readyState == 4) {
        if (req.status == 200) {
            onComplete(req.responseText);
        } else {
            //alert('Loading Error: ['+req.status+'] ' + req.statusText);
        }
    }
  }
  
  try {
      req.open('GET', page, true);
      req.send(null);
  } catch (err)
  {}
}

SportsDo.GetInnerSize = function() {
	var x,y;
	if (self.innerHeight) // all except Explorer
	{
		x = self.innerWidth;
		y = self.innerHeight;
	}
	else if (document.documentElement && document.documentElement.clientHeight)
		// Explorer 6 Strict Mode
	{
		x = document.documentElement.clientWidth;
		y = document.documentElement.clientHeight;
	}
	else if (document.body) // other Explorers
	{
		x = document.body.clientWidth;
		y = document.body.clientHeight;
	}
	return [x,y];
}

SportsDo.setObjInnerText = function(objId, text, obj) { 
    /// parameter obj is required if objId is null
    if (objId != null) {
      obj = $get(objId);
    }
    
    if (obj != null) {
        if (typeof(obj.innerText) !== "undefined") {
            obj.innerText = text;
        } else {
            obj.textContent = text;
        }
    }
}

SportsDo.getObjInnerText = function(objId) { 
    var obj = $get(objId);
    
    if (obj != null) {
        if (typeof(obj.innerText) !== "undefined") {
            return obj.innerText;
        } else {
            return obj.textContent;
        }
    }
}

SportsDo.removeChildrenFromNode = function(node, tagName) {
  if (node === undefined || node === null) {
    return;
  }

  var len = node.childNodes.length;

  if (typeof(tagName) === "undefined" || tagName === null) {
    while (node.hasChildNodes()) {
      node.removeChild(node.firstChild);
    }
  } else {
    var toRemove = [];
    for (var n in node.childNodes) {
      var cn = node.childNodes[n];
      if (typeof(cn) !== "undefined" || cn != null) {
        if (cn.tagName === tagName) {
          Array.add(toRemove, cn);
        }
      }
    }
    
    for (var n in toRemove) {
      var d = toRemove[n];
      d.parentNode.removeChild(d);
    }
  }
}

// items - 2d array with value in [0] and text in [1]
SportsDo.createSelectList = function(id, items, defaultSelectedValue) {
  var select = document.createElement("select");
  select.className = "dropList";
  if (id != null) {
    select.setAttribute("id", id);
  }
  
  if (items != null) {
    var option;
    for (var i=0;i<items.length; i++) {
      option = document.createElement("option");
      option.text=items[i][1];
      option.value=items[i][0];
      if (option.value == defaultSelectedValue) {
        if (BrowserDetect.browser == "Firefox") {
          option.defaultSelected = true;
        } else {
          option.selected = true;
        }
      }
      select.options.add(option);
    }
  }
  return select;
}

SportsDo.createTextBox = function(id) {
  var input = document.createElement("input");
  if (id != null) {
    input.setAttribute("id", id);
  }
  input.setAttribute("type", "text");
  input.className = "textBox";
  return input;
}

SportsDo.createButton = function(id, text) {
  var input = document.createElement("input");
  if (id != null) {
    input.setAttribute("id", id);
  }
  input.setAttribute("type", "button");
  input.className = "button";
  input.value = text;
  return input;
}

SportsDo.createTable = function(rows, columns) {
  var tbl = document.createElement("table");
  tbl.appendChild(document.createElement("tbody"));
  var num, tr;
  
  for (var r=0; r<rows; r++) {
    num = tbl.tBodies[0].rows.length;
    tr = tbl.tBodies[0].insertRow(num);
    
    for (var c=0; c<columns; c++) {
      tr.insertCell(0);
    }
  }
  
  return tbl;
}

SportsDo.copyToClipboard = function(text) {
 if (window.clipboardData) {
   window.clipboardData.setData("Text", text);
 } else if (window.netscape) { 
   netscape.security.PrivilegeManager.enablePrivilege('UniversalXPConnect');
   var clip = Components.classes['@mozilla.org/widget/clipboard;1'].createInstance(Components.interfaces.nsIClipboard);
   if (!clip) return;

   var trans = Components.classes['@mozilla.org/widget/transferable;1'].createInstance(Components.interfaces.nsITransferable);
   if (!trans) return;
   
   trans.addDataFlavor('text/unicode');

   var str = new Object();
   var len = new Object();
   
   var str = Components.classes["@mozilla.org/supports-string;1"].createInstance(Components.interfaces.nsISupportsString);
   var copytext=text;
   
   str.data=copytext;
   trans.setTransferData("text/unicode",str,copytext.length*2);
   
   var clipid=Components.interfaces.nsIClipboard;
   
   if (!clip) return false;
   
   clip.setData(trans,null,clipid.kGlobalClipboard);
 }
 
 return false;
}

function SportsDoApi(id, method, callback, args, serverUrl, opts) {
  var bodyTag = document.getElementsByTagName("body").item(0);
  //this.divObjectReference = document.createElement("div");
  //this.divObjectReference.id = id;
  this.id = id;
  if (opts != null && typeof(opts.extension) !== "undefined") {
    var extension = opts.extension;
  } else {
    var extension = ".ashx";
  }

  if (serverUrl == null) serverUrl = "/";
  this.url = serverUrl + method + extension + "?callback=" + callback;
  
  if (args != null) {
    for (var i=0; i<args.length; i++) {
      this.url += "&" + args[i][0] + "=" + args[i][1];
    }
  }
  this.callback = callback;
  //bodyTag.appendChild(this.divObjectReference);
}

SportsDoApi.prototype = {
  createScriptTag: function() {
    var scriptObj = document.createElement("script");
    scriptObj.setAttribute("type", "text/javascript");
    scriptObj.setAttribute("src", this.url);
    scriptObj.setAttribute("id", this.id + "_script");
    return scriptObj;
  },
  
  removeScriptTag: function() {
    var Node = $get(this.id + "_script");
    if (Node != null) {
      Node.parentNode.removeChild(Node);
    }
    if (this.divObjectReference != null) {
      this.divObjectReference.parentNode.removeChild(this.divObjectReference);
    }
  },
  
  startRequest: function()	{
    var headTag = document.getElementsByTagName("head").item(0);
    
    this.removeScriptTag();
    
    this.scriptObj = this.createScriptTag();
    headTag.appendChild(this.scriptObj);
  }
}

var Request = {
  init: function() {
    this.currentUrlWithoutQueryString = location.protocol + "//" + location.hostname + location.pathname;
    this.hostUrl = location.protocol + "//" + location.hostname;
    var search = location.search;
    search = search.replace(/\?/,'');
    var searchAttributes = search.split('&');
    this._items = new Hash();
    for (var no=0;no<searchAttributes.length;no++){
      var items = searchAttributes[no].split('=');
      this._items.setItem(items[0], items[1]);
    }
  },
  queryString: function(key) {
    return this._items.getItem(key);
  },
  keys: function() {
    return this._items.keys;
  }
};
Request.init();

var BrowserDetect = {
	init: function () {
		this.browser = this.searchString(this.dataBrowser) || "An unknown browser";
		this.version = this.searchVersion(navigator.userAgent)
			|| this.searchVersion(navigator.appVersion)
			|| "an unknown version";
		this.OS = this.searchString(this.dataOS) || "an unknown OS";
	},
	searchString: function (data) {
		for (var i=0;i<data.length;i++)	{
			var dataString = data[i].string;
			var dataProp = data[i].prop;
			this.versionSearchString = data[i].versionSearch || data[i].identity;
			if (dataString) {
				if (dataString.indexOf(data[i].subString) != -1)
					return data[i].identity;
			}
			else if (dataProp)
				return data[i].identity;
		}
	},
	searchVersion: function (dataString) {
		var index = dataString.indexOf(this.versionSearchString);
		if (index == -1) return;
		return parseFloat(dataString.substring(index+this.versionSearchString.length+1));
	},
	dataBrowser: [
		{ 	string: navigator.userAgent,
			subString: "OmniWeb",
			versionSearch: "OmniWeb/",
			identity: "OmniWeb"
		},
		{
			string: navigator.vendor,
			subString: "Apple",
			identity: "Safari"
		},
		{
			prop: window.opera,
			identity: "Opera"
		},
		{
			string: navigator.vendor,
			subString: "iCab",
			identity: "iCab"
		},
		{
			string: navigator.vendor,
			subString: "KDE",
			identity: "Konqueror"
		},
		{
			string: navigator.userAgent,
			subString: "Firefox",
			identity: "Firefox"
		},
		{
			string: navigator.vendor,
			subString: "Camino",
			identity: "Camino"
		},
		{		// for newer Netscapes (6+)
			string: navigator.userAgent,
			subString: "Netscape",
			identity: "Netscape"
		},
		{
			string: navigator.userAgent,
			subString: "MSIE",
			identity: "Explorer",
			versionSearch: "MSIE"
		},
		{
			string: navigator.userAgent,
			subString: "Gecko",
			identity: "Mozilla",
			versionSearch: "rv"
		},
		{ 		// for older Netscapes (4-)
			string: navigator.userAgent,
			subString: "Mozilla",
			identity: "Netscape",
			versionSearch: "Mozilla"
		}
	],
	dataOS : [
		{
			string: navigator.platform,
			subString: "Win",
			identity: "Windows"
		},
		{
			string: navigator.platform,
			subString: "Mac",
			identity: "Mac"
		},
		{
			string: navigator.platform,
			subString: "Linux",
			identity: "Linux"
		}
	]

};
BrowserDetect.init();


function Hash() {
	this.length = 0;
	this.items = new Array();
	this.keys = new Array();
	for (var i = 0; i < arguments.length; i += 2) {
		if (typeof(arguments[i + 1]) != 'undefined') {
			this.items[arguments[i]] = arguments[i + 1];
			this.length++;
		}
	}
   
	this.removeItem = function(in_key) {
		var tmp_value;
		if (typeof(this.items[in_key]) != 'undefined') {
			this.length--;
			Array.remove(this.keys, in_key);
			var tmp_value = this.items[in_key];
			delete this.items[in_key];
		}
	   
		return tmp_value;
	}

	this.getItem = function(in_key) {
		return this.items[in_key];
	}

	this.setItem = function(in_key, in_value) {
		if (typeof(in_value) != 'undefined') {
			if (typeof(this.items[in_key]) == 'undefined') {
				this.length++;
				Array.add(this.keys, in_key);
			}

			this.items[in_key] = in_value;
		}
	   
		return in_value;
	}

	this.hasItem = function(in_key) {
		return typeof(this.items[in_key]) != 'undefined';
	}
	
	this.sort = function(comparer) {
	  var a = new Array();
	  for (var i=0; i<this.length; i++) {
	    Array.add(a, this.items[this.keys[i]]);
	  }
	  return a.sort(comparer);
	}
}


//TSorter
/*--------------------------------------------------------------*/
// HTML TABLE SORTER
// OBJECT ORIENTED JAVASCRIPT IMPLEMENTATION OF QUICKSORT
// @author	Terrill Dent 
// @source	http://www.terrill.ca
// @date	August 28th, 2006
/*--------------------------------------------------------------*/
function TSorter(){
	var table = Object;
	var trs = Array;
	var ths = Array;
	var curSortCol = Object;
	var prevSortCol = '3';
	var sortType = Object;

	function get(){}

	function getCell(index){
		return trs[index].cells[curSortCol];
	}

	/*----------------------INIT------------------------------------*/
	// Initialize the variable
	// @param tableName - the name of the table to be sorted
	/*--------------------------------------------------------------*/
	this.init = function(tableName)
	{
		table = document.getElementById(tableName);
		ths = table.getElementsByTagName("th");
		for(var i = 0; i < ths.length ; i++)
		{
			ths[i].onclick = function()
			{
				sort(this);
			}
		}
		return true;
	};
	
	/*----------------------SORT------------------------------------*/
	// Sorts a particular column. If it has been sorted then call reverse
	// if not, then use quicksort to get it sorted.
	// Sets the arrow direction in the headers.
	// @param oTH - the table header cell (<th>) object that is clicked
	/*--------------------------------------------------------------*/
	this.sort = function(oTH) {
	  if (oTH != null) {
		  curSortCol = oTH.cellIndex;
		  sortType = oTH.abbr;
		  trs = table.tBodies[0].getElementsByTagName("tr");

		  //set the get function
		  setGet(sortType)

		  // it would be nice to remove this to save time,
		  // but we need to close any rows that have been expanded
		  for(var j=0; j<trs.length; j++)
		  {
			  if(trs[j].className == 'detail_row')
			  {
				  closeDetails(j+2);
			  }
		  }

		  // if already sorted just reverse
		  if(prevSortCol == curSortCol)
		  {
			  oTH.className = (oTH.className != 'ascend' ? 'ascend' : 'descend' );
			  reverseTable();
		  }
		  // not sorted - call quicksort
		  else
		  {
			  oTH.className = 'ascend';
			  if(ths[prevSortCol].className != 'exc_cell'){ths[prevSortCol].className = '';}
			  quicksort(0, trs.length);
		  }
		  prevSortCol = curSortCol;
		} else {
		  trs = table.tBodies[0].getElementsByTagName("tr");
		  quicksort(1, trs.length);
		}
	}
	
	/*--------------------------------------------------------------*/
	// Sets the GET function so that it doesnt need to be 
	// decided on each call to get() a value.
	// @param: colNum - the column number to be sorted
	/*--------------------------------------------------------------*/
	this.setGet = function(sortType, value)
	{
		switch(sortType)
		{   
			case "link_column":
				get = function(index){
					return getCell(index).firstChild.firstChild.nodeValue;
				};
				break;
		  case "attribute":
		    get = function(index){
		      return trs[index].getAttribute(value);
		    };
		    break;
			default:
				get = function(index){	return getCell(index).firstChild.nodeValue;};
				break;
		};	
	}

	/*-----------------------EXCHANGE-------------------------------*/
	//  A complicated way of exchanging two rows in a table.
	//  Exchanges rows at index i and j
	/*--------------------------------------------------------------*/
	function exchange(i, j)
	{
		if(i == j+1) {
			//table.tBodies[0].insertBefore(trs[i], trs[j]);
			trs[j].parentNode.insertBefore(trs[i], trs[j]);
		} else if(j == i+1) {
			//table.tBodies[0].insertBefore(trs[j], trs[i]);
			trs[i].parentNode.insertBefore(trs[j], trs[i]);
		} else {
			//var tmpNode = table.tBodies[0].replaceChild(trs[i], trs[j]);
			var tmpNode = trs[j].parentNode.replaceChild(trs[i], trs[j]);
			if(typeof(trs[i]) == "undefined") {
				table.appendChild(tmpNode);
			} else {
				//table.tBodies[0].insertBefore(tmpNode, trs[i]);
				trs[i].parentNode.insertBefore(tmpNode, trs[i]);
			}
		}
	}
	
	/*----------------------REVERSE TABLE----------------------------*/
	//  Reverses a table ordering
	/*--------------------------------------------------------------*/
	function reverseTable()
	{
		for(var i = 1; i<trs.length; i++)
		{
			table.tBodies[0].insertBefore(trs[i], trs[0]);
		}
	}

	/*----------------------QUICKSORT-------------------------------*/
	// This quicksort implementation is a modified version of this tutorial: 
	// http://www.the-art-of-web.com/javascript/quicksort/
	// @param: lo - the low index of the array to sort
	// @param: hi - the high index of the array to sort
	/*--------------------------------------------------------------*/
	function quicksort(lo, hi)
	{
		if(hi <= lo+1) return;
		 
		if((hi - lo) == 2) {
			if(get(hi-1) > get(lo)) exchange(hi-1, lo);
			return;
		}
		
		var i = lo + 1;
		var j = hi - 1;
		
		if(get(lo) > get(i)) exchange(i, lo);
		if(get(j) > get(lo)) exchange(lo, j);
		if(get(lo) > get(i)) exchange(i, lo);
		
		var pivot = get(lo);
		
		while(true) {
			j--;
			while(pivot > get(j)) j--;
			i++;
			while(get(i) > pivot) i++;
			if(j <= i) break;
			exchange(i, j);
		}
		exchange(lo, j);
		
		if((j-lo) < (hi-j)) {
			quicksort(lo, j);
			quicksort(j+1, hi);
		} else {
			quicksort(j+1, hi);
			quicksort(lo, j);
		}
	}
}


// Notify ScriptManager that this is the end of the script.
if (typeof(Sys) !== 'undefined') {
  Sys.Application.notifyScriptLoaded();
}