var Dom = YAHOO.util.Dom;
var Event = YAHOO.util.Event;
var $ = function(id) {
	return document.getElementById(id);
}

YAHOO.widget.DataTable.MSG_EMPTY = "Geen resultaten gevonden.";
YAHOO.widget.DataTable.MSG_LOADING = "Resultaten worden geladen...";
YAHOO.widget.DataTable.MSG_ERROR = "Service is niet beschikbaar.";

YAHOO.widget.DataTable.formatText = function(elCell, oRecord, oColumn, oData) {
	if (oData && ((YAHOO.lang.trim(oData)).length > 0) && (currentDictType != DIKKE)) {
		elCell.innerHTML = "<img src = '../template/v0/image/zoekservice/"+oData+".gif'/>";
	}
	Event.addListener(elCell.parentNode,"mouseover",isOverTr,elCell.parentNode);
	Event.addListener(elCell.parentNode,"mouseout",isOutTr,elCell.parentNode);
};

isOverTr = function(e) {
	Dom.addClass(this,"over");
}
isOutTr = function(e) {
	Dom.removeClass(this,"over");
}

//Only for ALPHABETIC_SEARCH
YAHOO.widget.DataTable.formatHitSelection = function(elCell, oRecord, oColumn, oData) {
	elCell.innerHTML = oData;
	if (oRecord.getData().index == wordLists[ALPHABETIC_LIST].dataSource.pageData.hit) {
		Dom.addClass(elCell.parentNode,"hit");
	} else {
		Dom.removeClass(elCell.parentNode,"hit");
	}   
	YAHOO.widget.DataTable.formatCurrentSelection(elCell, oRecord, oColumn, oData);
}
//Marks the loaded article headword
YAHOO.widget.DataTable.formatCurrentSelection = function(elCell, oRecord, oColumn, oData) {
	elCell.innerHTML = oData;
	var table = elCell.parentNode.parentNode.parentNode;
	if (table.id == currentSelection.tableId && oRecord.getData().index == currentSelection.index) {
		Dom.addClass(elCell.parentNode,"selectedWord");
	} else if (table.id == currentSelection.tableId) {
		Dom.removeClass(elCell.parentNode,"selectedWord");
	}
}
YAHOO.namespace(NAMESPACE);
 
//++++++++++++++++++++++++++++++++++++
// TOGGLE
// 12/4/2007 - Edwart Visser / Arjen Weeber
//
// toggle the view of elements
//
// REQUIRES: yahoo-dom-event.js
//
//++++++++++++++++++++++++++++++++++++
YAHOO.vandale.toggle = {
		init : function() {
			toggleLinks = Dom.getElementsByClassName("toggle");
			toggleElems = [];
			for(var i=0; i<toggleLinks.length; i++) {
				var rel = toggleLinks[i].rel ? toggleLinks[i].rel : toggleLinks[i].value;
				var elems = toggleElems[rel] != null ? toggleElems[rel] : [];
				elems.push(toggleLinks[i]);
				toggleElems[rel] = elems;
				Event.addListener(toggleLinks[i],"click", this.toggleElements);          
			}
			/* Handle Taalhandboek Toggle */
			if (currentDictType == TAALHANDBOEK) {
				toggleLinks = Dom.getElementsByClassName("languageToggle");
				for(var i=0; i<toggleLinks.length; i++) {
					var rel = toggleLinks[i].rel ? toggleLinks[i].rel : toggleLinks[i].value;
					if (!Dom.hasClass(toggleLinks[i], "disabled") ) {
						Event.addListener(toggleLinks[i],"click", this.toggleThxLanguage);			
					}
				}
			}
		},

		toggleThxLanguage : function(e,controlNode)	{
			if (e) {
				Event.stopEvent(e);
			}
	
			var btn; //button to disable
			var chk; //radio input to enable
			var lbl = Dom.get('lblDictionary'); //label
			var txt = this.title; //text to show in label
			
			if(this.id == 'btnDutch'){
				btn = Dom.get('btnEnglish');
				chk = Dom.get('lang_nn');
				}
			
			if(this.id == 'btnEnglish'){
				btn = Dom.get('btnDutch');
				chk = Dom.get('lang_ee');
			}
			
			lbl.innerHTML = txt;
			Dom.removeClass(btn,"selected");
			Dom.addClass(this,"selected");
			chk.checked = true;
		
			$("fldKeyword").value = '';
			wordLists[INHOUDSOPGAVE_LIST].loadInhoudsopgave(getDictSelection(), getDictType()); 
			// 20111111 also reset other lists when switching dictionary
			wordLists[1].reset();
			wordLists[2].reset();
		},

		toggleElements : function(e,controlNode) {
			if (e) {
				Event.stopEvent(e);
			}
			if(this.rel || (this.type == 'image' && this.value)) {
				controlNode = this;
			}
			if(typeof(controlNode) == "string") {
				controlNode = Dom.get(controlNode);
			}

			var rel = controlNode.rel ? controlNode.rel : controlNode.value;
			var refEl = Dom.get(rel);

			if(controlNode && refEl) {  
				for (var i = 0; toggleElems[rel] != null && i < toggleElems[rel].length; i++ ){
					if(Dom.hasClass(refEl,"show")) {
						if (toggleElems[rel][i].getAttribute("rel") == "exactList_toggle") {
							Dom.removeClass(toggleElems[rel][i].parentNode,"selected");
						}
						Dom.removeClass(toggleElems[rel][i],"selected");
					} else {
						if (toggleElems[rel][i].getAttribute("rel") == "exactList_toggle") {
							Dom.addClass(toggleElems[rel][i].parentNode,"selected");
						}
						Dom.addClass(toggleElems[rel][i],"selected");
					}
				}

				if(Dom.hasClass(refEl,"show")) {
					Dom.removeClass(refEl,"show");
					if (currentDictType == TAALHANDBOEK) {
						var toggleText = YAHOO.util.Dom.get("patternMatchCount");
						toggleText.innerHTML = '';
						// 20111102 verwijder ook zoekwoord en markeringen van zoekwoord
						$('fldSearchLemma').value='Zoeken in huidige paragraaf...';
						thx.ej('');
					}
				} else {
					Dom.addClass(refEl,"show");
				}           
			}

			// if a list is collapsed determine new size
			if (currentDictType == TAALHANDBOEK) {
				determineListsHeight();
			}

			if (controlNode.id && controlNode.id == "useBooks") {
				var query = '';
				if (currentDictType == PRO && YAHOO.vandale.booleanSearch.getSearchString().length > 0) {
					query = YAHOO.vandale.booleanSearch.getSearchString();
				} else if ($("fldKeyword").value.length > 0) {
					query = $("fldKeyword").value;
				}
				if (query.length > 0) {
					updateResults(query, isJokerSearch(query), isBooleanSearch(query));
				}
			}
			// disable control node's default behaviour
			return false;
		}
}
//++++++++++++++++++++++++++++++++++++
// YUI NOTIFY
// 11/28/2007 - Edwart Visser
//
// shows a dialog
//
// REQUIRES: yahoo-dom-event.js, dragdrop-min.js, container-min.js
// OPTIONAL: animation-min.js
//
//++++++++++++++++++++++++++++++++++++
YAHOO.vandale.notificationHandler = { 
		specs: null,
		init: function() {
			this.specs =
			{ 
					width:"760px",
					height: "500px",
					modal:true, 
					visible:true, 
					draggable:true, 
					close:true, 
					fixedcenter: true
					// effect:{effect:YAHOO.widget.ContainerEffect.FADE,duration:0.5}
			}
		},

		notify : function(message,type) { 
			this.init();

			this.notifyPanel = new YAHOO.widget.Panel("notifyPanel",this.specs);
			this.notifyPanel.setHeader(type);
			this.notifyPanel.setBody(message);
			this.notifyPanel.render(document.body);

			// timeout is needed because of a "slow performance" bug with destroying
			// 20111107 IHO removed because this only seems to be needed in browsers < IE7, it messes up IE7 and newer browsers don't need it at all
//			var panelToDestroy = this.notifyPanel;
//			var destroyTimer = function() { window.setTimeout(function() { panelToDestroy.destroy(); },0);};
//			this.notifyPanel.hideEvent.subscribe(destroyTimer); 
		}
}

YAHOO.vandale.showDialog = function(title,obj) {
	if(typeof(title) != "string") {
		Event.preventDefault(title);
		title = obj.title;
		url = obj.url;
	} else {
		url = obj;
	}
	var notificationMessage = "<iframe src='"+url+"' width='745px' height='465px'></iframe>";
	var notificationHeader = title;
	YAHOO.vandale.notificationHandler.notify(notificationMessage,notificationHeader);
}

//++++++++++++++++++++++++++++++++++++
// INIT HELP DIALOGUES
// 12/17/2007 - Edwart Visser
//++++++++++++++++++++++++++++++++++++
YAHOO.vandale.helpDialogues = {
		init : function() {
			var helpLinks = Dom.getElementsByClassName("help","a");
			for(var i=0; i< helpLinks.length; i++) {
				elProps = {
						title : helpLinks[i].getAttribute("title"),
						url : helpLinks[i].getAttribute("href")
				}
				Event.on(helpLinks[i],"click",YAHOO.vandale.showDialog,elProps);
			}
		}
}

//++++++++++++++++++++++++++++++++++++
// INIT PRINT BUTTON
// 12/18/2007 - Edwart Visser
//++++++++++++++++++++++++++++++++++++
YAHOO.vandale.printLemma = {
		init : function() {
			var printButton = $("printLemma");
			Event.on(printButton,"click",this.printItem);
		},
		printItem : function() {
			window.print();
		}
}

//++++++++++++++++++++++++++++++++++++
// INTI HOVER (IE6 ONLY)
// 12/19/2007 - Edwart Visser
//++++++++++++++++++++++++++++++++++++
YAHOO.vandale.hover = {
		init : function() {
			var elems = new Array("adjustFontSize", "showExtras");
			for (var i = 0; i < elems.length; i++) {
				var el = $(elems[i]);
				Event.on(el,"mouseover",this.isOver,el);
				Event.on(el,"mouseout",this.isOut,el);
			}
		},
		isOver : function(e,obj) {
			Dom.addClass(obj,"isOver");
		},
		isOut : function(e,obj) {
			Dom.removeClass(obj,"isOver");
		}
}

//++++++++++++++++++++++++++++++++++++
// FONT RESIZER
// 12/18/2007 - Edwart Visser
//++++++++++++++++++++++++++++++++++++
YAHOO.vandale.fontResize = {
		init : function() {
			body = document.getElementsByTagName("BODY")[0];
			fontResizer = $("fontSelection");
			if(fontResizer) {
				fontResizeLinks = fontResizer.getElementsByTagName("A"); 
				if(fontResizeLinks.length > 0) {
					for(var i=0; i<fontResizeLinks.length; i++) {
						Event.on(fontResizeLinks[i],"click",this.resizeFont,fontResizeLinks[i]);
					}
				}
				if(Cookies.vandaleFontSize){
					Dom.setStyle(body,"font-size",Cookies.vandaleFontSize + "px");
					if(fontResizeLinks.length > 0) {
						for(var i=0; i<fontResizeLinks.length; i++) {
							if(fontResizeLinks[i].getAttribute("rel") == Cookies.vandaleFontSize) {
								obj = fontResizeLinks[i];
							}
							Dom.removeClass(fontResizeLinks[i],"fontSelected");
						}
						Dom.addClass(obj,"fontSelected");
					}
				}
			}
		},
		resizeFont : function(e,obj) {
			var newFontSize = obj.getAttribute("rel");
			Dom.setStyle(body,"font-size",newFontSize + "px");


			if(fontResizeLinks.length > 0) {
				for(var i=0; i<fontResizeLinks.length; i++) {
					Dom.removeClass(fontResizeLinks[i],"fontSelected");
				}
			}
			Dom.addClass(obj,"fontSelected");

			// resize phonetic image on resize of font
			if(YAHOO.util.Dom.getElementsByClassName("ob")) {
				var phoneticImage = YAHOO.util.Dom.getElementsByClassName("ob");
				for(var i=0; i<phoneticImage.length; i++) {
					var src = phoneticImage[i].src;
					var srcParams = src.split("&");
					newSrc = srcParams[0] + "&size=" + newFontSize;
					phoneticImage[i].src = newSrc;
				}
			}

			// reset focus for articles in TAALHANDBOEK
			if (currentDictType == TAALHANDBOEK) {
				var selectedArticle = YAHOO.util.Dom.getElementsByClassName("tc");
				selectedArticle[0].scrollIntoView(true);
				am.currentWord.scrollIntoView( true );
			}

			Cookies.create("vandaleFontSize",newFontSize,1000);
		}
}

//++++++++++++++++++++++++++++++++++++
// BOOLEAN SEARCH
// 12/12/2007 - Edwart Visser
//
// toggle the view
// add / remove inputs
//
// REQUIRES: yahoo-dom-event.js
//
//++++++++++++++++++++++++++++++++++++
YAHOO.vandale.booleanSearch = {
		init : function() {
			// defining objects
			booleanSearchActive = false;
			toggleLink = $("toggleExtraOptions");
			extraOptionsContainer = $("extraOptions");
			fldKeyword = $("fldKeyword");
			fldBooleanKeyword = $("fldBooleanKeyword");
			booleanSearchContainer = $("booleanSearch");
			booleanRows = Dom.getElementsByClassName("frmBooleanRow","div",booleanSearchContainer);
			addFieldLink = Dom.getElementsByClassName("addBoolean")[0];

			// add toggle event to view boolean search options
			Event.addListener(toggleLink,"click",this.toggleSearch,this);

			// add addRow events to buttons
			var addButton = Dom.getElementsByClassName("addBoolean","a",booleanSearchContainer)[0];
			Event.addListener(addButton,"click",this.addRow,this);

			// add removeRow events to buttons
			var removeButtons = Dom.getElementsByClassName("removeBoolean","a",booleanSearchContainer);
			for(var j=0;j<removeButtons.length;j++) {
				Event.addListener(removeButtons[j],"click",this.removeRow,this);
			}

			// cancel boolean search button
			var cancelButton = $("butBooleanCancel");
			Event.addListener(cancelButton,"click",this.cancelSearch,this); 

			// boolean search button
			var searchButton = $("butBooleanSearch");
			Event.addListener(searchButton,"click",this.doSearch,this);         
		},
		doSearch : function(e, obj) {
			Event.stopEvent(e);
			var query = obj.getSearchString();
			fldKeyword.value = query;
			updateResults(fldKeyword.value, isJokerSearch(fldKeyword.value), isBooleanSearch(fldKeyword.value));
		},
		toggleSearch : function (e,obj) {
			Event.stopEvent(e);
			//if(Dom.hasClass(extraOptionsContainer,"show")) {
			if(booleanSearchActive == false) {
				// hide boolean search
				obj.disableNormalSearch();
				booleanSearchActive = true;
			} else {
				// show boolean search
				obj.enableNormalSearch();
				booleanSearchActive = false;
			}
		},
		disableNormalSearch : function() {
			// disable normal search (SHOW)
			// disable input of keyword
			fldKeyword.setAttribute("disabled","disabled");
			Dom.addClass(fldKeyword,"disabled");

			// tranfer value to boolean search
			var keywordValue = fldKeyword.value;

			// split input into boolean options
			var andWords = keywordValue.split('+');
			var finalWords = [];
			var count = 0;
			for (var i = 0; i < andWords.length; i++)   {
				var orWords = andWords[i].split('|');
				for (var j = 0; j < orWords.length; j++) {
					orWords[j] = YAHOO.lang.trim(orWords[j]);
					if (orWords[j].length > 0) {
						finalWords[count++] = {word:orWords[j], join: j==0 ? 'EN' : 'OF'}
					}               
				}
			}
			if (finalWords[0]) {
				fldBooleanKeyword.value = finalWords[0].word;
			}
			if (finalWords.length > 1) {
				for (var i = 1; i < finalWords.length && i < 4; i++) {
					this.addValue(i, finalWords[i].word, finalWords[i].join);
				}
			} else {
				this.addValue(1, '', 'EN');
			}
		},
		enableNormalSearch : function() {
			// enable normal search (HIDE)

			// enable input of keyword
			if (getDictSelection().length > 0) {
				fldKeyword.removeAttribute("disabled");
				Dom.removeClass(fldKeyword,"disabled");         
			}

			// transfer value to input
			fldKeyword.value = this.getSearchString();

			// clear all fields
			this.cancelSearch();
		},
		getSearchString : function() {
			var newValue = YAHOO.lang.trim(fldBooleanKeyword.value);

			for(var i=1;i<booleanRows.length;i++) {
				// skip the first, this is the default search field
				if(Dom.hasClass(booleanRows[i],"show")) {
					var val = YAHOO.lang.trim(booleanRows[i].getElementsByTagName("input")[0].value);
					if (val.length > 0) {
						if(newValue.length > 0 && booleanRows[i].getElementsByTagName("select")[0].value == "EN"){
							newValue += "+";
						} else if(newValue.length > 0 && booleanRows[i].getElementsByTagName("select")[0].value == "OF") {
							newValue += "|";
						}
						// get value
						newValue += YAHOO.lang.trim(booleanRows[i].getElementsByTagName("input")[0].value);
					}
				}

			}
			return newValue;        
		},
		addValue : function(row,value,join) {
			var booleanRowInput = Dom.getElementsByClassName('fldBoolean', 'input', booleanRows[row]);
			booleanRowInput[0].value = value;
			booleanRows[row].getElementsByTagName("select")[0].value = join;        
			this.addRow();
		},
		addRow : function(e,obj) {      
			if (e) {
				Event.preventDefault(e);
			}
			for(var i=0; i<booleanRows.length; i++) {
				if(!Dom.hasClass(booleanRows[i],"show")) {
					Dom.addClass(booleanRows[i],"show");
					break;
				}
				if(i == booleanRows.length - 2) {
					// is last item, hide "add fields"
					Dom.addClass(this,"hideButton");
				}
			}
		},
		removeRow : function(e,obj) {
			Event.preventDefault(e);
			var previousElement = Dom.getPreviousSibling(this.parentNode);
			var previousAddLink = Dom.getElementsByClassName("hideButton","a",previousElement)[0];

			Dom.removeClass(previousAddLink,"hideButton")
			Dom.removeClass(this.parentNode,"show");
			Dom.removeClass(addFieldLink,"hideButton");

			var inputField = this.parentNode.getElementsByTagName("input")[0];
			inputField.value = "";
			var joinType = this.parentNode.getElementsByTagName("select")[0];
			joinType.value   = "EN";        

		},
		cancelSearch : function(e,obj) {
			if (e) {
				Event.preventDefault(e);
			}
			// clear and hide all fields
			for(var i = 0; i < booleanRows.length; i++) {
				if (i != 0) {
					//if (i > 1) {
					Dom.removeClass(booleanRows[i],"show");
					//}
					var joinType = booleanRows[i].getElementsByTagName("select")[0];
					joinType.value   = "EN";                
				}                   
				var inputField = booleanRows[i].getElementsByTagName("input")[0];
				inputField.value = "";
			}

			// show add fields button
			Dom.removeClass(addFieldLink,"hideButton");

			// hide container and enable search field
			if (e) {
				YAHOO.vandale.toggle.toggleElements("extraOptions",toggleLink);
				fldKeyword.value = "";
			}
			if (getDictSelection().length > 0) {
				fldKeyword.removeAttribute("disabled");
				Dom.removeClass(fldKeyword,"disabled");
			}

			booleanSearchActive = false;
		}
}


//++++++++++++++++++++++++++++++++++++
//INIT widgets section
//++++++++++++++++++++++++++++++++++++
function initAutoCompleteBox(inputItem, container) {
	var myServer = ENGINE_SERVER+"/ndc-vzs/search/autoComplete.vdw"; 
	var mySchema = ["result", "headword"];
	// Datasource def
	
	if(!YAHOO.widget.DS_XHR)return;
	
	myDataSource = new YAHOO.widget.DS_XHR(myServer, mySchema);
	myDataSource.responseType = YAHOO.widget.DS_XHR.TYPE_XML;
	myDataSource.scriptQueryParam = "pattern";
	myDataSource._doQueryOriginal = myDataSource.doQuery;
	myDataSource.doQuery = function(oCallbackFn , sQuery , oParent) {

		var decodedQuery = decodeURIComponent(sQuery); 

		// TODO move softKeyboard translation to softKeyboard object if more softKeys needed in future
		// TODO create resolveTranslation for each key and dict only for ZN
		if (/zn/.test(getDictSelection())) {
			var re = /\\/g;
			if (re.test(decodedQuery)){
				decodedQuery = decodedQuery.replace(/\\/g,"å");
				Dom.get('fldKeyword').value = decodedQuery; 
			}
		}
		if (decodedQuery.indexOf('*') != -1 || decodedQuery.indexOf('?') != -1 || decodedQuery.indexOf('|') != -1 || decodedQuery.indexOf('+') != -1) {
			oCallbackFn(sQuery, new Array(), oParent);
		} else {
			this._doQueryOriginal(oCallbackFn , sQuery , oParent);
		}
	}   
	myDataSource.scriptQueryAppend = "lang="+getDictSelection()+"&viewCount=10";
	handleError = function(name, res) {
		handleCommunicationException(res);
	}

	// myDataSource.dataErrorEvent.subscribe(handleError);
	myDataSource.connMgr.failureEvent.subscribe(handleError);   
	// Autocomplete def
	myAutoComp = new YAHOO.widget.AutoComplete(inputItem,container, myDataSource);
	myAutoComp.autoHighlight = true;
	myAutoComp.allowBrowserAutocomplete = false;
	myAutoComp.prehighlightClassName = "myCustomPrehighlightClass"; 

	itemSelectHandler = function(sType, aArgs) {
		var selected = aArgs[2][0];
		// IHO 20111025 If in taalhandboek then strip jokercharacters from selected entry from autocompletelist
		if (currentDictType == TAALHANDBOEK) {
			selected = selected.replace(/\*/g,''); // remove all '*'
			selected = selected.replace(/\?/g,''); // remove all '?'
		}
		updateResults(selected);
	};
	myAutoComp.doBeforeExpandContainer = function(oTextbox, oContainer, sQuery , aResults) {
		if (submitMutex) {
			submitMutex = false;
			return false;   
		}
		return true;
	};  

	doShowBooleanSearch = function() {
		// show extraoptions and booleansearch
	}

	myAutoComp.containerCollapseEvent.subscribe(doShowBooleanSearch);
	myAutoComp.itemSelectEvent.subscribe(itemSelectHandler);
	myAutoComp.doBeforeSendQuery = function(sQuery) {
		this.dataSource.scriptQueryAppend = "lang="+getDictSelection()+"&dict="+getDictType()+"&viewCount=10";
		this.dataSource.flushCache();
		return sQuery;
	}
}

var EXACT_LIST          = 0;
var ALPHABETIC_LIST     = 1;
var IN_ARTICLES_LIST    = 2;
var INHOUDSOPGAVE_LIST  = 0;
var INDEX_LIST          = 1;
function initWordLists(articleManager) {
	var wordLists = [];
	if (currentDictType != TAALHANDBOEK) {
		// EXACT_LIST, for basis, pro and dikke
		wordLists[EXACT_LIST] = new DataTableWrapper(EXACT_LIST, EXACT_SEARCH, ENGINE_SERVER+"/ndc-vzs/search/searchExact.vdw?", 
				{   resultNode: "result", // Node name of each result item
			fields: ["headword","headwordDisplay", "index", "lang", "sup"] // Field names
				},
				[ 
				 {key:"headwordDisplay", label:"", formatter:YAHOO.widget.DataTable.formatCurrentSelection},
				 {key:"lang", label:"", formatter:YAHOO.widget.DataTable.formatText}
				 ],"exactList",articleManager,false,7,{initialRequest:"pattern=&lang=nn"}
		);
		Event.addListener($("exactList_prev"),"click",wordLists[EXACT_LIST].loadPrevPage, wordLists[EXACT_LIST]);
		Event.addListener($("exactList_next"),"click",wordLists[EXACT_LIST].loadNextPage, wordLists[EXACT_LIST]);                 
		// ALPHABETIC_LIST, for basis, pro and dikke
		wordLists[ALPHABETIC_LIST] = new DataTableWrapper(ALPHABETIC_LIST, ALPHABETIC_SEARCH, ENGINE_SERVER+"/ndc-vzs/search/searchAlphabetic.vdw?", 
				{   resultNode: "result", // Node name of each result item
			fields: ["headword","headwordDisplay","index", "lang", "sup"] // Field names
				},
				[ 
				 {key:"headwordDisplay", label:"", formatter:YAHOO.widget.DataTable.formatHitSelection}, 
				 {key:"lang", label:"", formatter:YAHOO.widget.DataTable.formatText}
				 ],"alphabeticList",articleManager,false,5
		);
		Event.addListener($("alphabeticList_prev"),"click",wordLists[ALPHABETIC_LIST].loadPrevPage, wordLists[ALPHABETIC_LIST]);
		Event.addListener($("alphabeticList_next"),"click",wordLists[ALPHABETIC_LIST].loadNextPage, wordLists[ALPHABETIC_LIST]);
	}

	if (currentDictType == TAALHANDBOEK) {  // 20110822 IHO add wordlists for Taalhandboeken
		// INHOUDSOPGAVE_LIST for taalhandboek
		wordLists[INHOUDSOPGAVE_LIST] = new DataTableWrapper(INHOUDSOPGAVE_LIST, INHOUDSOPGAVE_SEARCH, ENGINE_SERVER+"/ndc-vzs/search/searchInhoudsopgave.vdw?", 
				{   resultNode: "result", // Node name of each result item
			fields: ["headword","headwordDisplay","index", "lang", "sup"] // Field names
				},
				[ 
				 {key:"headwordDisplay", label:""},
				 {key:"lang", label:"", formatter:YAHOO.widget.DataTable.formatText}
				 ],"inhoudsopgaveList",articleManager,false,2000,{initialRequest:"pattern=&lang=nn"} // actually  1146 items
		);  
		// INDEX_LIST for taalhandboek
		wordLists[INDEX_LIST] = new DataTableWrapper(INDEX_LIST, INDEX_SEARCH, ENGINE_SERVER+"/ndc-vzs/search/searchIndex.vdw?", 
				{   resultNode: "result", // Node name of each result item
			fields: ["headword","headwordDisplay","index", "lang", "sup"] // Field names
				},
				[ 
				 {key:"headwordDisplay", label:"", formatter:YAHOO.widget.DataTable.formatCurrentSelection},
				 {key:"lang", label:"", formatter:YAHOO.widget.DataTable.formatText}
				 ],"indexList",articleManager,false,5,{initialRequest:"pattern=&lang=nn"}
		);  
		Event.addListener($("indexList_prev"),"click",wordLists[INDEX_LIST].loadPrevPage, wordLists[INDEX_LIST]);
		Event.addListener($("indexList_next"),"click",wordLists[INDEX_LIST].loadNextPage, wordLists[INDEX_LIST]);
		// IN_ARTICLES_LIST for taalhandboek
		wordLists[IN_ARTICLES_LIST] = new DataTableWrapper(IN_ARTICLES_LIST, IN_ARTICLE_SEARCH, ENGINE_SERVER+"/ndc-vzs/search/searchInArticles.vdw?", 
				{   resultNode: "result", // Node name of each result item
			fields: ["headword","headwordDisplay","index", "lang", "sup"] // Field names
				},
				[ 
				 {key:"headwordDisplay", label:"", formatter:YAHOO.widget.DataTable.formatCurrentSelection},
				 {key:"lang", label:"", formatter:YAHOO.widget.DataTable.formatText}
				 ],"inArticlesList",articleManager,true,5,{initialRequest:"pattern=&lang=nn"}
		);  
		Event.addListener($("inArticlesList_prev"),"click",wordLists[IN_ARTICLES_LIST].loadPrevPage, wordLists[IN_ARTICLES_LIST]);
		Event.addListener($("inArticlesList_next"),"click",wordLists[IN_ARTICLES_LIST].loadNextPage, wordLists[IN_ARTICLES_LIST]);
	}           

	if ((currentDictType == PRO) || (currentDictType == DIKKE)) {
		// IN_ARTICLES_LIST for pro, dikke
		wordLists[IN_ARTICLES_LIST] = new DataTableWrapper(IN_ARTICLES_LIST, IN_ARTICLE_SEARCH, ENGINE_SERVER+"/ndc-vzs/search/searchInArticles.vdw?", 
				{   resultNode: "result", // Node name of each result item
			fields: ["headword","headwordDisplay","index", "lang", "sup"] // Field names
				},
				[ 
				 {key:"headwordDisplay", label:"", formatter:YAHOO.widget.DataTable.formatCurrentSelection},
				 {key:"lang", label:"", formatter:YAHOO.widget.DataTable.formatText}
				 ],"inArticlesList",articleManager,true,7,{initialRequest:"pattern=&lang=nn"}
		);  
		Event.addListener($("inArticlesList_prev"),"click",wordLists[IN_ARTICLES_LIST].loadPrevPage, wordLists[IN_ARTICLES_LIST]);
		Event.addListener($("inArticlesList_next"),"click",wordLists[IN_ARTICLES_LIST].loadNextPage, wordLists[IN_ARTICLES_LIST]);
	}           
	return wordLists;                                   
}

var fetchArticleTimer = null;

function isWildcardOnly(pattern) {
	var temp = pattern;
	var isWildcardOnly = false;
	if (pattern.indexOf('*') != -1 || pattern.indexOf('?') != -1) {
		temp = temp.replace(/\s/g,''); // remove all whitespace
		temp = temp.replace(/\*/g,''); // remove all '*'
		temp = temp.replace(/\?/g,''); // remove all '?'
		temp = temp.replace(/^\s\s*/, '').replace(/\s\s*$/, ''); // trim
		isWildcardOnly = temp.length < 2;
	}
	return isWildcardOnly; 
}

function updateResults(pattern, jokerSearch, boolSearch) {
	if (pattern != null && pattern.length > 0 && !isWildcardOnly(pattern) && getDictSelection().length > 0) {
		searchHistory.addItem(pattern);
		if(YAHOO.util.Dom.get(DIKKE)) {
			$('fldSearchLemma').value='Zoeken in huidig artikel...';
		} else {
			$('fldSearchLemma').value='';
		}
		if(YAHOO.util.Dom.get(TAALHANDBOEK))
			{
				if (Dom.hasClass($('lemmaSearch_overlay'),"show")) {
					YAHOO.vandale.toggle.toggleElements('searchInLemmaObj',$('toggleSearchInLemmaObj'));
				}
			}else{
				if (Dom.hasClass($('searchInLemmaObj'),"show")) {
					YAHOO.vandale.toggle.toggleElements('searchInLemmaObj',$('toggleSearchInLemmaObj'));
				}
			}
		currentSelection = {tableId:'yui-dt0-table', index:-1};
		fetchArticleTimer = setInterval("am.resolveArticleLoad()",200);
		for (var i = 0; i < wordLists.length; i++) {
			if ((boolSearch) && i < 2) { // ALPHABETIC_LIST && EXACT_LIST, and for Taalhandboek INDEX list
				wordLists[i].reset();
				am.loaded = [0,0,-1];
				continue;
			} 
			// load wordlists, but do not load the static inhoudsopgave list for Taalhandboeken
			if (!(currentDictType == TAALHANDBOEK && i == 0) ) {
				wordLists[i].dataTable.switchLoadIndicator(true);
				wordLists[i].reset();
				wordLists[i].reloadData(pattern, getDictSelection(), getDictType());
			}
		}
	}
}
function getDictType() {
	return dictTypes[currentDictType];
}
function getDictSelection() {
	var bookSelDiv = $('bookSelection');
	var dikke = $(DIKKE);
	if (bookSelDiv) {
		return getSelected(bookSelDiv.getElementsByTagName('input'));
	} else if (dikke) {
		return DICTTYPE_DIKKE+';';
	}
}
function getSelected(options) {
	var s = '';
	var cookieString = '';
	for (var i = 0; i < options.length; i++) {
		if (options[i].id.substring(0,4) == 'lang' && options[i].checked && !options[i].disabled) {
			s += options[i].id.substring(5)+';';
			cookieString += options[i].id.substring(5)+',';
		}
	}
	// by default enable nederlands for Taalhandboek
	if (currentDictType == TAALHANDBOEK && cookieString == '') {
		s += options[0].id.substring(5)+';';
		cookieString += options[0].id.substring(5)+',';
	}
	Cookies.create(currentDictType+"_langs", cookieString, 180);
	return s;
}

//++++++++++++++++++++++++++++++++++++
// Wrappers
//++++++++++++++++++++++++++++++++++++
function DataTableWrapper(id, searchType, sourceURL, responseSchema, columnDefs, container, articleManager, highlightPattern, itemsCount, options) {  
	// set dataSource
	if(!YAHOO.util.DataSource)return;
	this.dataSource = new YAHOO.util.DataSource(sourceURL);
	this.dataSource.searchType = searchType;
	this.dataSource.responseType = YAHOO.util.DataSource.TYPE_XML;
	this.dataSource.responseSchema = responseSchema;
	this.dataSource.connMethodPost = true;
	// custom data
	this.dataSource.pageData = { totalCount:0, viewCount: itemsCount, pattern:"", lang:"", dictType:" ", page:0, hit:-1};
	// set dataTable
	this.dataTable = new YAHOO.widget.DataTable(container, columnDefs, this.dataSource, options); 
	this.dataTable.articleManager = articleManager;
	this.dataTable.highlightPattern = highlightPattern;
	this.dataTable.container = container;
	this.dataTable.loadIndicator = $(container + "_loading");
	this.dataTable.parentId = id;

	this.dataSource.finished = [false,false];           

	this.reset = function() {
		this.dataSource.finished = [false,false];
		if (this.dataSource.results != null) {
			this.dataTable.deleteRows(0, this.dataSource.results.length);
		}
		this.dataTable.updateCounter("(0)");
		this.dataSource.pageData = { totalCount:0, viewCount: this.dataSource.pageData.viewCount, pattern:"", lang:"", dictType:" ", page:-1 , hit:-1};
		this.dataSource.results = [];
		this.dataTable.checkPageAvailability();
	}
	this.reloadData = function(pattern, lang, dict) {
		pattern = encodeURIComponent(pattern);
		if (currentDictType == TAALHANDBOEK) {
			this.dataSource.sendRequest('pattern='+pattern+'&lang='+lang+'&dict=' + dict + '&page='+this.dataSource.pageData.page + '&viewCount='+this.dataSource.pageData.viewCount, this.dataTable.onDataReturnInitializeThxTables, this.dataTable);
		} else {
			this.dataSource.sendRequest('pattern='+pattern+'&lang='+lang+'&dict=' + dict + '&page='+this.dataSource.pageData.page + '&viewCount='+this.dataSource.pageData.viewCount, this.dataTable.onDataReturnInitializeTable, this.dataTable);
		}
	}
	// 20111116 IHO callback method for taalhandboek 
	this.dataTable.onDataReturnInitializeThxTables = function(sRequest, oResponse) {
		// after inhoudsopgavelijst is loaded determine height for lists
		this.onDataReturnInitializeTable(sRequest, oResponse);
		determineListsHeight();
	}


	// 20110914 IHO load inhoudsopgavelijst and use different callbackmethod
	this.loadInhoudsopgave = function(lang, dict) {
		wordLists[INHOUDSOPGAVE_LIST].dataTable.switchLoadIndicator(true);
		wordLists[INHOUDSOPGAVE_LIST].reset();
		// for next call we need to give a pattern otherwise clicking on the rows doesn't work!
		this.dataSource.sendRequest('pattern=a&lang=' +lang+ '&dict=' +dict+ '&page=-1&viewCount=2000', this.dataTable.onDataReturnInitializeInhoudsopgaveTable, this.dataTable);
	}
	// 20110914 IHO callback method for inhoudsopgavelijst 
	this.dataTable.onDataReturnInitializeInhoudsopgaveTable = function(sRequest, oResponse) {
		// after inhoudsopgavelijst is loaded immediately fetch the first article
		this.onDataReturnInitializeTable(sRequest, oResponse);
		am.currentWord = wordLists[INHOUDSOPGAVE_LIST].dataTable.selectRow(0);
		am.fetchArticle('a', 0, getDictSelection(), getDictType(), INHOUDSOPGAVE_SEARCH, false, null, false);
	}
	
	this.dataTable.switchLoadIndicator = function(on) {
		if (on) {
			Dom.removeClass(this.loadIndicator,"loaded");
		} else {
			Dom.addClass(this.loadIndicator,"loaded");
		}
	}
	this.dataTable.selectRow = function(resultId) {
		for (var i = 0; i < this._oDataSource.results.length; i++) {
			if (this._oDataSource.results[i].index == resultId) {
				Dom.addClass(this._elTable.rows[i+2],"selectedWord");       
				return this._elTable.rows[i+2];
			}
		}
		return null;
	}
	this.dataTable.highlightInhoudsopgaveRow = function(index) {
		for (var i=0; i<this._elTable.rows.length; i++) {
			Dom.removeClass(this._elTable.rows[i],"hit");
			Dom.removeClass(this._elTable.rows[i],"selectedWord");
		}
		Dom.addClass(this._elTable.rows[index+2],"hit");       
		// 20111121 Fix ?? for scrollintoview error on IE8 build 8.0.7600.16385
		var scrollTo = document.getElementById("yui-dt0-bdrow"+index+"-cell0");
		if (!scrollTo) {
			scrollTo = this._elTable.rows[index+2].firstChild;
		}
		if (!scrollTo) {
			scrollTo = this._elTable.rows[index+2];
		}
		// only scroll into view if scrollto is not null to prevent further errors!
		if (scrollTo != null) {
   			scrollTo.scrollIntoView(true);
		}
	}

	/* Pagination logic **************************** */
	this.dataTable.hasPrevPage = function() {
		var hasPrevPage = false;
		if (this._oDataSource.results && this._oDataSource.results.length > 0) {        
			hasPrevPage = 1*this._oDataSource.results[0].index - 1 >= 0;
		}
		return hasPrevPage; 
	}   
	this.dataTable.hasNextPage = function() {
		var hasNextPage = false;
		if (this._oDataSource.results && this._oDataSource.results.length > 0) {
			hasNextPage = 1*this._oDataSource.results[0].index < this._oDataSource.pageData.totalCount - this._oDataSource.pageData.viewCount;
		} 
		return hasNextPage;
	}
	this.dataTable.loadPage = function(pageNo) {
		this._oDataSource.pageData.page = pageNo;
		this.reloadData(this._oDataSource.pageData.pattern, this._oDataSource.pageData.lang, this._oDataSource.pageData.dictType);
	}
	this.dataTable.loadFirstPage = function() {
		this.loadPage(0);
	}
	this.dataTable.loadLastPage = function() {
		this.loadPage(this.getPagesCount()-1); // 0 based page numbering
	}
	this.dataTable.getPagesCount = function() {
		var wholePages = parseInt(this._oDataSource.pageData.totalCount/this._oDataSource.pageData.viewCount);
		var partialPage = this._oDataSource.pageData.totalCount%this._oDataSource.pageData.viewCount;
		if (partialPage > 0) {
			wholePages++;
		}
		return wholePages;
	}
	this.dataTable.checkPageAvailability = function() {
		var idPrev = this.container + "_prev";
		var idNext = this.container + "_next";
		if (this.hasPrevPage()) {
			Dom.addClass($(idPrev),"active");           
		} else {
			Dom.removeClass($(idPrev),"active");        
		}
		if (this.hasNextPage()) {
			Dom.addClass($(idNext),"active");           
		} else {
			Dom.removeClass($(idNext),"active");        
		}       
	}
	this.dataTable.updateCounter = function(forcedCount) {
		var idCounter = this.container + "_count";
		if ($(idCounter) != null) {
			$(idCounter).innerHTML = forcedCount != null ? forcedCount : '('+ this._oDataSource.pageData.totalCount +')';
		}
	}   
	/* Event handlers ************ */
	this.dataTable.doBeforeLoadData = function(a,res) {
		var success = true;

		if (res.status && res.status != 200) {
			handleCommunicationException(res);
			success = false;
		} else {
			this.checkPageAvailability();
			this.switchLoadIndicator(false);
			this.updateCounter();
			this.articleManager.setLoaded(this, this._oDataSource.results.length);
			this._oDataSource.finished[1] = true;
		}
		return success;
	}

	// public event handlers for next/prev page
	this.loadNextPage = function(e, obj) {
		Event.preventDefault(e);
		obj.dataTable.switchLoadIndicator(true);
		obj.dataTable.checkPageAvailability();
		if (obj.dataTable.hasNextPage()) {
			++obj.dataSource.pageData.page;
			obj.reloadData(obj.dataSource.pageData.pattern, obj.dataSource.pageData.lang, obj.dataSource.pageData.dictType);
			if (currentSelection.tableId == obj.dataTable._elTable.id) { 
				Dom.removeClass(obj.dataTable.articleManager.currentWord,"selectedWord");
			}
		}         
	}
	this.loadPrevPage = function(e,obj) {
		Event.preventDefault(e);
		obj.dataTable.switchLoadIndicator(true);
		obj.dataTable.checkPageAvailability();
		if (obj.dataTable.hasPrevPage()) {
			--obj.dataSource.pageData.page;
			obj.reloadData(obj.dataSource.pageData.pattern, obj.dataSource.pageData.lang, obj.dataSource.pageData.dictType);
			if (currentSelection.tableId == obj.dataTable._elTable.id) { 
				Dom.removeClass(obj.dataTable.articleManager.currentWord,"selectedWord");
			}
		}
	}   

	/* Event handlers **************************** */
	this.dataSource.doBeforeCallback = function(oRequest, oRawResponse, oParsedResponse) {
		this.results = oParsedResponse.results;
		this.pageData.totalCount = oRawResponse.getElementsByTagName('results')[0].getAttribute('count');
		this.pageData.hit = oRawResponse.getElementsByTagName('results')[0].getAttribute('hit');
		this.pageData.pattern = oRawResponse.getElementsByTagName('results')[0].getAttribute('pattern');
		this.pageData.lang = oRawResponse.getElementsByTagName('results')[0].getAttribute('lang');
		this.pageData.dictType = oRawResponse.getElementsByTagName('results')[0].getAttribute('dict');      
		this.pageData.page = parseInt(oRawResponse.getElementsByTagName('results')[0].getAttribute('page'));
		this.finished[0] = true;
		return oParsedResponse;
	}

	function clickRow(e) {
		var src = e.target ? e.target : e.srcElement;
		clearInterval(fetchArticleTimer);
		var index = parseInt(src.rowIndex);
		var skipArticleFetch = false;

		if (am.currentWord) {
			Dom.removeClass(am.currentWord, "selectedWord");
		}
		if (currentDictType == TAALHANDBOEK) {
			var regTitel = new RegExp(/[^-a-zA-Z0-9.,\u00E0():;!]+/g);
			if ( (am.currentWord.textContent && YAHOO.lang.trim(am.currentWord.textContent.replace(regTitel,'')) == YAHOO.lang.trim(src.textContent.replace(regTitel,'')) )
				  ||
				 (am.currentWord.innerText && YAHOO.lang.trim(am.currentWord.innerText.replace(regTitel,'')) == YAHOO.lang.trim(src.innerText.replace(regTitel,'')) )) {
				skipArticleFetch = true;
			}
			else {
				 // also removeclass hit on inhoudsopgavelijst
				var inhoudsopgaveindex = parseInt(am.currentPosid.replace(INDEXPREFIX, ''), 10) + 2;
				Dom.removeClass(wordLists[INHOUDSOPGAVE_LIST].dataTable._elTable.rows[inhoudsopgaveindex], "hit");
			}

			// just in case window is resized, determine new height for inhoudsopgavelist
			determineListsHeight();
		}

		Dom.addClass(src, "selectedWord");
		am.currentWord = src;

		var result = this._oDataSource.results[index - 2];
		currentSelection.index = result.index;
		currentSelection.tableId = this._elTable.id;

		if (!skipArticleFetch) {
			this.articleManager.fetchArticle(this._oDataSource.pageData.pattern, result.index, this._oDataSource.pageData.lang, this._oDataSource.pageData.dictType, this._oDataSource.searchType, this.highlightPattern);
		}
	}

	this.dataTable.subscribe("rowClickEvent", clickRow);
	// this.dataTable.subscribe("dataReturnEvent", this.dataTable.onRefresh);
}

function ArticleManager(headwordContainer, articleContainer, patternMatchContainer,  patternInput, loadIndicator) {
	// dataSource def

	if(!YAHOO.util.DataSource)return;
	
	this.dataSource = new YAHOO.util.DataSource(ENGINE_SERVER+"/ndc-vzs/search/fetchArticle.vdw?"); 
	this.dataSource.responseType = YAHOO.util.DataSource.TYPE_XML; 
	this.dataSource.responseSchema = { 
			resultNode: "result",
			fields: ["headword", "article", "div"] 
	};
	this.dataSource.connMethodPost = true;  

	this.currentWord = null;
	this.loaded = [-1,-1,-1]; // -1 - not loaded yet, >=0 - loaded
	this.currentArticle = null;  // only for taalhandboek
	this.currentPosid = '';  // only for taalhandboek
	this.currentSubpar = '';  // only for taalhandboek

	var dataTable = null;
	var articleContainer = {headword:headwordContainer, article:articleContainer, patternCount: patternMatchContainer, patternInput: patternInput};
	var toHighlight = false;
	var hPattern = ''; 
	var loadIndicator = loadIndicator;

	this.getCurrentArticle = function() {
		// first get the shown articles, these are divs with id (i.e. thx_subparid-d1e148) and posid (i.e. zzzzzzzzzz_0005) 
		var shownArticles = Dom.getElementsByClassName("tr0");
		// from these articles select the one where firstChild.innerHTML matches the innerText of currentword
		this.currentArticle = shownArticles[0];
		this.currentPosid = shownArticles[0].getAttribute("posid");
		this.currentSubpar = shownArticles[0].getAttribute("id");
		var regTitel = new RegExp(/[^-a-zA-Z0-9.,\u00E0():;!]+/g);
		if (this.currentWord.textContent) {
			currentSelectionTitle = YAHOO.lang.trim(this.currentWord.textContent.replace(regTitel,''));
			for (var i=0; i<shownArticles.length; i++) {
				if (shownArticles[i].firstChild.textContent.replace(regTitel,'').indexOf(currentSelectionTitle) == 0 ||
				      // articles starting with question mark
					( shownArticles[i].firstChild.textContent.replace(regTitel,'').indexOf(currentSelectionTitle) > 0 && 
					  shownArticles[i].firstChild.textContent.indexOf("Vraag") == 0) ) {
					this.currentArticle = shownArticles[i];
					this.currentPosid = shownArticles[i].getAttribute("posid");
					this.currentSubpar = shownArticles[i].getAttribute("id");
					break;
				}
			}
		} else {
			currentSelectionTitle = YAHOO.lang.trim(this.currentWord.innerText.replace(regTitel,''));
			for (var i=0; i<shownArticles.length; i++) {
				if (shownArticles[i].firstChild.innerText.replace(regTitel,'').indexOf(currentSelectionTitle) == 0 ||
				      // articles starting with question mark
					( shownArticles[i].firstChild.innerText.replace(regTitel,'').indexOf(currentSelectionTitle) > 0 && 
					  shownArticles[i].firstChild.innerText.indexOf("Vraag") == 0) ) {
					this.currentArticle = shownArticles[i];
					this.currentPosid = shownArticles[i].getAttribute("posid");
					this.currentSubpar = shownArticles[i].getAttribute("id");
					break;
				}
			}
		}
		return parseInt(this.currentPosid.replace(INDEXPREFIX, ''), 10);
	}

	this.callback = function(query, oResponse, caller) {
		if (oResponse.status && oResponse.status != 200) {
			handleCommunicationException(oResponse);
		} else {
			var toggleButton = YAHOO.util.Dom.get("toggleLemmaBlocks");
			if (toggleButton) {
				toggleButton.setAttribute("rel", 0);
			}
			if (oResponse.results[0].headword) {
				articleContainer.headword.innerHTML = oResponse.results[0].headword;
			} else {
				articleContainer.headword.innerHTML = "error";
			}
			var article = oResponse.results[0].article;
			// article = article.replace(/<span
			// class=\"gx\"[^>]*>(.*?)<\/span>/g,"<img class=\"ob\"
			// src=\"../render?text=$1\" alt=\"$1\" />");
			articleContainer.article.innerHTML = article;                                                       

			// 201109 IHO specials for taalhandboek
			if (currentDictType == TAALHANDBOEK) {
				// highlight article title in inhoudsopgave if article is not selected from the inhoudsopgave
				var index = this.getCurrentArticle();
				if (currentSelection.tableId != "yui-dt0-table") {
					wordLists[INHOUDSOPGAVE_LIST].dataTable.highlightInhoudsopgaveRow(index);
				}
				// 20110905 IHO reset show volgende/vorige buttons on article
				this.checkArticleAvailability(index);
				thx.i = null;
				thx.sah(this.currentSubpar.substring(4));
				// position article
				this.currentArticle.scrollIntoView(true);
			}

			if (toHighlight) {          
				toHighlight = false;
				highlightPattern(hPattern);
			}

			// check for audio
			// var articleContainer = document.getElementById("lemmaContent");
			function checker_1(el){
				var x = el.alt === "Klik hier om de uitspraak te horen";
				return x;
			}
			var audioNodes = Dom.getElementsBy(checker_1, "img");
			for(var i=0; i<audioNodes.length; i++) {
				// replace node
				var missingMp3 = ENGINE_SERVER+"/audio/misgepis.mp3";
				var targetNode = audioNodes[i].parentNode;
				var parentNode = targetNode.parentNode;
				var mp3 = targetNode.href;

				/*
				 * [Vdl] Old replacement code was too structure dependant
				 * 
				 * parentNode.removeChild(targetNode); var newNode =
				 * document.createElement("span"); var firstspan =
				 * parentNode.childNodes[0]; firstspan.appendChild(newNode);
				 * 
				 * We now work with replaceChild:
				 */

				var newNode = document.createElement("span");
				parentNode.replaceChild(newNode,targetNode);

				Dom.generateId(newNode);
				mp3 = mp3.replace(/http:\/\/spraak/,ENGINE_SERVER+"/audio/1_0");            


				function makeplayer(file_to_play) {
					file_to_play = encodeURIComponent(file_to_play);
					var options = {quality: "high", wmode: "transparent"};
					var flashvars = {file: file_to_play,
							auto: "no",
							sendstop: "yes",
							repeat: 1,
							buttondir: "../template/v0/image/audioplay",
							bgcolor: "0xffffff",
							mode: "playstop"
					};   
					swfobject.embedSWF("../template/v0/image/audioplay/audioplay.swf",newNode.id , "15", "15", "8.0.0", "../template/v0/image/audioplay/expressInstall.swf", flashvars, options, null, null);
				}

				var callback = { 
						success: function(o){makeplayer(mp3);}, 
						failure: function(o){makeplayer(missingMp3);}
				}  
				var transaction = YAHOO.util.Connect.asyncRequest('HEAD', mp3, callback, null); 
			}
		}
		switchLoadIndicator(false);
	}
	// show glossary articles in popups
	this.callbackGlossarylink = function(query, oResponse, caller) {
		if (oResponse.status && oResponse.status != 200) {
			handleCommunicationException(oResponse);
		} else {
			var title = "error";
			if (oResponse.results[0].headword) {
				title = oResponse.results[0].headword;
			}
			var article = oResponse.results[0].article;
	        YAHOO.vandale.showDialog(title, "/vandale/template/v0/zoekservice/glossary.jsp?article="+article);
		}
	}
	// show links from within a glossary article (in a popup) in the already existing popup
	this.callbackGlossaryPopuplink = function(query, oResponse, caller) {
		if (oResponse.status && oResponse.status != 200) {
			handleCommunicationException(oResponse);
		} else {
			var title = "error";
			if (oResponse.results[0].headword) {
				title = oResponse.results[0].headword;
			}
			var article = oResponse.results[0].article;
			YAHOO.vandale.notificationHandler.notifyPanel.setHeader(title);
			YAHOO.vandale.notificationHandler.notifyPanel.setBody("<iframe src='/vandale/template/v0/zoekservice/glossary.jsp?article="+article+"' width='745px' height='465px'></iframe>");
		}
	}

	this.fetchArticle = function(pattern, index, lang, dictType, searchType, highlightPattern, dt, encodeURI) {
		articleContainer.patternCount.innerHTML = '';
		switchLoadIndicator(true);
		toHighlight = highlightPattern;
		hPattern = pattern;
		// pattern = encodeURI ? encodeURIComponent(pattern) : pattern;
		pattern = encodeURIComponent(pattern);
		this.dataSource.sendRequest('pattern='+pattern+'&index='+index+'&lang='+lang+ '&dict=' + dictType + '&searchType='+searchType, this.callback , this);
		dataTable = dt;
	}
	this.fetchArticleForDataTable = function(dataTable) {
		this.fetchArticle(dataTable._oDataSource.pageData.pattern, dataTable._oDataSource.pageData.hit, dataTable._oDataSource.pageData.lang, dataTable._oDataSource.pageData.dictType, dataTable._oDataSource.searchType, dataTable.highlightPattern, dataTable);
	}
	// 20110905 IHO Get next or previous article from article venster
	this.fetchNextArticle = function(dataTable, index, posid) {
		this.fetchArticle(posid, index, dataTable._oDataSource.pageData.lang, dataTable._oDataSource.pageData.dictType, INHOUDSOPGAVE_SEARCH, dataTable.highlightPattern, dataTable);
	}
	// 20110913 IHO Get article from hyperlink in taalboeken
	this.fetchGlossaryArticle = function(pattern, lang, dictType, inpopup) {
		articleContainer.patternCount.innerHTML = '';
		switchLoadIndicator(true);
		if (inpopup) {
			this.dataSource.sendRequest('pattern='+pattern+'&index=-1&lang='+lang+ '&dict=' + dictType + '&searchType=POSITION_GLOSSARY_ID', this.callbackGlossaryPopuplink , this);
		} else {
			this.dataSource.sendRequest('pattern='+pattern+'&index=-1&lang='+lang+ '&dict=' + dictType + '&searchType=POSITION_GLOSSARY_ID', this.callbackGlossarylink , this);
		}
	}
	
	// 20110902 IHO show/hide volgende/vorige buttons on article navigation
	this.checkArticleAvailability = function(index) {
		if (index > 0) {
			Dom.addClass("lemma_prev","active");           
		} else {
			Dom.removeClass("lemma_prev","active");        
		}
		if (index < wordLists[INHOUDSOPGAVE_LIST].dataSource.results.length - 1) {
			Dom.addClass("lemma_next","active");           
		} else {
			Dom.removeClass("lemma_next","active");        
		}       
	}

	var switchLoadIndicator = function(on) { 
		if (on) {
			Dom.removeClass(loadIndicator,"loaded");
		} else {
			Dom.addClass(loadIndicator,"loaded");
			Dom.setStyle("printLemma","display","block");
		}
	}

	/* awe 10-05-2010, changed to fit basis|pro|dikke context */
	var highlightPattern = function(pattern) {
		if(document.body.id === BASIS) {
			ezxx1.eji(pattern);
		} else if(document.body.id === PRO) {
			gxx.eji(pattern);
		} else if(document.body.id === DIKKE) {
			gwn.eji(pattern);
		} else if(document.body.id === TAALHANDBOEK) { // IHO 20110816
			thx.eji(pattern);
		} 
	}
	/* end awe 10-05-2010, changed to fit basis|pro|dikke context */

//	this.highlightPattern = function(e) {
//	var src = e.target ? e.target : e.srcElement;
//	highlightPattern(src.value);
//	}
	this.searchInArticle = function(e) {
		Event.preventDefault(e);
		highlightPattern(articleContainer.patternInput.value);


		/* awe 10-05-2010, changed to fit basis|pro|dikke context */
		var patternsMatched = null;
		if(document.body.id === BASIS) {
			patternsMatched = Dom.getElementsByClassName('z1k','span',articleContainer.article);// g1o
		} else if(document.body.id === PRO) {
			patternsMatched = Dom.getElementsByClassName('gp','span',articleContainer.article);// g1o
		} else if(document.body.id === DIKKE) {
			patternsMatched = Dom.getElementsByClassName('wz','span',articleContainer.article);// g1o
		} else if(document.body.id === TAALHANDBOEK) {
			// IHO 20110816
			patternsMatched = Dom.getElementsByClassName('th','span',articleContainer.article);// g1o
		} 
		/* end awe 10-05-2010, changed to fit basis|pro|dikke context */

		if (patternsMatched.length > 0) {
			patternsMatched[0].scrollIntoView(true);
			articleContainer.patternCount.innerHTML = patternsMatched.length + (patternsMatched.length > 1 ? ' resultaten':' resultaat') + ' gevonden.';
		} else {
			//20110913 IHO aangepaste tekst voor taalhandboek
			if(document.body.id === TAALHANDBOEK) {
				articleContainer.patternCount.innerHTML = 'Geen resultaten gevonden binnen deze paragraaf.';  
			} else {
				articleContainer.patternCount.innerHTML = 'Geen resultaten gevonden.';  
			}
		}   
	}   
	this.resolveLemmaLink = function(title,link, e) {       
		var properLink = false;

		if(link.indexOf('q=_') != -1) { // pro/basis/taalhulp cross article link
			Event.preventDefault(e);
			// possible links are
			// http://goto/?q=__gxxpattern, where we match _gxxpattern and take xx (lang, e.g. nf) and pattern
			// http://goto/?q=_gxx0000_gxxpattern, where we match _gxxpattern and take xx (lang, e.g. nf) and pattern
			var rePro = new RegExp(/_g([fends][fends])([^_]+)$/); 
			// http://goto/?q=__ezxxpattern, where we match _ezxxpattern and take xx (lang, e.g. nf) and pattern
			var reBasis = new RegExp(/_ez([fendiszp][fendiszp])(.+)$/); /* awe 10-05-2010 added iszp */
			// http://glossary/?q=_thxpattern_thxpattern, where we match thxpattern and take x (lang. e.g. e --> ee or n --> nn) and pattern
			var reThxGlossary = new RegExp(/glossary...._th([en])(.+)_th.+$/); 
			// http://goto/?q=_thxpattern_thxpattern, where we match thxpattern and take x (lang. e.g. e --> ee or n --> nn) and pattern
			var reThxGoto = new RegExp(/goto...._th([en])(.+)_th.+$/); 
			// special dictionaries
			var reOde = new RegExp(/_ode.*$/);
			var reOte = new RegExp(/_ote.*$/);
			var reGwn = new RegExp(/_gwn.*$/);

			var specialDicType = false;
			var specialDicName = "";
			var specialPattern = "";
			var glossaryType = false;

			// try to match pro
			var match = link.match(rePro); // try matching pro
			// assume dictType is pro unless proven otherwise later on
			var dictType = DICTTYPE_PRO;

			// try to match basis
			if (match == null) {
				match = link.match(reBasis);
				if(match) {
					dictType = DICTTYPE_BASIS;
				}
			}

			// try to match taalhandboek glossary
			if (match == null) {
				match = link.match(reThxGlossary);
				if(match) {
					dictType = DICTTYPE_TAALHANDBOEK;
					glossaryType = true;
				}
			}

			// try to match taalhandboek goto
			if (match == null) {
				match = link.match(reThxGoto);
				if(match) {
					dictType = DICTTYPE_TAALHANDBOEK;
				}
			}

			// these are all special dictionaries for pro
			if (match == null) {  
				match = link.match(reOde);
				if(match) {
					specialDicType = true;
					specialDicName = DICTTYPE_OXFORD_DICT;
					specialPattern = match[0];
				}
			}

			if (match == null) {  
				match = link.match(reOte);
				if(match) {
					specialDicType = true;
					specialDicName = DICTTYPE_OXFORD_TH;
					specialPattern = match[0];
				}
			}

			if (match == null) {  
				match = link.match(reGwn);
				if(match) {
					specialDicType = true;
					specialDicName = DICTTYPE_DIKKE;
					specialPattern = match[0];
				}
			}


			/* // awe 10-05-2010 added _ode, _ote, _gwn */
			if (match != null) { 
				if(specialDicType) {
					var dict = specialDicName; // xx
					var pattern = specialPattern.split("&")[0]; // strip any 2nd param from the pattern, this causes an error
					dictType = DICTTYPE_PRO;
				} else {
					var dict = match[1]; // xx
					// var pattern = match[2];
					var pattern = link.substring(link.indexOf('q=_') + 2);
				}

				// var pattern = match[2]; //pattern
				if (!YAHOO.env.ua.ie) {
					pattern = Utf8.decode(unescape(pattern));
				}
				if (dictType == DICTTYPE_TAALHANDBOEK) {
					// 20110906 IHO links in taalhandboek
					dict += dict;
					if (glossaryType) {
						this.fetchGlossaryArticle(pattern, dict, dictType, false);
					} else {
						// first remove current selection
						if (am.currentWord) {
							Dom.removeClass(am.currentWord, "selectedWord");
						}
						// then set current word to new article 
						var selected = 0;
						for (var i=0; i<wordLists[INHOUDSOPGAVE_LIST].dataSource.results.length; i++) {
							if (wordLists[INHOUDSOPGAVE_LIST].dataSource.results[i].headwordDisplay.indexOf(title) >= 0) {
								selected = i;
								break;
							}
						}
						am.currentWord = wordLists[INHOUDSOPGAVE_LIST].dataTable.selectRow(selected);
						currentSelection.tableId = "";
						pattern = pattern.substring(0, pattern.indexOf('_th', 4));
						// finally fetch article
						this.fetchArticle(pattern, -1, dict, dictType, POSITION, false, null, false);
					}
				}
				else {
					this.fetchArticle(pattern, -1, dict,dictType, POSITION, false, null, false);
				}
				properLink = true;
			}
		} else if (link.indexOf('lang=') != -1 && link.indexOf('url=') != 1) { // pro
			// extra kader old style - e.g. http://tabvw/?lang=N&url=Kaderteksten/dier.htm
			Event.preventDefault(e);
			var url = link.substring(link.indexOf('url=')+4);
			var lang = link.substring(link.indexOf('lang=')+5,link.indexOf('lang=')+6).toUpperCase();
			YAHOO.vandale.showDialog(title, "/extra/pro/extra"+lang+"/"+url);
			properLink = true;
		} else if (link.indexOf('get?') != -1) { // basis or pro extra kader
			/*
			 * basis e.g. http://kader/get?NN_Dieren1.png,NN_Dieren2.png or http://kader/get?NN_Dieren1.png basis is mapped to /extra/basis/kader/ez[lang1,lang2]/png/[image_name], e.g.
			 * http://kader/get?NN_Dieren1.png -> /extra/basis/kader/eznn/png/NN_Dieren1.png
			 * 
			 * pro e.g. http://kader/get?gfn3FNCuissonPraktijk.png
			 */
			Event.preventDefault(e);
			var data = link.substring(link.indexOf('get?') + 4); // get substring after http://kader/get?
			var params='';

			if (currentDictType == PRO) {
				/*
				 * [Vdl] URL has changed since latest datasets: no moniker in url for pro either.
				 * 
				 * var moniker = data.substring(0,4); //get moniker e.g. gfn3
				 * params += 'moniker='+moniker; var pngs =
				 * data.substring(4).split(","); //get pngs and split them (if
				 * more than one), we assume NN_Dieren1.png,NN_Dieren2.png
				 * pattern (without moniker)
				 * 
				 * We take the "basis" method and derive the lang variable from
				 * the png filename:
				 */
				var pngs = data.split(","); // split NN_Dieren1.png,NN_Dieren2.png
				params += 'moniker=g'+data.substring(0,2).toLowerCase()+'3'; 
				for (var i = 0; i < pngs.length; i++) {
					params += '&src=' + pngs[i];
				}

			} else { 
				var lang = getDictSelection().split(';')[0]; // there's only one dict selected in basis (strip ;)
				var pngs = data.split(","); // split NN_Dieren1.png,NN_Dieren2.png
				params += 'moniker='+'ez'+lang; 
				for (var i = 0; i < pngs.length; i++) {
					params += '&src=' + pngs[i];
				}

			}
			params += '&type=' + currentDictType;
			YAHOO.vandale.showDialog(title, "/vandale/template/v0/zoekservice/kader.jsp?"+params);
			properLink = true;
		}
		return properLink;
	}
	this.resolveGlossaryLink = function(title,link, e) {       
		Event.preventDefault(e);
		var reThxGlossary = new RegExp(/glossary...._th([en])(.+)_th.+$/); 
		var match = link.match(reThxGlossary);
		var dict = match[1] + match[1]; // xx
		var pattern = link.substring(link.indexOf('q=_') + 2);
		this.fetchGlossaryArticle(pattern, dict, DICTTYPE_TAALHANDBOEK, true);
		return true;
	}
	this.clearLoaded = function() {
		this.loaded = [-1,-1,-1];
	}
	this.setLoaded = function(caller, resultNo) {
		this.loaded[caller.parentId] = resultNo;
	}
	this.resolveArticleLoad = function() {
		var listId = -1;
		var rowId = -1;

		if (currentDictType == TAALHANDBOEK) {
			if (this.loaded[INDEX_LIST] != -1) { // INDEX_LIST loaded
				if (this.loaded[INDEX_LIST] > 0) {// INDEX_LIST has results
					listId = INDEX_LIST;
					rowId  = wordLists[INDEX_LIST].dataTable._oDataSource.pageData.hit >= 0 ? wordLists[INDEX_LIST].dataTable._oDataSource.pageData.hit : 0;
					clearInterval(fetchArticleTimer);
				} else if (this.loaded[IN_ARTICLES_LIST] != -1) { // IN_ARTICLES_LIST loaded
					if (this.loaded[IN_ARTICLES_LIST] > 0) {      // IN_ARTICLES_LIST has results
						listId = IN_ARTICLES_LIST;
						rowId  = wordLists[IN_ARTICLES_LIST].dataTable._oDataSource.pageData.hit;
						clearInterval(fetchArticleTimer);
					} else if (this.loaded[INHOUDSOPGAVE_LIST] != -1) { // INHOUDSOPGAVE_LIST loaded
						if (this.loaded[INHOUDSOPGAVE_LIST] > 0) {      // INHOUDSOPGAVE_LIST has results
							listId = INHOUDSOPGAVE_LIST;
							rowId  = 0;     
							clearInterval(fetchArticleTimer);
						}
					}
				}
			}
		}
		else {
			if (this.loaded[EXACT_LIST] != -1) { // EXACT_LIST loaded
				if (this.loaded[EXACT_LIST] > 0) {// EXACT_LIST has results
					listId = EXACT_LIST;
					rowId  = wordLists[EXACT_LIST].dataTable._oDataSource.pageData.hit >= 0 ? wordLists[EXACT_LIST].dataTable._oDataSource.pageData.hit : 0;
					clearInterval(fetchArticleTimer);
				} else if (this.loaded[ALPHABETIC_LIST] != -1) { // ALPHABETIC_LIST loaded
					if (this.loaded[ALPHABETIC_LIST] > 0) {      // ALPHABETIC_LIST has results
						listId = ALPHABETIC_LIST;
						rowId  = wordLists[ALPHABETIC_LIST].dataTable._oDataSource.pageData.hit;
						clearInterval(fetchArticleTimer);
					} else if (this.loaded[IN_ARTICLES_LIST] != -1) { // IN_ARTICLES_LIST loaded
						if (this.loaded[IN_ARTICLES_LIST] > 0) {      // IN_ARTICLES_LIST has results
							listId = IN_ARTICLES_LIST;
							rowId  = 0;     
							clearInterval(fetchArticleTimer);
						}
					}
				}
			}
		}

		// load article
		if (listId > -1 && rowId > -1) {
			currentSelection = {tableId:wordLists[listId].dataTable._elTable.id, index:rowId};
			am.currentWord = wordLists[listId].dataTable.selectRow(rowId);
			this.clearLoaded();
			this.fetchArticleForDataTable(wordLists[listId].dataTable);
		}
	}
}
/**
*
*  UTF-8 data encode / decode
*  http://www.webtoolkit.info/
*
**/
var Utf8 = {
		// public method for url encoding
		encode : function (string) {
			string = string.replace(/\r\n/g,"\n");
			var utftext = "";

			for (var n = 0; n < string.length; n++) {

				var c = string.charCodeAt(n);

				if (c < 128) {
					utftext += String.fromCharCode(c);
				}
				else if((c > 127) && (c < 2048)) {
					utftext += String.fromCharCode((c >> 6) | 192);
					utftext += String.fromCharCode((c & 63) | 128);
				}
				else {
					utftext += String.fromCharCode((c >> 12) | 224);
					utftext += String.fromCharCode(((c >> 6) & 63) | 128);
					utftext += String.fromCharCode((c & 63) | 128);
				}

			}

			return utftext;
		},

		// public method for url decoding
		decode : function (utftext) {
			var string = "";
			var i = 0;
			var c = c1 = c2 = 0;

			while ( i < utftext.length ) {
				c = utftext.charCodeAt(i);
				if (c < 128) {
					string += String.fromCharCode(c);
					i++;
				}
				else if((c > 191) && (c < 224)) {
					c2 = utftext.charCodeAt(i+1);
					string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
					i += 2;
				}
				else {
					c2 = utftext.charCodeAt(i+1);
					c3 = utftext.charCodeAt(i+2);
					string += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
					i += 3;
				}
			}
			return string;
		}
}

function CheckboxGroupManager(form, checkboxIdPrefix, allSwitchId, allSwitchTexts) {
	var checkboxes = [];

	var elems = $(form).getElementsByTagName('input');
	for (var i = 0; i < elems.length; i++) {
		if (elems[i].id.substring(0,checkboxIdPrefix.length) == checkboxIdPrefix) {
			checkboxes[i] = elems[i];
		}
	}

	var allSwitch = $(allSwitchId);
	var switchTexts = allSwitchTexts;
	allSwitch.innerHTML = switchTexts['on'];

	var allLangsSelected = function() { 
		var allSelected = true;
		var atLeastOne = false;
		var fldKeyword = $('fldKeyword');
		var nrSelected = 0;
		for (var i = 0; i < checkboxes.length; i++) {
			if (!checkboxes[i].checked) {
				allSelected = false;
				Dom.removeClass($('current_' + checkboxes[i].id),'usedLang');
			} else {
				Dom.addClass($('current_' + checkboxes[i].id),'usedLang');
				atLeastOne = true;
			    nrSelected++;
			}
		}   
		if (atLeastOne) {
			Dom.removeClass($('current_lang_none'),'usedLang');
			if(!Dom.hasClass($('extraOptions'),"show")) {
				fldKeyword.removeAttribute("disabled");
				Dom.removeClass(fldKeyword,"disabled");
			}
		} else {
			Dom.addClass($('current_lang_none'),'usedLang');
			fldKeyword.setAttribute("disabled", "disabled");
			Dom.addClass(fldKeyword,"disabled");
		}
		if (nrSelected > 9) {
			Dom.addClass($('current_lang_none').parentNode, "extraHeight");
		} else {
			Dom.removeClass($('current_lang_none').parentNode, "extraHeight");
		}
		return allSelected; 
	}
	var switchAllLangs = function(doSelect) {
		for (var i = 0; i < checkboxes.length; i++) {
			// 20111026 IHO only select available checkboxes
			if (!checkboxes[i].disabled) {
				checkboxes[i].checked = doSelect;
			}
		}
		allLangsSelected();     
	}
	/* public event handlers */
	this.switchAll = function(e) {
		var src = e.target ? e.target : e.srcElement;
		src.blur();
		Event.preventDefault(e);
		if(src.innerHTML == switchTexts['on']) {
			switchAllLangs(true);
			src.innerHTML = switchTexts['off'];
		} else {
			switchAllLangs(false);
			src.innerHTML = switchTexts['on'];      
		}   
	}
	this.updateAll = function() {
		if (allLangsSelected()) {
			allSwitch.innerHTML = switchTexts['off'];
		} else {
			allSwitch.innerHTML = switchTexts['on'];
		}
	}
}

var Cookies = {
		init: function () {
			var allCookies = document.cookie.split('; ');
			for (var i=0;i<allCookies.length;i++) {
				var cookiePair = allCookies[i].split('=');
				this[cookiePair[0]] = cookiePair[1];
			}

			if (!this['pro_langs']) {
				this.create('pro_langs', PRO_LANGS, 100);
			}

			if (!this['basis_langs']) {
				this.create('basis_langs', BASIS_LANGS, 100);
			}       

			// 20110823 IHO add taalhandboek languages
			if (!this['thb_langs']) {
				this.create('thb_langs', TAALHANDBOEK_LANGS, 100);
			}       
		},
		create: function (name,value,days) {
			if (days) {
				var date = new Date();
				date.setTime(date.getTime()+(days*24*60*60*1000));
				var expires = "; expires="+date.toGMTString();
			}
			else var expires = "";
			document.cookie = name+"="+value+expires+"; path=/";
			this[name] = value;
		},
		erase: function (name) {
			this.create(name,'',-1);
			this[name] = undefined;
		}
};

function readLangSettings() {   
	var langVar = currentDictType+"_langs";
	var langsInCookie = Cookies[currentDictType+"_langs"];
	if (langsInCookie != null) {
		var langs = langsInCookie.split(',');
		for (var i=0; i < langs.length; i++) {
			if ((langs[i] != '') && $("lang_"+langs[i]) && !($("lang_"+langs[i]).disabled)) {
				$("lang_"+langs[i]).checked = "checked";
			}
		}
	}
	if (currentDictType == PRO) {
		lm.updateAll();
	} else if (currentDictType == BASIS || currentDictType == TAALHANDBOEK) {	// IHO 20110822 add taalhandboek
		updateSelection();
	}
}

function determineListsHeight() {
	var windowHeight;

	if (typeof window.innerWidth != 'undefined')
	{
		windowHeight = window.innerHeight;
	}
	// IE6 in standards compliant mode (i.e. with a valid doctype as the first 
	// line in the document)
	else if (typeof document.documentElement != 'undefined'
			&& typeof document.documentElement.clientWidth != 'undefined' 
			&& document.documentElement.clientWidth != 0)
	{
		windowHeight = document.documentElement.clientHeight;
	}
	// older versions of IE
	else
	{
		windowHeight = document.getElementsByTagName('body')[0].clientHeight;
	}
	
	var h1 = document.getElementById('indexList_toggle').scrollHeight;
	var h2 = document.getElementById('inArticlesList_toggle').scrollHeight;
	if (windowHeight < h1+h2+363+85) {
		document.getElementById('inhoudsopgaveList').style.height = "85px";
	} else {
		document.getElementById('inhoudsopgaveList').style.height = (windowHeight - h1 - h2 - 363) + "px";
	}
}


/**********EVENTS*******/
/* attach event to form submit boolean search */
booleanFormSubmitted = function(e) {
	Event.stopEvent(e);
	doFinalSearch();
}
function setFocus(obj) {
	obj.focus();
}
/* attach event to search within article */
initSearchInArticle = function() {
	var inputEl = $("fldSearchLemma");
	Event.addListener(inputEl,"keyup",am.highlightPattern);
}
/* attach event to form submit search */
formSubmitted = function(e) {
	Event.preventDefault(e);
	doFinalSearch();
}
doFinalSearch = function() {
	submitMutex = true;
	updateResults($("fldKeyword").value, isJokerSearch($("fldKeyword").value), isBooleanSearch($("fldKeyword").value));
	clearTimeout(mutexOffTimeout);
	mutexOffTimeout = setTimeout("submitMutex=false",500);
}
isJokerSearch = function(pattern) {
	return (pattern.indexOf('*') != -1 || pattern.indexOf('?') != -1);
}
isBooleanSearch = function(pattern) {
	return (pattern.indexOf('|') != -1 || pattern.indexOf('+') != -1);
}
initSearchSubmit = function() {
	Event.addListener($("frmSearch"),"submit",formSubmitted);
}

/* attach event to prev / next buttons */
initPrevNext = function() {
	alert('initPrevNext is being used!');
	wordLists.getPrevPage();
	wordLists.getNextPage();
}
/* attach event to the lemma container */
initLemmaLinks = function() {
	Event.addListener($('lemmaContent'), "click", clickLemma);
	// 20110905 IHO volgende vorige knoppen in artikelnavigatie
	Event.addListener($('lemma_prev'), "click", prevLemma, am);
	Event.addListener($('lemma_next'), "click", nextLemma, am);
}
function prevLemma(e, am) {
	navigateLemma(e, am, false);
}
function nextLemma(e, am) {
	navigateLemma(e, am, true);
}
function navigateLemma(e, am, next) {
	// only navigate if possible (i.e. not going back on first or forward on last article)
	var src = e.target ? e.target : e.srcElement;
	if (src.className.indexOf('active') >= 0 ) {
		// find out currently shown article
		rowId = am.getCurrentArticle();
		if (am.currentWord) {
			Dom.removeClass(am.currentWord, "selectedWord");
		}
		if (next) {
			rowId++;
			am.currentWord = am.currentWord.nextSibling;
		} else  {
			rowId--;
			am.currentWord = am.currentWord.previousSibling;
		}

		// just in case window is resized, determine new height for inhoudsopgavelist
		determineListsHeight();

		am.currentWord = wordLists[INHOUDSOPGAVE_LIST].dataTable.selectRow(rowId);
		am.currentWord.scrollIntoView( true );
		if (navigator.appVersion.indexOf("MSIE 8.0") > 0) {
			// TODO user alternative scrollIntoView method
		}
		var posid = (INDEXPREFIX + rowId/1000).replace('.','');
		am.fetchNextArticle(wordLists[INHOUDSOPGAVE_LIST].dataTable, rowId, posid);
	}
}

function clickLemma(e) {        
	var src = e.target ? e.target : e.srcElement;
	try {
		if (src.href == null) { //workaround for a <a><span/></a>
			src = src.parentNode;
		}
		if (src.href.indexOf("javascript:") == -1) {
			am.resolveLemmaLink(src.innerHTML, src.href, e);
		}
	} catch(e) {
		//not a link
	}
}
function clickGlossary(e, am) {        
	var src = e.target ? e.target : e.srcElement;
	try {
		if (src.href == null) { //workaround for a <a><span/></a>
			src = src.parentNode;
		}
		if (src.href.indexOf("javascript:") == -1) {
			am.resolveGlossaryLink(src.innerHTML, src.href, e);
		}
	} catch(e) {
		//not a link
	}
}
/* attach event(s) to language multiple selection */
function updateSelection(e) {
	var elems = $('bookSelection').getElementsByTagName('input');
	for (var i = 0; i < elems.length; i++) {
		if (elems[i].id.substring(0,4) == 'lang') {
			if (elems[i].checked) {     
				Dom.addClass($('current_' + elems[i].id),'usedLang');
				YAHOO.vandale.softKeyboard.resolve(elems[i].id.substring(5));   
			} else {
				Dom.removeClass($('current_' + elems[i].id),'usedLang');    
			}
		}
	}
}
initLangSelection = function(isRadio) {
	var bookSelDiv = $('bookSelection');
	if (bookSelDiv) {
		if (!isRadio) {
			Event.addListener($('all_langs_switch'),"click",lm.switchAll);
		}
		var elems = bookSelDiv.getElementsByTagName('input');
		for (var i = 0; i < elems.length; i++) {
			if (elems[i].id.substring(0,4) == 'lang') {
				Event.addListener(elems[i],"click",isRadio ?  updateSelection : lm.updateAll);      
			}
		}
	}
}
/* attach event(s) to 'search in article' button */
initSearchInArticleForm = function() {
	Event.addListener($('btn_searchInArticle'), "click", am.searchInArticle);
	Event.addListener($('searchInLemmaObj'), "submit", am.searchInArticle); 
}
/* init all events */
initAllEvents = function() {
	initSearchSubmit();
	initLemmaLinks();
	//initSearchInArticle();
	initSearchInArticleForm();
	initLangSelection((currentDictType == BASIS) || (currentDictType == DIKKE) || (currentDictType == TAALHANDBOEK));
}

function popup(e, props) {
	YAHOO.util.Event.preventDefault(e);
	props = props || {};
	var origin = window;
	var windowName = props["name"] || "vandale";
	var windowWidth = props["width"] || 600;
	var windowHeight = props["height"] || 400;
	var windowResizable = props["resizable"] || 0;
	var windowScrollbars = props["scrollbars"] || 0;
	var centerWidth = ((window.screen.width - windowWidth) / 2);
	var centerHeight = ((window.screen.height - windowHeight) / 2);

	var properties = "scrollbars=" + windowScrollbars + ",resizable=" + windowResizable + ", width=" + windowWidth + ",height=" + windowHeight + ",left=" + centerWidth + ",top=" + centerHeight;
	var newWindow = origin.open(this.href, windowName, properties);
	newWindow.focus();
	return;
}
function initPopUpLinks() {
	var popupLinks = YAHOO.util.Dom.getElementsByClassName("popup", "a");
	for (var i = 0; i < popupLinks.length; i++) {
		YAHOO.util.Event.on(popupLinks[i], "click", popup, {width: 600, height: 400, scrollbars: 1, resizable: 1 });
	}
}
function initPopUp() {
	var body = YAHOO.util.Dom.getElementsByClassName("popup", "body");
	if (body[0]) {
		var closers = YAHOO.util.Dom.getElementsByClassName("close", "a", body[0]);

		for (var i = 0; i < closers.length; i++) {
			YAHOO.util.Event.on(closers[i], "click", function(e) { YAHOO.util.Event.preventDefault(e); window.close() } );
		}
	}
}

YAHOO.vandale.softKeyboard = {
		init : function() {
			var softKeys = YAHOO.util.Dom.getElementsByClassName("softKey", "a");
			for (var i = 0; i < softKeys.length; i++) {     
				YAHOO.util.Event.on(softKeys[i], "click", function(e) { YAHOO.util.Event.preventDefault(e); YAHOO.vandale.softKeyboard.onKeyPress(this) } );
			}   
		},
		currentKeyboard : null,
		resolve : function(book) {  
			if (this.currentKeyboard) {                         
				this.hide(this.currentKeyboard.charAt(0));
				this.hide(this.currentKeyboard.charAt(1));
			}
			this.show(book.charAt(0));
			//this.show(book.charAt(1)); // fix for vandale
			this.currentKeyboard = book;
		},
		show : function(lang) {
			Dom.addClass(lang+"_softKeyboard", "visible");

		},
		hide : function(lang) {
			Dom.removeClass(lang+"_softKeyboard", "visible");
		},
		onKeyPress : function(softKey) {
			Dom.get('fldKeyword').value += softKey.rel;
		}
}

YAHOO.vandale.formLanguage = {
		settings : {
			rawXML          : null,
			dictType        : "",
			langSettingsUrl : ""
		},
		dataPro:null,
		dataBasis:null,
		dataTaalhandboek:null,
		init : function(dictType,langUrl) {
			this.settings.dictType = dictType;
			this.settings.langSettingsUrl = langUrl;
			// load data
			this.loadLanguage();
		},
		getDictSet : function(setName) {
			return Dom.getElementsBy(function(e){return e.parentNode.getAttribute("name") == setName;}, "dict",this.settings.rawXML);
		},
		enableInputs : function(dataSet) {
			for(var i=0; i<dataSet.length; i++) {
				var currentLang =  dataSet[i].getAttribute("lang");
				var domTarget = Dom.get("lang_" + currentLang);
				if(domTarget) {
					domTarget.removeAttribute("disabled");
					// for taalhandboek make sure buttons are disabled
					if (currentDictType == TAALHANDBOEK && currentLang == "nn") {
						btn = Dom.get('btnDutch');
						Dom.removeClass(btn, "disabled");
					}
					else if (currentDictType == TAALHANDBOEK && currentLang == "ee") {
						btn = Dom.get('btnEnglish');
						Dom.removeClass(btn, "disabled");
					}
				} else {
					// DOM not consistent with language
				}
			}
		},
		initExtras : function(dataSet) {
			for(var i=0; i<dataSet.length; i++) {
				var currentLang =  dataSet[i].getAttribute("lang");
				var targetLang = null;
				switch(currentLang) {
				case 'nn': targetLang = 'n'; break;
				case 'ee':
				case 'en':
				case 'ne': targetLang = 'e'; break;
				case 'dn':
				case 'nd': targetLang = 'd'; break;
				case 'fn':
				case 'nf': targetLang = 'f'; break;                              
				case 'sn':
				case 'ns': targetLang = 's'; break;
				case 'in':
				case 'ni': targetLang = 'i'; break;
				case 'pn':
				case 'np': targetLang = 'p'; break;
				case 'zn':
				case 'nz': targetLang = 'z'; break;
				default: targetLang = currentLang;
				}

				if (targetLang) {
					Dom.addClass('extra-'+targetLang,'visible');
				}
			}
		},
		loadLanguage : function() {
			var callback =  {   
					success: function(o) {
						var fl = o.argument.formLanguage;
						fl.settings.rawXML = o.responseXML;
						fl.dataBasis = fl.getDictSet(BASIS);
						fl.dataPro = fl.getDictSet(PROFESSIONAL);
						fl.dataDikke = fl.getDictSet(DIKKE);
						fl.dataTaalhandboek = fl.getDictSet(TAALHANDBOEK);
						// 20111018 IHO instead of switching off not used tabs it's now reversed: only show used tabs
						if (fl.dataBasis.length > 0) {
							Dom.removeClass($('basisTab'), 'inactiveTab');
						}
						if (fl.dataPro.length > 0) {
							Dom.removeClass($('proTab'), 'inactiveTab');
						}   
						if (fl.dataDikke.length > 0) {
							Dom.removeClass($('dikkeTab'), 'inactiveTab');
						}
						if (fl.dataTaalhandboek.length > 0) {
							Dom.removeClass($('taalhandboekTab'), 'inactiveTab');
						}
						//switch off not used tabs
//						if (fl.dataBasis.length == 0) {
//							Dom.addClass($('basisTab'), 'inactiveTab');
//						}
//						if (fl.dataPro.length == 0) {
//							Dom.addClass($('proTab'), 'inactiveTab');
//						}   
//						if (fl.dataDikke.length == 0) {
//							Dom.addClass($('dikkeTab'), 'inactiveTab');
//						}
//						if (fl.dataTaalhandboek.length == 0) {
//							Dom.addClass($('taalhandboekTab'), 'inactiveTab');
//						}

						if(fl.settings.dictType == BASIS) {
							fl.enableInputs(fl.dataBasis);
							fl.initExtras(fl.dataBasis);
						} else if(fl.settings.dictType == PRO) {
							fl.enableInputs(fl.dataPro);
							fl.initExtras(fl.dataPro);
						} else if(fl.settings.dictType == DIKKE) {
							fl.enableInputs(fl.dataDikke);
							fl.initExtras(fl.dataDikke);
						} else if(fl.settings.dictType == TAALHANDBOEK) {
							fl.enableInputs(fl.dataTaalhandboek);
							fl.initExtras(fl.dataTaalhandboek);
						}
						//CALL further init
						servicesInit();
					},

					failure: function(o) { 
						handleCommunicationException(o);
					}, 

					argument : {formLanguage: this}
			}   
			var transaction = YAHOO.util.Connect.asyncRequest('GET', this.settings.langSettingsUrl, callback, null);  

		}
}

var handleCommunicationSuccess = function(res) {

}
var handleCommunicationException = function(res) {
	var re401 = new RegExp(/^Authentication failed/i);
	var re403 = new RegExp(/^Authorization failed/i);
	var isAborted = false;
	var status = res.status ? res.status : res[0].status;   
	switch (status) {
	case -1  : isAborted = true; break;
	case 401 : 
		if(res.responseText != null || res[0].responseText != null) {
			var warn = (res.responseText != null) ? res.responseText : res[0].responseText;
			if (warn.match(re401)) {
				Dom.addClass($('error401'), 'visible'); break; // authentication problem
				break;
			} else if (warn.match(re403)) {
				Dom.addClass($('error403'), 'visible'); break; // authorization problem
				break;
			} 
		}          
	default: 
		Dom.addClass($('errorDefault'), 'visible');         
	break;
	}
	if (!isAborted) { // -1 - transaction aborted
		Dom.addClass($('zoekserviceErrorContent'), 'visible');
		Dom.addClass($('zoekserviceErrorHeader'), 'visible');       
	}
}
// 
var initFormLanguage = function(requiredLangs) {
	if(Dom.get("langSettingsBasic")) {
		YAHOO.vandale.formLanguage.init(BASIS, ENGINE_SERVER+"/ndc-vzs/search/getAvailableDictionaries.vdw?required="+requiredLangs);
	} else if(Dom.get("langSettingsPro")) {
		YAHOO.vandale.formLanguage.init(PRO, ENGINE_SERVER+"/ndc-vzs/search/getAvailableDictionaries.vdw?required="+requiredLangs);
	} else if(Dom.get("langSettingsTh")) {
		YAHOO.vandale.formLanguage.init(TAALHANDBOEK, ENGINE_SERVER+"/ndc-vzs/search/getAvailableDictionaries.vdw?required="+requiredLangs);
	} else {
		YAHOO.vandale.formLanguage.init(DIKKE, ENGINE_SERVER+"/ndc-vzs/search/getAvailableDictionaries.vdw?required="+requiredLangs);
		return false;
	}
}

YAHOO.vandale.extrasHandler = {
		init : function() {
			var extrasMenu = $("extrasSelection");
			if(extrasMenu){
				var extraLinks = extrasMenu.getElementsByTagName("A"); 
				if(extraLinks.length > 0) {
					for(var i=0; i<extraLinks.length; i++) {
						// IHO make sure oxford links are not handled by the showdialog handler
						if (extraLinks[i].parentNode.id && extraLinks[i].parentNode.id.indexOf("extra") == 0 && extraLinks[i].parentNode.id.length <= 7) { 
							Event.on(extraLinks[i],"click",this.handle,extraLinks[i]);
						}
					}
				}
			}
		},
		handle : function(e,obj) {
			YAHOO.vandale.showDialog(e, {url:obj.rel, title:obj.title});

		}
}


//++++++++++++++++++++++++++++++++++++
// INIT
// 12/4/2007 - Edwart Visser
//
// load init scripts
//
// REQUIRES: yahoo-dom-event.js
//
//++++++++++++++++++++++++++++++++++++
var servicesInit = function() {
	Cookies.init(); 
	YAHOO.vandale.toggle.init();
	YAHOO.vandale.booleanSearch.init();
	//YAHOO.vandale.helpDialogues.init();
	YAHOO.vandale.printLemma.init();
	// 20111107 IHO events give problems in IE7 (blank screen) and does not add anything for other current browsers, so removed
	//YAHOO.vandale.hover.init();
	YAHOO.vandale.fontResize.init();
	//YAHOO.util.Connect.setDefaultPostHeader("");
	//YAHOO.util.Connect.initHeader("Content-Type","application/x-www-form-urlencoded; charset=UTF-8",true);

	//Basis and Pro
	dictTypes = {basis: DICTTYPE_BASIS, pro: DICTTYPE_PRO, dikke: DICTTYPE_PRO, thb: DICTTYPE_TAALHANDBOEK};

	var switchTexts = [];
	switchTexts['on'] = "Alles selecteren";
	switchTexts['off'] = "Alles deselecteren";  
	if (currentDictType == PRO) {
		lm = new CheckboxGroupManager('bookSelection','lang', 'all_langs_switch', switchTexts);
		lm.updateAll();
	}
	readLangSettings(); 
	//fast typing problem
	submitMutex = false; 
	mutexOffTimeout = null;

	initAutoCompleteBox("fldKeyword", "resultsContainer");
	am = new ArticleManager($('headword'),$('lemmaContent'),$('patternMatchCount'),$('fldSearchLemma'),$('article_loading'));

	wordLists = initWordLists(am);
	
	if(typeof(gxx) == 'undefined' )return;
	
	
	gxx._i = $('lemmaContent');
	if (currentDictType == TAALHANDBOEK) {
		var disableBtn; //button to disable
		var enableBtn; //button to disable
		var chk; //radio input to enable
		var txt;
		if (getDictSelection() == 'nn;') {
			disableBtn = Dom.get('btnEnglish');
			enableBtn = Dom.get('btnDutch');
			chk = Dom.get('lang_nn');
			txt = 'Taalhandboek Nederlands';
		} else {
			disableBtn = Dom.get('btnDutch');
			enableBtn = Dom.get('btnEnglish');
			chk = Dom.get('lang_ee');
			txt = 'Taalhandboek Engels';
		}
		Dom.get('lblDictionary').innerHTML = txt;
		Dom.removeClass(disableBtn,"selected");
		Dom.addClass(enableBtn,"selected");
		chk.checked = true;
		
		// 20110901 IHO load inhoudsopgave and first article for taalhandboeken on pageload
		wordLists[INHOUDSOPGAVE_LIST].loadInhoudsopgave(getDictSelection(), getDictType()); 
		document.getElementById('inhoudsopgaveList').style.height = (document.documentElement.clientHeight - 405) + "px";
	}

	currentSelection = {tableId:'yui-dt0-table', index:0};
	initAllEvents();
	initPopUp();
	initPopUpLinks();   
	setFocus($('fldKeyword'));
}

/* searchHistory*/
searchHistory = {
		init : function() {
			this.historyLink = document.getElementById("historyButton");
			this.historyContainer = document.getElementById("searchHistoryContainer");

			if(!this.historyContainer)return;

			this.historyList = this.historyContainer.getElementsByTagName("ul")[0]; 
			this.historyItem = this.historyContainer.getElementsByTagName("li")[0];
			this.historyList.removeChild(this.historyContainer.getElementsByTagName("li")[0]);
			this.removeLink = document.getElementById("deleteHistory");
			this.historyArray = new Array();
			this.historyVisible = false;

			Dom.addClass(this.historyLink,"disabled");

			Event.addListener(this.historyLink,"click",searchHistory.showhide,this);
			Event.addListener(this.removeLink,"click",searchHistory.cleanHistory,this);
			Event.addListener(this.historyContainer,"mouseout",searchHistory.hideContainer,this);
		},
		hideContainer : function(e,obj){
			// mouse location detection needed because mouseout detection BUG
			var objL = Dom.getRegion(obj.historyContainer).left;
			var objR = Dom.getRegion(obj.historyContainer).right;
			var objT = Dom.getRegion(obj.historyContainer).top;
			var objB = Dom.getRegion(obj.historyContainer).bottom;

			var mouseX = Event.getXY(e)[0];
			var mouseY = Event.getXY(e)[1];

			if(mouseX > objL && mouseX < objR && mouseY > objT && mouseY < objB) {
				// inside element so don't hide
			} else {
				obj.hide(obj);
			}
		},
		showhide : function(e,obj) {
			var liEls = obj.historyContainer.getElementsByTagName("li"); 
			if(liEls.length > 0) {
				if(obj.historyVisible == false) {
					searchHistory.show(obj);
				} else {
					searchHistory.hide(obj);
				}
			}
		},
		show : function(obj) {
			obj.historyVisible = true;
			Dom.setStyle(obj.historyContainer,"display","block"); // to support IE6
			//Dom.addClass(obj.historyContainer,"show");
		},
		hide : function(obj) {
			obj.historyVisible = false;
			Dom.setStyle(obj.historyContainer,"display","none"); // to support IE6
			//Dom.removeClass(obj.historyContainer,"show");
		},
		addItem : function(word) {
			this.historyArray.push(word);
			var newItem = this.historyItem.cloneNode(true);
			newItem.getElementsByTagName("a")[0].innerHTML = word;

			var passObj = { 
					word : word,
					obj : this
			}

			// check if items > 12 : set height of box to fixed height
			if(this.historyArray.length > 12) {
				Dom.addClass(this.historyList.parentNode,"fixedHeight");
			} else {
				Dom.removeClass(this.historyList.parentNode,"fixedHeight");
			}

			Event.addListener(newItem,"click",this.updateResult,passObj);
			this.historyList.insertBefore(newItem,this.historyList.firstChild);

			Dom.addClass(this.removeLink,"show"); 
			Dom.removeClass(this.historyLink,"disabled");
		},
		cleanHistory : function(e,obj){
			var listEl = obj.historyItem.cloneNode(true);
			obj.historyArray = new Array();
			obj.historyList.innerHTML = "";
			Dom.removeClass(obj.removeLink,"show");
			searchHistory.hide(obj);
			Dom.addClass(obj.historyLink,"disabled");

		},
		updateResult : function(e,passObj){
			passObj.obj.hide(passObj.obj);
			updateResults(passObj.word, isJokerSearch(passObj.word), isBooleanSearch(passObj.word));
		}
}

/* keep connection open */
keepConnection = function() {
	var sUrl = ENGINE_SERVER+"/ndc-vzs/search/searchExact.vdw?pattern=test&lang=nn;&dict=g&viewCount=1&rnd=" + (Math.random(3) * 1000);
	//var sUrl = ENGINE_SERVER+"/ndc-vzs/search/searchExact.vdw?pattern=test&lang=nn;&dict=g&viewCount=1";
	var handleSuccess = function(o){
		if(o.responseText !== undefined){
			// connection made successful
		}
	}

	var handleFailure = function(o){
		if(o.responseText !== undefined){
			// connection failed
		}
	}

	var callback =
	{
			success:handleSuccess,
			failure: handleFailure
	};

	var request = YAHOO.util.Connect.asyncRequest('GET', sUrl, callback); 
}

var logoLoad = {
		init : function() {
			if (top.frames.length == 0) return;

			var reClient = new RegExp(/^https?:\/\/([\w-]+)\.vandale\.nl\//);
			var match = reClient.exec(top.location.href);
			if ( match == null ) return;

			var clientName = match[1];
			var q = document.getElementById("clientLogoDiv");
			var imageElem = document.createElement("img");
			imageElem.src='/logo/'+clientName+'.gif';
			clientLogoDiv.appendChild(imageElem);
		}
}

var toggleAllLemmaDetails = function(e) {
	var state;

	if(!this.rel) {
		this.setAttribute("rel", "1");
		state = 0;
	} else {
		state = parseInt(this.rel,10);  
	}

	var Dom =  YAHOO.util.Dom;
	var detailElements = Dom.getElementsByClassName("wv", "span", "lemmaContent");
	var lemmaLinks = Dom.get("lemmaContent").getElementsByTagName("a");

	for(var i=0; i<detailElements.length; i++) {
		if(Dom.hasClass(detailElements[i].parentNode, "w0f")) {
			if(state === 1) {
				Dom.setStyle(detailElements[i], "display", "block");    
			} else {
				Dom.setStyle(detailElements[i], "display", "none");
			}
		}
	}

	for (var i=0; i<lemmaLinks.length; i++) {
		// 20121206 Bij in/uitklappen van alle items in een artikel moeten de pijltjes voor woordvormen en dubbelgangers niet mee-flippen als je op klap-in-klap-uit klikt
		if(lemmaLinks[i].id && !Dom.hasClass(lemmaLinks[i].parentNode, "w0g") && lemmaLinks[i].onfocus) {
			if(state === 1) {
				lemmaLinks[i].innerHTML = "▼";
			} else {
				lemmaLinks[i].innerHTML = "▶";
			}

		}
	}

	if (state === 1) {
		this.rel = 0;
	} else {
		this.rel = 1;
	}
};


//window.onresize = function() {
//	if (currentDictType == TAALHANDBOEK ) {
//		determineListsHeight();
//	}
//}


var pageInit = function() {
	currentDictType = document.body.id;
	// IHO 20110819 Add new dictionaries (and missing old ones!)
	initFormLanguage(DICTIONARIES);
	YAHOO.vandale.extrasHandler.init();
	searchHistory.init();
	logoLoad.init();
	YAHOO.vandale.softKeyboard.init();
	var connectionInterval = setInterval(keepConnection, 600000); // 10 minutes
	if(YAHOO.util.Dom.get("toggleLemmaBlocks") && toggleAllLemmaDetails) {
		YAHOO.util.Event.addListener("toggleLemmaBlocks", "click", toggleAllLemmaDetails);
	}
}

Event.addListener(window,"load",pageInit);