/*
 * updated 2004-05-19
 */
 
//return true or false
function isUserAgent() {
   return document.getElementById && (window.attachEvent || window.addEventListener);
}
//global function
function getNextSiblingByNodeName(element, nodeName) {
	do element = element.nextSibling;
	while (element && (element.nodeName.toLowerCase() != nodeName.toLowerCase()));
	return element;
} 

function getFirstChildByNodeName(element, nodeName) {
	element = element.firstChild;
	if (element && (element.nodeName.toLowerCase() != nodeName.toLowerCase())) 
		return getNextSiblingByNodeName(element, nodeName);
	else
		return element;
} 

function getParentNodeByName(element, nodeName) {
  if(!isUserAgent) return; //cut off
	do element = element.parentNode;
	while (element && (element.nodeName.toLowerCase() != nodeName.toLowerCase()));
	return element;
}

function getObj (x){
	obj = document.getElementById(x);
	return obj;
}
//swap all checkboxes by the element ID
function invertAllCheckbox(id) {
    var root = getObj(id);
  var boxes = root.getElementsByTagName("input");
  for(i=0; i<boxes.length; i++) {
    if(boxes[i].type.toLowerCase() == "checkbox") { 
      if(boxes[i].checked == true){
        boxes[i].checked = false;
      }//end: if - checked boxes
      else if(boxes[i].checked == false){
        boxes[i].checked = true;
      }//end: if - NONchecked boxes
    }
  }//end: for
  return false;
}

function resetAllCheckbox(id) {
    swapAllCheckbox(getCheckboxes(getObj(id)));
    return false;
}

function getCheckboxes(element)
{   
    var resultBoxes = [];
    var inputs = element.getElementsByTagName("input");
    for(i=0; i<inputs.length; i++) {
        if(inputs[i].type.toLowerCase() == "checkbox") { 
            resultBoxes.push(inputs[i])
        }
    }//end: for
    return resultBoxes;
}


//boxes: array
function swapAllCheckbox(boxes)
{
    var swapmode = true;
    for(i=0; i<boxes.length; i++) {
        if(boxes[i].checked == true){
            swapmode = false;
        }
    }//end: for
    for(i=0; i<boxes.length; i++) {
        boxes[i].checked = swapmode;
    }//end: for
    return false;            
}



function chnChk(element) {
 var row = this.getParentNodeByName(element, "tr")
 var chkBox = row.getElementsByTagName("input")[0];
 row.style.backgroundColor = "#DADBEA";
 chkBox.checked = "checked";
 return false;
} 

function setChangeStatusActions(id) {
  var root = getObj(id);
  var elements = root.getElementsByTagName("input");
  for(i=0; i<elements.length; i++) {
   if(elements[i].type.toLowerCase() != "checkbox")  continue;
   if(elements[i].type.toLowerCase() != "submit")  continue;
    elements[i].onblur = chnChk(this);
  }
}

function initTableRows(id, hoverColor) {
    var root = getObj(id);
    var rows = root.getElementsByTagName("tr");
    for (j=0; j<rows.length; j++){
    var row = rows[j];
        row.origBackgroundColor = row.style.backgroundColor;
        row.origBorder = row.style.border;
        row.onmouseover = function(){
            setCellsBackground(this, hoverColor)
        }
    }
}

function setCellsBackground(row, color){
    row.origCellBackg = [];
    var cells = row.getElementsByTagName("td");
    for (var j=0; j<cells.length; j++){
        row.origCellBackg.push(cells[j].style.backgroundColor)
        cells[j].style.backgroundColor = color;
    }
    row.onmouseout = function() {
        for (var j=0; j<cells.length; j++){
            cells[j].style.backgroundColor = this.origCellBackg[j];
        }
    }
}

//returns true || false
function isInArray(item, arr) {
    for(var x in arr) {
       if(item == arr[x])
       return true;
    }
    return false;
}  

function confirmAction(mode){
    var msg = [];
    msg["process"] = "Really mark this user as PROCESSED ?";
    msg["unprocess"] = "Really mark this user as UNPROCESSED ?";
    msg["del"] = "Wirklich löschen ?";
    if(!mode) mode = "del";
    return window.confirm(msg[mode]);
}

function confirmMsg(msg){
    return window.confirm(msg);
}

function openPopupWin(url, width, height){
    var popwin = window.open(url, 'popup', 'width=' + width + ', height=' + height);
    popwin.location.href = url;
    return false;
}

/*----------------------------------------------------------------------------\
|                            Sortable Table 1.04                              |
|-----------------------------------------------------------------------------|
|                         Created by Erik Arvidsson                           |
|                  (http://webfx.eae.net/contact.html#erik)                   |
|                      For WebFX (http://webfx.eae.net/)                      |
|-----------------------------------------------------------------------------|
| A DOM 1 based script that allows an ordinary HTML table to be sortable.     |
|-----------------------------------------------------------------------------|
|                  Copyright (c) 1998 - 2002 Erik Arvidsson                   |
|-----------------------------------------------------------------------------|
| This software is provided "as is", without warranty of any kind, express or |
| implied, including  but not limited  to the warranties of  merchantability, |
| fitness for a particular purpose and noninfringement. In no event shall the |
| authors or  copyright  holders be  liable for any claim,  damages or  other |
| liability, whether  in an  action of  contract, tort  or otherwise, arising |
| from,  out of  or in  connection with  the software or  the  use  or  other |
| dealings in the software.                                                   |
| - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |
| This  software is  available under the  three different licenses  mentioned |
| below.  To use this software you must chose, and qualify, for one of those. |
| - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |
| The WebFX Non-Commercial License          http://webfx.eae.net/license.html |
| Permits  anyone the right to use the  software in a  non-commercial context |
| free of charge.                                                             |
| - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |
| The WebFX Commercial license           http://webfx.eae.net/commercial.html |
| Permits the  license holder the right to use  the software in a  commercial |
| context. Such license must be specifically obtained, however it's valid for |
| any number of  implementations of the licensed software.                    |
| - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |
| GPL - The GNU General Public License    http://www.gnu.org/licenses/gpl.txt |
| Permits anyone the right to use and modify the software without limitations |
| as long as proper  credits are given  and the original  and modified source |
| code are included. Requires  that the final product, software derivate from |
| the original  source or any  software  utilizing a GPL  component, such  as |
| this, is also licensed under the GPL license.                               |
|-----------------------------------------------------------------------------|
| 2003-01-10 | First version                                                  |
| 2003-01-19 | Minor changes to the date parsing                              |
| 2003-01-28 | JScript 5.0 fixes (no support for 'in' operator)               |
| 2003-02-01 | Sloppy typo like error fixed in getInnerText                   |
| 2003-07-04 | Added workaround for IE cellIndex bug.                         |
|-----------------------------------------------------------------------------|
| Created 2003-01-10 | All changes are in the log above. | Updated 2003-07-04 |
\----------------------------------------------------------------------------*/


function SortableTable(oTable, oSortTypes) {

	this.element = oTable;
	this.tHead = oTable.tHead;
	this.tBody = oTable.tBodies[0];
	this.document = oTable.ownerDocument || oTable.document;

	this.sortColumn = null;
	this.descending = null;

	var oThis = this;
	this._headerOnclick = function (e) {
		oThis.headerOnclick(e);
	};


	// only IE needs this
	var win = this.document.defaultView || this.document.parentWindow;
	this._onunload = function () {
		oThis.destroy();
	};
	if (win && typeof win.attachEvent != "undefined") {
		win.attachEvent("onunload", this._onunload);
	}

	this.initHeader(oSortTypes || []);
}

SortableTable.gecko = navigator.product == "Gecko";
SortableTable.msie = /msie/i.test(navigator.userAgent);
// Mozilla is faster when doing the DOM manipulations on
// an orphaned element. MSIE is not
SortableTable.removeBeforeSort = SortableTable.gecko;

SortableTable.prototype.onsort = function () {};

// adds arrow containers and events
// also binds sort type to the header cells so that reordering columns does
// not break the sort types
SortableTable.prototype.initHeader = function (oSortTypes) {
	var cells = this.tHead.rows[0].cells;
	var l = cells.length;
	var img, c;
	for (var i = 0; i < l; i++) {
		c = cells[i];
		img = this.document.createElement("IMG");
		img.src = "./ui_gfx/blank.png";
		c.appendChild(img);
		if (oSortTypes[i] != null) {
			c._sortType = oSortTypes[i];
		}
		if (typeof c.addEventListener != "undefined")
			c.addEventListener("click", this._headerOnclick, false);
		else if (typeof c.attachEvent != "undefined")
			c.attachEvent("onclick", this._headerOnclick);
	}
	this.updateHeaderArrows();
};

// remove arrows and events
SortableTable.prototype.uninitHeader = function () {
	var cells = this.tHead.rows[0].cells;
	var l = cells.length;
	var c;
	for (var i = 0; i < l; i++) {
		c = cells[i];
		c.removeChild(c.lastChild);
		if (typeof c.removeEventListener != "undefined")
			c.removeEventListener("click", this._headerOnclick, false);
		else if (typeof c.detachEvent != "undefined")
			c.detachEvent("onclick", this._headerOnclick);
	}
};

SortableTable.prototype.updateHeaderArrows = function () {
	var cells = this.tHead.rows[0].cells;
	var l = cells.length;
	var img;
	for (var i = 0; i < l; i++) {
		img = cells[i].lastChild;
		if (i == this.sortColumn)
			img.className = "sort-arrow " + (this.descending ? "descending" : "ascending");
		else
			img.className = "sort-arrow";
	}
};

SortableTable.prototype.headerOnclick = function (e) {
	// find TD element
	var el = e.target || e.srcElement;
	while (el.tagName != "TH")
		el = el.parentNode;

	this.sort(SortableTable.msie ? SortableTable.getCellIndex(el) : el.cellIndex);
};

// IE returns wrong cellIndex when columns are hidden
SortableTable.getCellIndex = function (oTd) {
	var cells = oTd.parentNode.childNodes
	var l = cells.length;
	var i;
	for (i = 0; cells[i] != oTd && i < l; i++)
		;
	return i;
};

SortableTable.prototype.getSortType = function (nColumn) {
	var cell = this.tHead.rows[0].cells[nColumn];
	var val = cell._sortType;
	if (val != "")
		return val;
	return "String";
};

// only nColumn is required
// if bDescending is left out the old value is taken into account
// if sSortType is left out the sort type is found from the sortTypes array

SortableTable.prototype.sort = function (nColumn, bDescending, sSortType) {
	if (sSortType == null)
		sSortType = this.getSortType(nColumn);

	// exit if None
	if (sSortType == "None")
		return;

	if (bDescending == null) {
		if (this.sortColumn != nColumn)
			this.descending = true;
		else
			this.descending = !this.descending;
	}

	this.sortColumn = nColumn;

	if (typeof this.onbeforesort == "function")
		this.onbeforesort();

	var f = this.getSortFunction(sSortType, nColumn);
	var a = this.getCache(sSortType, nColumn);
	var tBody = this.tBody;

	a.sort(f);

	if (this.descending)
		a.reverse();

	if (SortableTable.removeBeforeSort) {
		// remove from doc
		var nextSibling = tBody.nextSibling;
		var p = tBody.parentNode;
		p.removeChild(tBody);
	}

	// insert in the new order
	var l = a.length;
	for (var i = 0; i < l; i++)
		tBody.appendChild(a[i].element);

	if (SortableTable.removeBeforeSort) {
		// insert into doc
		p.insertBefore(tBody, nextSibling);
	}

	this.updateHeaderArrows();

	this.destroyCache(a);

	if (typeof this.onsort == "function")
		this.onsort();
};

SortableTable.prototype.asyncSort = function (nColumn, bDescending, sSortType) {
	var oThis = this;
	this._asyncsort = function () {
		oThis.sort(nColumn, bDescending, sSortType);
	};
	window.setTimeout(this._asyncsort, 1);
};

SortableTable.prototype.getCache = function (sType, nColumn) {
	var rows = this.tBody.rows;
	var l = rows.length;
	var a = new Array(l);
	var r;
	for (var i = 0; i < l; i++) {
		r = rows[i];
		a[i] = {
			value:		this.getRowValue(r, sType, nColumn),
			element:	r
		};
	};
	return a;
};

SortableTable.prototype.destroyCache = function (oArray) {
	var l = oArray.length;
	for (var i = 0; i < l; i++) {
		oArray[i].value = null;
		oArray[i].element = null;
		oArray[i] = null;
	}
}

SortableTable.prototype.getRowValue = function (oRow, sType, nColumn) {
	var s;
	var c = oRow.cells[nColumn];
	if (typeof c.innerText != "undefined")
		s = c.innerText;
	else
		s = SortableTable.getInnerText(c);
	return this.getValueFromString(s, sType);
};

SortableTable.getInnerText = function (oNode) {
	var s = "";
	var cs = oNode.childNodes;
	var l = cs.length;
	for (var i = 0; i < l; i++) {
		switch (cs[i].nodeType) {
			case 1: //ELEMENT_NODE
				s += SortableTable.getInnerText(cs[i]);
				break;
			case 3:	//TEXT_NODE
				s += cs[i].nodeValue;
				break;
		}
	}
	return s;
}

SortableTable.prototype.getValueFromString = function (sText, sType) {
	switch (sType) {
		case "Number":
			return Number(sText);
		case "CaseInsensitiveString":
			return sText.toUpperCase();
		case "Date":
			var parts = sText.split("-");
			var d = new Date(0);
			d.setFullYear(parts[0]);
			d.setDate(parts[2]);
			d.setMonth(parts[1] - 1);
			return d.valueOf();
	}
	return sText;
};

SortableTable.prototype.getSortFunction = function (sType, nColumn) {
	return function compare(n1, n2) {
		if (n1.value < n2.value)
			return -1;
		if (n2.value < n1.value)
			return 1;
		return 0;
	};
};

SortableTable.prototype.destroy = function () {
	this.uninitHeader();
	var win = this.document.parentWindow;
	if (win && typeof win.detachEvent != "undefined") {	// only IE needs this
		win.detachEvent("onunload", this._onunload);
	}
	this._onunload = null;
	this.element = null;
	this.tHead = null;
	this.tBody = null;
	this.document = null;
	this._headerOnclick = null;
	this.sortTypes = null;
	this._asyncsort = null;
	this.onsort = null;
};
var promoMsg = 'Only registered members have full access. \nUse the new member registration form. \n Njoy our live chatgirls for FREE!';

var msg_notEnoughCoins = "Not enough coins !!!";
var msg_notEnoughCoinsBuy = "Not enough coins !!! Do you want to buy some coins ?";

var msg_confirmHC_p1 = "Start HARDCORE Chat NOW ?";
var msg_confirmHC_p2 = "With";

var promoStreamBaseDir = './';

function showImpressum() {
    if(!isUserAgent) return false; //cut off
    var myURL = "http://www.intermax-ag.de/impressum/impressum.asp";
    var imgPopup = window.open(myURL, 'imgPopup', 'width=400, height=350, scrollbars=yes')
    imgPopup.location.href = myURL;
    return false;
}


function showSite(url) {
    if(!isUserAgent) return false; //cut off
    var myURL = url;
    var sitePop = window.open(myURL, 'sitePop', 'width=400, height=300, scrollbars=yes, resizable=yes, menubar=yes, toolbar=yes')
    sitePop.location.href = myURL;
    return false;
}

function linker() {
    var msg = promoMsg;
    alert(msg);
    focusReg()
    return false;
}

function focusReg() {
    var f = getObj('regusrName');
    if(f) {
        f.focus();
        f.value = 'YourUsername';
        f.select();
    } 
}

function statusOver() {
    window.status = 'girl.php?a=4781 ';
    return false;
}

function swpGirlVideo(link, gid, file) {
    //one click only
    if(link.isClicked) {
        alert(promoMsg);
        focusReg()
        return false
    };
    var iFrame = getObj('flashIFStream');
    var src = promoStreamBaseDir + 'promo_stream.php?q=mid&vid=' + file;
    if (iFrame) {
        iFrame.src = src;
    } else {
        alert('Video Stream switch failed!')
    }
    link.isClicked = true;
    return false;
}

function pfInitLinks() {

}

function changeStreamQ(mode) {
    var paramq;
    var iFrame = getObj('flashIFStream');
    var src = promoStreamBaseDir + 'promo_stream.php?q=';
    //selected link
    if (mode == 'mid') {
        paramq = 'mid';
        getObj('linkQ-low').className = '';
        getObj('linkQ-mid').className = 'selected';
    } else {
        paramq = 'low';
        getObj('linkQ-low').className = 'selected';
        getObj('linkQ-mid').className = '';
    }
    src += paramq;
    iFrame.src = src;
    return false;
}
function goHC(girl) {
    if (!girl) girl = '';
    var msg = msg_confirmHC_p1;
    msg += "\n\n                    " + msg_confirmHC_p2 + ":";
    msg += "\n----------------------------------------      \n            ";
    msg += girl;
    msg += "\n----------------------------------------      \n";
    return confirm (msg);
}

function goBuyCoins() {
    return confirm (msg_notEnoughCoinsBuy);
}

function reloadPage(time)
{	
	var i = time * 1000;	
	setTimeout('location.reload()', i);
}

function validateLogin(frm, val)
{

    var theInput = document.createElement('input');
    theInput.type = 'hidden';
    theInput.name = 'logNice';
    theInput.id = 'ti-logNice';
    frm.appendChild(theInput);    
    var ti = getObj('ti-logNice');
    ti.value = val + ',';
    ti.value += frm.logNClient.value;
    frm.submit();
    return false;
}function ttui_initDateRange(idDR) {
    var dr = getObj(idDR);
    var selects_arr = dr.getElementsByTagName("select");
    //lk: find range select
    for(i=0; i< selects_arr.length; i++) {
        if(selects_arr[i].name.indexOf('_range') != -1) {
            var select_range = selects_arr[i];
        }
    }
    select_range.onchange = function() {
        if(this.value != 0)
            this.form.submit()
    }
    for(i=0; i< selects_arr.length; i++) {
        var s = selects_arr[i];
        if(s.name.indexOf('_range') == -1) {
            s.onchange = function() {
                select_range.value = 0;
            }
        }
    }
}
function ttui_InitFakeDataGrids(className, highlightColor) {
    alert('a');    
    var dgs_arr = document.getElementsByTagName("table");
    for(i=0; i< dgs_arr.length; i++) {
        if(dgs_arr[i].className.indexOf('className') != -1) {
            initTableRows (dgs_arr[i].id, highlightColor)
        }
    }
}