/*=Sarven Capadisli 2007*/

var TDM = {
	Config: {
		Init: {
			Increment: 0,
			Direction: null,
			Postal_Code_Pattern: /^[a-zA-Z]{1}[0-9]{1}[a-zA-Z]{1}[0-9]{1}[a-zA-Z]{1}[0-9]{1}$/,
			Email_Pattern: /^\w+([\.\-]?\w+)*@\w+([\.\-]?\w+)*(\.\w{2,4})+$/,
			SliderCurrent: 0,
			SliderID: 0,
			SliderLength: 0,
			SliderTimeInterval: 3900,
			SliderDatas: [],
			SliderActions: [],
			OpacityStart: 20,
			CurrentTab: 0
		},
		Selectors: {
			Opened: "opened",
			Closed: "closed",
			Selected: "selected",
			Current: "current",
			Hover: "hover",
			DropDownMenu: "interaction_dd_menu",
			TypographyDecrease: "typography_decrease",
			TypographyIncrease: "typography_increase",
			RequiredField: "required_field",
			ValidateRequiredFields: "validate_required_fields",
			FieldValidatePostalCode: "field_validate_postal_code",
			FieldValidateEmail: "field_validate_email",
			FieldValidateEmailIdentical: "field_validate_email_identical",
			FieldValidateEmailMultiple: "field_validate_email_multiple",
			UserRatingSystem: "user_rating_system",
			RatingSystem: "rating_system",
			OpenResourceOnNewWindow: "open_resource_on_new_window",
			Warning: "warning",
			Error: "error",
			ErrorMessage: "error_message",
			Validate: "validate"
		}
	},

	Utils: {
		ClassName: {
			hasClass: function(obj, str) {
				return obj && new RegExp('(?:^|\\s)' + str + '(?:\\s|$)').test(obj.className);
			},
			Add: function (obj, str) {
				if (!this.hasClass(obj, str)) { obj.className += (obj.className ? ' ' : '') + str; }
			},
			Remove: function (obj, str) {
				if (this.hasClass(obj, str)) { obj.className = obj.className.replace(new RegExp('^(?:' + str + '(?:\\s+|$))+|\\s+' + str + '\\s*(?=\\s|$)', 'g'), ''); }
			},
			setClass: function (obj, str, add) {
				return add ? this.Add(obj, str) : this.Remove(obj, str);
			}
		},
		
		GetElementsByClassName: function (name, nodes, match_type) {
			var ret = [];
			var re = (!match_type) ? new RegExp('(?:^|\\s)' + name + '(?:\\s|$)') : new RegExp('(?:^|\\s)' + name);

			if (!nodes) { nodes = document.getElementsByTagName('*'); }
			for (var i = 0, l = nodes.length; i < l; i++) {
				if (re.test(nodes[i].className)) { ret.push(nodes[i]); }
			}
			return ret;
		},

		TypographyResize: function (id) {
			var modifyClass = TDM.Utils.ClassName;
			var settings = TDM.Config.Selectors;

			var content_container = document.getElementById(id);

			var typography_adjuster = document.getElementById('document_typography').getElementsByTagName('span');
			
			for (var i=0; i < typography_adjuster.length; i++) {
				if (i === 0) {
					typography_adjuster[i].onclick = function() {
						if (modifyClass.hasClass(content_container, settings.TypographyIncrease)) {
							modifyClass.Remove(content_container, settings.TypographyIncrease);
						}
						else {
							if (!modifyClass.hasClass(content_container, settings.TypographyDecrease)) {
								modifyClass.Add(content_container, settings.TypographyDecrease);
							}
						}
					};
				}
				else {
					typography_adjuster[i].onclick = function() {
						if (modifyClass.hasClass(content_container, settings.TypographyDecrease)) {
							modifyClass.Remove(content_container, settings.TypographyDecrease);
						}
						else {
							if (!modifyClass.hasClass(content_container, settings.TypographyIncrease)) {
								modifyClass.Add(content_container, settings.TypographyIncrease);
							}
						}
					};
				}
			}
		},

		FindEvent: function (el, evt, handler) {
			for (var events = TDM.Utils.AddEvent.events, i = events.length, e; i--;) {
				e = events[i];
				if (e[0] == el && e[1] == evt && e[2] == handler) {
					return i;
				}
			}
			return -1;
		},

		DelEvent: function (el, evt, handler, flush) {
			if (!el) { return; }
			if (!flush) {
				var i = TDM.Utils.FindEvent(el, evt, handler);
				if (i != -1) { TDM.Utils.AddEvent.events.splice(i, 1); }
			}
			if (el.removeEventListener) {
				el.removeEventListener(evt, handler, false);
			} else if (el.detachEvent) {
				el.detachEvent('on' + evt, handler);
			} else {
				el['on' + evt] = null;
			}
		},

		FlushEvents: function () {
			for (var events = TDM.Utils.AddEvent.events, i = events.length, e; i--;) {
				e = events[i];
				TDM.Utils.DelEvent(e[0], e[1], e[2], true);
			}
			TDM.Utils.AddEvent.events = [];
		},

		HaltEvent: function (evt) {
			if (evt) {
				evt.returnValue = false;
				if (evt.preventDefault) { evt.preventDefault(); }
			}
			return false;
		},

		AddEvent: function (el, evt, handler) {
			if (!el) { return; }
			if (el.addEventListener) {
				el.addEventListener(evt, handler, false);
			} else if (el.attachEvent) {
				el.detachEvent('on' + evt, handler);
				el.attachEvent('on' + evt, handler);
			} else {
				var oldevent = el['on' + evt];
				if (typeof oldevent != 'function') {
					el['on' + evt] = handler;
				} else {
					el['on' + evt] = function(e) {
						oldevent(e);
						handler(e);
					};
				}
			}
			if (TDM.Utils.FindEvent(el, evt, handler) == -1 && evt != 'unload') {
				TDM.Utils.AddEvent.events.push([el, evt, handler]);
			}
		},

		Tabbing: function(datas, actions) {
			var modifyClass = TDM.Utils.ClassName;
			var settings = TDM.Config.Selectors;

			for (var i=0; i<actions.length; i++) {
				TDM.Utils.AddEvent(actions[i], 'click', (function(datas, actions, i) {
					return function(e) {
						TDM.Utils.ShowObject(datas, actions, i);
						e.returnValue = false;
						if (e.preventDefault) { e.preventDefault(); }	
					};
				})(datas, actions, i));
			}
		},

		ShowObject: function (datas, actions, change_id) {
			var modifyClass = TDM.Utils.ClassName;
			var settings = TDM.Config.Selectors;
			TDM.Utils.Close(datas[TDM.Config.Init.CurrentTab]);	
			modifyClass.Remove(actions[TDM.Config.Init.CurrentTab], settings.Selected);

			TDM.Config.Init.CurrentTab = change_id;
			TDM.Utils.Open(datas[TDM.Config.Init.CurrentTab]);
			modifyClass.setClass(actions[TDM.Config.Init.CurrentTab], settings.Selected, 'add');
		},		
				
		Slider: function() {
			var modifyClass = TDM.Utils.ClassName;
			var settings = TDM.Config.Selectors;

			TDM.Config.Init.SliderCurrent = (TDM.Config.Init.SliderCurrent+1) % TDM.Config.Init.SliderLength;
			TDM.Utils.ShowObject(TDM.Config.Init.SliderDatas, TDM.Config.Init.SliderActions, TDM.Config.Init.SliderCurrent);
			TDM.Utils.FadeIn(TDM.Config.Init.SliderDatas[TDM.Config.Init.SliderCurrent % TDM.Config.Init.SliderLength], TDM.Config.Init.OpacityStart);
		},

		SliderInit: function(datas, actions, current){
			if (datas.length != actions.length) { return false; }
			TDM.Config.Init.SliderLength = datas.length;
			TDM.Config.Init.SliderDatas = datas;
			TDM.Config.Init.SliderActions = actions;
			TDM.Config.Init.SliderCurrent = current;
				
			TDM.Utils.SliderPlay();

			for (var i=0; i<datas.length; i++) {
				TDM.Utils.AddEvent(datas[i], 'mouseover', TDM.Utils.SliderPause);
				TDM.Utils.AddEvent(datas[i], 'mouseout', TDM.Utils.SliderPlay);
				TDM.Utils.AddEvent(actions[i], 'mouseover', TDM.Utils.SliderPause);
				TDM.Utils.AddEvent(actions[i], 'mouseout', TDM.Utils.SliderPlay);
				TDM.Utils.AddEvent(actions[i], 'click', function(i) {
					return function() {
						TDM.Config.Init.SliderCurrent = i;
						TDM.Utils.SliderPause();
					};
				}(i));
			}
		},

		SliderPause: function() {
			window.clearInterval(TDM.Config.Init.SliderID);
		},

		SliderPlay: function() {
			if (TDM.Config.Init.SliderID !== 0) {
				window.clearInterval(TDM.Config.Init.SliderID);
			}
			TDM.Config.Init.SliderID = window.setInterval(TDM.Utils.Slider, TDM.Config.Init.SliderTimeInterval);
		},

		ShowHide: function(data, action) {
			var modifyClass = TDM.Utils.ClassName;
			var settings = TDM.Config.Selectors;

			TDM.Utils.AddEvent(action, 'click', function() {
				if (modifyClass.hasClass(data, settings.Opened)) {
					TDM.Utils.Close(data);
				}
				else {
					TDM.Utils.Open(data);
				}
			});
			return false;
		},

		Close: function (obj) {
			var modifyClass = TDM.Utils.ClassName;
			var settings = TDM.Config.Selectors;
			modifyClass.Remove(obj, settings.Opened);
			modifyClass.setClass(obj, settings.Closed, 'add');
		},

		Open: function(obj) {
			var modifyClass = TDM.Utils.ClassName;
			var settings = TDM.Config.Selectors;
			modifyClass.Remove(obj, settings.Closed);
			modifyClass.setClass(obj, settings.Opened, 'add');
		},

		SetOpacity: function (object, opacity) {
			var obj = object.style;
			obj.opacity = (opacity / 100);
			obj.MozOpacity = (opacity / 100);
			obj.KhtmlOpacity = (opacity / 100);
			object.getElementsByTagName('img')[0].style.filter = "alpha(opacity=" + opacity + ")";
		},

		FadeIn: function (obj, opacity) {
			if (opacity <= 100) {
				TDM.Utils.SetOpacity(obj, opacity);
				opacity += 5;
				window.setTimeout(function(obj, opacity){
					return function () {
						TDM.Utils.FadeIn(obj, opacity);
					};
				}(obj, opacity), 50);
			}
		},
		
		FadeInInit: function(datas, actions, opacity_start_value) {		
			var modifyClass = TDM.Utils.ClassName;
			var settings = TDM.Config.Selectors;
			
			for (var i=0; i<actions.length; i++) {
				TDM.Utils.AddEvent(actions[i], 'click', function (data, opacity_start_value) {
					return function () {
						if (opacity_start_value !== -1) {
							TDM.Utils.FadeIn(data, opacity_start_value);
						}
						return false;
					};
				}(datas[i], opacity_start_value));
			}		
		},

		DropDown: function() {
			settings = TDM.Config.Selectors;
			modifyClass = TDM.Utils.ClassName;
			utils = TDM.Utils;
			
			drop_down_containers = utils.GetElementsByClassName(settings.DropDownMenu);
			if (drop_down_containers.length > 0) {
				for(var i=0; i<drop_down_containers.length; i++) {

					node = drop_down_containers[i];
					if (node.nodeName=="LI") {
						node.onmouseover = function() {
							modifyClass.Add(this, settings.Hover);
						};
						node.onmouseout = function() {
							modifyClass.Remove(this, settings.Hover);
						};
					}
				}
			}
		},

		OpenResourceOnNewWindow: function () {
			new_window_elements = this.GetElementsByClassName(TDM.Config.Selectors.OpenResourceOnNewWindow, '', '');

			for (var i=0; i < new_window_elements.length; i++) {
				new_window_elements[i].onkeypress = new_window_elements[i].onclick = function () {
					window.open(this.href); return false;
				};
			}
		},
		
		RatingSystem: function() {
			var modifyClass = TDM.Utils.ClassName;
			var settings = TDM.Config.Selectors;
			var utils = TDM.Utils;

			user_rating_systems = utils.GetElementsByClassName(settings.UserRatingSystem);

			if (user_rating_systems.length > 0) {
				for (var i=0; i<user_rating_systems.length; i++) {
					var div = document.createElement("div");
					var ul = document.createElement("ul");
					var p = document.createElement("p");
					modifyClass.setClass(div, settings.UserRatingSystem, 'add');
					modifyClass.setClass(ul, settings.RatingSystem, 'add');

					var select = user_rating_systems[i].getElementsByTagName('select')[0];
					var options = select.getElementsByTagName('option');
					var selected_option = '';
					
					var current_selection = document.createElement("li");
					modifyClass.Add(current_selection, settings.Current);
					var current_selection_textCDATA = document.createTextNode("Current Selection");
					current_selection.appendChild(current_selection_textCDATA);
					ul.appendChild(current_selection);

					for (var j=0; j<options.length; j++) {
						node = options[j];
						if (node.nodeName=="OPTION") {
							var li = document.createElement("li");
							var a = document.createElement("a");
							var textCDATA = document.createTextNode(node.text);

							modifyClass.setClass(li, node.value, 'add');
							li.title = node.title;

							a.onclick = function(selectElement, optionIndex, selectedOption, currentSelection) {
								return function () {
									selectElement.selectedIndex = -1;
									selectElement.selectedIndex = optionIndex;	
									currentSelection.style.width = 30*(optionIndex+1) + 'px';
									return false;
								};
							}(select, j, selected_option, current_selection);

							a.appendChild(textCDATA);
							li.appendChild(a);
							ul.appendChild(li);
						}
					}
					ul.id = select.id;
					select.parentNode.insertBefore(ul, select.nextSibling);
				}
			}
		},

		ValidateRequiredFields: function() {
			var config = TDM.Config;
			var modifyClass = TDM.Utils.ClassName;
			var settings = config.Selectors;
			var constants = config.Init; 

			form_elements = TDM.Utils.GetElementsByClassName(settings.ValidateRequiredFields, document.getElementsByTagName('form'), '');
			for (var i=0; i<form_elements.length; i++) {
				form_elements[i].onsubmit = function () {
					var r_v = true;
					required_fields = TDM.Utils.GetElementsByClassName(settings.Validate, this.elements, 'partial');
					
					var error_message_elements = TDM.Utils.GetElementsByClassName(settings.ErrorMessage, '', '');
					if (error_message_elements) {
						for (var e=0; e<error_message_elements.length; e++) {
							removedChild = error_message_elements[e].parentNode.removeChild(error_message_elements[e]);
						}
					}

					for (var j=0; j<required_fields.length; j++) {
						modifyClass.Remove(required_fields[j], settings.Error);
						var required_field_classes = required_fields[j].className.split(" ");
						for (var c=0; c<required_field_classes.length; c++) {
							var v_re = required_field_classes[c].match(new RegExp('^'+settings.Validate+'_([^_]+)_(.+)'));
							if (v_re) {
								var checktype = v_re[1];
								var fieldname = v_re[2];

								for (var v=0; v<TDM.Config.ValidationFunctionList.length; v++) {
									if (TDM.Config.ValidationFunctionList[v].checktype==checktype) {
										if(!TDM.Config.ValidationFunctionList[v].func(required_fields[j].value, required_field_classes[c])){
											TDM.Utils.Set.ErrorClass(required_fields[j]);
											TDM.Utils.Set.ErrorMessage(required_fields[j], checktype+'_'+fieldname, TDM.Config.ValidationFunctionList[v].error);
											r_v = false;
										}
									}
								}
							}
						}
					}

					location.hash= '#' + this.id;
					return r_v && true;
				};
			}
		},

		ValidateField: {
			Isset: function(str) {
				if (str.length > 0) {
					var r_v = true;	
				}
				return r_v || false;
			},
			Pattern: {
				Email: function (str) {
					if (TDM.Config.Init.Email_Pattern.test(str)) {
						var r_v = true;
					}
					return r_v || false;
				},
				EmailMultiple: function (str) {
					multiple_emails = str.split(" ");
					var r_v = true;
					for (var y=0; y<multiple_emails.length; y++) {
						if (!TDM.Config.Init.Email_Pattern.test(multiple_emails[y])) {
							r_v = false;
						}
					}
					return r_v || false;
				},

				PostalCode: function(str) {
					if (TDM.Config.Init.Postal_Code_Pattern.test(str)) {
						var r_v = true;
					}
					return r_v || false;
				}
			},
			Identical: function (str_x, str_y) {
				if (str_x.toLowerCase() == str_y.toLowerCase()) {
					var r_v = true;
				}
				return r_v || false;
			},
			IdenticalField: function (str, element_class) {
				var elements = TDM.Utils.GetElementsByClassName(element_class, '', '');
				var init_value = '';
				var r_v = true;

				for (var i=0; i<elements.length; i++) {
					if (init_value === '') {
						init_value = elements[i].value;
					}
					else {
						if (elements[i].value.toLowerCase() != init_value.toLowerCase()) {
							r_v = false;
						}
					}
				}
				return r_v || false;
			}
		},
		Set: {
			ErrorClass: function(el) {
				var modifyClass = TDM.Utils.ClassName;
				var settings = TDM.Config.Selectors;
				
				modifyClass.Add(el, settings.Error);
				el.onfocus = function () {
					modifyClass.Remove(this, settings.Error);
				};
			},
			ErrorMessage: function (el, error_message_value, default_error) {
				var modifyClass = TDM.Utils.ClassName;
				var settings = TDM.Config.Selectors;
				var error_message_text = (TDM.Config.Messages.Errors[error_message_value]) ? TDM.Config.Messages.Errors[error_message_value] : default_error; 
				var error_message = document.createElement("em");
				var error_message_textCDATA = document.createTextNode(error_message_text);
				modifyClass.setClass(error_message, settings.ErrorMessage, 'add');
				error_message.appendChild(error_message_textCDATA);
				
				el.parentNode.insertBefore(error_message, el.nextSibling);
			}
		}
	}
};



function Go() {
	TDM.Utils.AddEvent(window, 'unload', TDM.Utils.FlushEvents);

	if (document.getElementById('highlights')) {
		var datas = document.getElementById('highlights_data').getElementsByTagName('li');
		var actions = document.getElementById('highlights_titles').getElementsByTagName('li');

		TDM.Utils.Tabbing(datas, actions);
		TDM.Utils.FadeInInit(datas, actions, TDM.Config.Init.OpacityStart);
		TDM.Utils.SliderInit(datas, actions, 0);
	}

	if (document.getElementById('action_print')) {
		if (document.getElementById('action_print').getElementsByTagName('span')[0].title.length === 0) {
			document.getElementById('action_print').getElementsByTagName('span')[0].onclick = function(){ window.print(); };
		}
		else {
			document.getElementById('action_print').getElementsByTagName('span')[0].onclick = function(){ window.open(document.getElementById('action_print').getElementsByTagName('span')[0].title); };
		}
	}

	TDM.Utils.DropDown();
	TDM.Utils.OpenResourceOnNewWindow();
	TDM.Utils.ValidateRequiredFields();	
	TDM.Utils.RatingSystem();
}

/* IE6 background flickering */
try {
document.execCommand("BackgroundImageCache", false, true);
} catch(err) {}