/*
**
** File 'functions.js'
**
*/
/////////////////////////////////////////////////////////////////////////////////////////////////////////
self.onError=null;
var clientPC = navigator.userAgent.toLowerCase(); // Get client info
var clientVer = parseInt(navigator.appVersion); // Get browser version
// *** BROWSER VERSION ***
// Note: On IE5, these return 4, so use is_ie5up to detect IE5.
var is_major = parseInt(navigator.appVersion);
var is_minor = parseFloat(navigator.appVersion);
var is_ie = ((clientPC.indexOf("msie") != -1) && (clientPC.indexOf("opera") == -1));
var is_nav = ((clientPC.indexOf('mozilla')!=-1) && (clientPC.indexOf('spoofer')==-1) && (clientPC.indexOf('compatible') == -1) && (clientPC.indexOf('opera')==-1) && (clientPC.indexOf('webtv')==-1) && (clientPC.indexOf('hotjava')==-1));
var is_moz = 0;
var is_win = ((clientPC.indexOf("win")!=-1) || (clientPC.indexOf("16bit") != -1));
var is_mac = (clientPC.indexOf("mac")!=-1);
var NS = (document.layers) ? 1 : 0;
var IE = (document.all) ? 1: 0;
var is_ie3 = (is_ie && (is_major < 4));
var is_ie4 = (is_ie && (is_major == 4) && (clientPC.indexOf("msie 4")!=-1) );
var is_ie4up = (is_ie && (is_major >= 4));
var is_ie5 = (is_ie && (is_major == 4) && (clientPC.indexOf("msie 5.0")!=-1) );
var is_ie5_5 = (is_ie && (is_major == 4) && (clientPC.indexOf("msie 5.5") !=-1));
var is_ie5up = (is_ie && !is_ie3 && !is_ie4);
var is_ie5_5up =(is_ie && !is_ie3 && !is_ie4 && !is_ie5);
var is_ie6 = (is_ie && (is_major == 4) && (clientPC.indexOf("msie 6.")!=-1) );
var is_ie6up = (is_ie && !is_ie3 && !is_ie4 && !is_ie5 && !is_ie5_5);
var Browser = new Object();
var ua = navigator.userAgent.toLowerCase();
Browser.isMozilla = (typeof document.implementation != 'undefined') && (typeof document.implementation.createDocument != 'undefined') && (typeof HTMLDocument!='undefined');
Browser.isIE = window.ActiveXObject ? true : false;
Browser.isFirefox = (ua.indexOf("firefox")!=-1);
Browser.isSafari = (ua.indexOf("safari")!=-1);
Browser.isOpera = (typeof window.opera != 'undefined');
var keine_action = 1;
var alle_action = 2;
var now = new Date();
var start_time = now.getTime();
var show_session_layer = false;
var currentX = 0;
var currentY = 0;
var whichIt = null;
var lastScrollX = 0;
var lastScrollY = 0;
/////////////////////////////////////////////////////////////////////////////////////////////////////////
function setCssClass (element, classname) {
element.setAttribute('class',classname);
element.setAttribute('className',classname); // IE6 is now our friend!
}
function addOnErrorEvent (fnc) {
if ( typeof window.addEventListener != "undefined" )
window.addEventListener( "error", fnc, false );
else if ( typeof window.attachEvent != "undefined" ) {
window.attachEvent( "onerror", fnc );
}
else {
if ( window.onerror != null ) {
var oldOnerror = window.onerror;
window.onerror = function ( e ) {
oldOnerror( e );
window[fnc]();
};
}
else
window.onerror = fnc;
}
}
function addEventHandler(element, type, handler) {
try {
element.addEventListener(type, handler, false);
} catch(inferiorBrowserException) {
if(element.attachEvent)
element.attachEvent('on'+type, handler);
else
element['on'+type] = handler;
}
return [element, type, handler];
}
/* does not work in Safari */
if (window.addEventListener) {
window.addEventListener("error", (function () {return null;}), false);
} else if (window.attachEvent) {
window.attachEvent("onerror", (function () {return null;}));
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
function sliding(element_name) {
if(IE) { diffY = document.body.scrollTop+120; diffX = document.body.scrollLeft; }
if(NS) { diffY = self.pageYOffset; diffX = self.pageXOffset; }
if(diffY != lastScrollY) {
percent = .1 * (diffY - lastScrollY);
if(percent > 0) percent = Math.ceil(percent);
else percent = Math.floor(percent);
if(IE) document.getElementById(element_name).style.pixelTop += percent;
if(NS) document.getElementById(element_name).top += percent;
lastScrollY = lastScrollY + percent;
}
if(diffX != lastScrollX) {
percent = .1 * (diffX - lastScrollX);
if(percent > 0) percent = Math.ceil(percent);
else percent = Math.floor(percent);
if(IE) getElementById(element_name).style.pixelLeft += percent;
if(NS) document.getElementById(element_name).left += percent;
lastScrollX = lastScrollX + percent;
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
function getActiveText (selectedtext) {
text = (document.all) ? document.selection.createRange().text : document.getSelection();
if (selectedtext.createTextRange) selectedtext.caretPos = document.selection.createRange().duplicate();
return true;
}
//////////////////////////////////////////////////////////////////////////////////////////////////
function fenster (seite) {
neu4 = window.open(seite,"preview","toolbar=no,width=500,height=550,scrollbars=yes,directories=no,menubar=no,screenx=1,screeny=1,pageXOffset=1,pageYOffset=1");
neu4.focus();
}
//////////////////////////////////////////////////////////////////////////////////////////////////
function popup (seite) {
neu4 = window.open(seite,"preview","toolbar=no,width=500,height=550,scrollbars=no,directories=no,menubar=no,screenx=1,screeny=1,pageXOffset=1,pageYOffset=1");
neu4.focus();
}
//////////////////////////////////////////////////////////////////////////////////////////////////
function popup2 (seite,breite,hoehe) {
neu4 = window.open(seite,"","toolbar=no,width="+breite+",height="+hoehe+",scrollbars=no,directories=no,menubar=no,screenx=1,screeny=1,pageXOffset=1,pageYOffset=1");
neu4.focus();
}
//////////////////////////////////////////////////////////////////////////////////////////////////
function fenster_new (seite) {
neu4 = window.open(seite,"preview","toolbar=yes,resizable=yes,width=600,height=500,scrollbars=yes,directories=yes,menubar=yes,screenx=1,screeny=1,pageXOffset=1,pageYOffset=1");
neu4.focus();
}
//////////////////////////////////////////////////////////////////////////////////////////////////
function fenster2 (seite, breite, hoehe, id) {
window.open(seite, id,"width=" +breite +",height=" +hoehe + ",resizable=no,location=no,status=no,toolbar=no,scrollbars=no,directories=no,menubar=no,screenx=1,screeny=1,pageXOffset=10,pageYOffset=10");
}
//////////////////////////////////////////////////////////////////////////////////////////////////
function fenster3 (seite, breite, hoehe, id) {
window.open(seite, id,"width=" +breite +",height=" +hoehe + ",resizable=no,location=no,status=no,toolbar=no,scrollbars=no,directories=no,menubar=no,screenx=1,screeny=1,pageXOffset=10,pageYOffset=10");
// neu=window.open("seite", id,"width=" +breite +",height=" +hoehe + ",resizable=no,location=no,status=no,toolbar=no,scrollbars=no,directories=no,menubar=no,screenx=1,screeny=1,pageXOffset=10,pageYOffset=10");
// neu.document.write('<\/head>
<\/body><\/html>')
// neu.focus()
}
//////////////////////////////////////////////////////////////////////////////////////////////////
function fenster2_scrollbars (seite, breite, hoehe, id) {
window.open(seite, id,"width=" +breite +",height=" +hoehe + ",resizable=yes,location=no,status=yes,toolbar=no,scrollbars=yes,directories=no,menubar=no,screenx=1,screeny=1,pageXOffset=1,pageYOffset=1");
}
////////////////////////////////////////////////////////////////////////////////////
function picture (seite, breite, hoehe, id) {
neu= window.open(seite, id ,"toolbar=no,width=" +breite +",height=" +hoehe + ",directories=no,status=no,menubar=no,screenx=1,screeny=1,pageXOffset=1,pageYOffset=1");
neu.focus();
}
////////////////////////////////////////////////////////////////////////////////////
function image_link (start, image, breite, hoehe, id) {
var string = "javascript: picture ('/index.php?action=" + start + "&image=" + image + "','" + breite +"','" + hoehe + "'," + id + ");";
return string
}
////////////////////////////////////////////////////////////////////////////////////
function print_page (seite) {
neu1= window.open(seite, "Druckversion" ,"width=545,height=600,left=0,top=0,toolbar=yes,scrollbars=yes");
neu1.focus();
}
////////////////////////////////////////////////////////////////////////////////////
function xml (seite) {
neu2= window.open(seite, "XMLVersion" ,"width=545,height=600,left=0,top=0,menubar=yes,toolbar=no,scrollbars=yes");
neu2.focus();
}
////////////////////////////////////////////////////////////////////////////////////
function details (seite,id) {
if (id != "") {
neu3= window.open(seite + "&idtoedit=" + id, "Details" ,"width=545,height=600,left=0,top=0,toolbar=yes,scrollbars=yes");
neu3.focus();
}
}
////////////////////////////////////////////////////////////////////////////////////
function GO (target) {
if (target != "nix") {
self.location.href = target;
}
}
////////////////////////////////////////////////////////////////////////////////////
function ListOption(content, id) {
this.content = content;
this.id = id;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
function AddText(NewCode,formName,fieldName) {
var txtarea = document.forms[formName].elements[fieldName];
if ((clientVer >= 4) && is_ie && is_win) {
var d = (document.forms ? document.forms[formName] : null);
var e = (d && d.elements ? d.elements[fieldName] : null);
if (e.createTextRange && e.caretPos) {
var caretPos = e.caretPos;
caretPos.text = caretPos.text.charAt(caretPos.text.length - 1) == ' ' ? NewCode + ' ' : NewCode;
} else {
e.value+=NewCode
}
txtarea.focus();
text = '';
} else {
txtarea.value += NewCode;
}
getActiveText (txtarea);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
function markSelection (start_tag, stop_tag, element, formName, fieldName){
var temp = "..." + stop_tag;
var val = start_tag;
val += (stop_tag ? temp : "");
if (text) {
val = start_tag + text + stop_tag;
}
AddText(val , formName, fieldName);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
function SetActionValue (formName, fieldName, valueAssign) {
document.forms[formName].elements[fieldName].value=valueAssign;
document.forms[formName].submit();
return true;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
function MM_preloadImages() { //v3.0
var d=document; if(d.images){ if(!d.MM_p) d.MM_p=new Array();
var i,j=d.MM_p.length,a=MM_preloadImages.arguments; for(i=0; i0&&parent.frames.length) {
d=parent.frames[n.substring(p+1)].document; n=n.substring(0,p);}
if(!(x=d[n])&&d.all) x=d.all[n]; for (i=0;!x&&i 2) {
if ((img = MM_findObj(args[2])) != null && !img.MM_init) {
img.MM_init = true; img.MM_up = args[3]; img.MM_dn = img.src;
if ((nbArr = document[grpName]) == null) nbArr = document[grpName] = new Array();
nbArr[nbArr.length] = img;
for (i=4; i < args.length-1; i+=2) if ((img = MM_findObj(args[i])) != null) {
if (!img.MM_up) img.MM_up = img.src;
img.src = img.MM_dn = args[i+1];
nbArr[nbArr.length] = img;
} }
} else if (event == "over") {
document.MM_nbOver = nbArr = new Array();
for (i=1; i < args.length-1; i+=3) if ((img = MM_findObj(args[i])) != null) {
if (!img.MM_up) img.MM_up = img.src;
img.src = (img.MM_dn && args[i+2]) ? args[i+2] : ((args[i+1])? args[i+1] : img.MM_up);
nbArr[nbArr.length] = img;
}
} else if (event == "out" ) {
for (i=0; i < document.MM_nbOver.length; i++) {
img = document.MM_nbOver[i]; img.src = (img.MM_dn) ? img.MM_dn : img.MM_up; }
} else if (event == "down") {
nbArr = document[grpName];
if (nbArr)
for (i=0; i < nbArr.length; i++) { img=nbArr[i]; img.src = img.MM_up; img.MM_dn = 0; }
document[grpName] = nbArr = new Array();
for (i=2; i < args.length-1; i+=2) if ((img = MM_findObj(args[i])) != null) {
if (!img.MM_up) img.MM_up = img.src;
img.src = img.MM_dn = (args[i+1])? args[i+1] : img.MM_up;
nbArr[nbArr.length] = img;
} }
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
function hasOptions(obj) {
if (obj!=null && obj.options!=null) { return true; }
return false;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
function lockOptions (obj) {
if (!hasOptions(obj)) { return false; }
for (var i=0; i (b.text+"")) { return 1; }
return 0;
}
);
for (var i=0; i 0) {
moveAllOptions (to, from);
if (option_set > 1) {
setSelectOptionsbyObj (from, alle_action, true);
} else {
setSelectOptionsbyObj (from, keine_action, true);
}
}
// Maximum exeeded ?
if (check > 0 && (to.length >= check || ((selectcount+to.length) > check))) { return; }
// Move them over
for (var i=0; i=0; i--) {
var o = from.options[i];
if (o.selected) {
from.options[i] = null;
}
}
if (sort == 1) {
sortSelect(from);
sortSelect(to);
}
from.selectedIndex = -1;
to.selectedIndex = -1;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
function moveSelectedOptionsAJAX(from,to,check,proove,sort,form) {
// Unselect matching options, if required
var selectcount = 0;
var option_set = 0;
var lock = false;
if (!hasOptions(from)) { return; }
for (var i=0; i 0) {
moveAllOptions (to, from);
if (option_set > 1) {
setSelectOptionsbyObj (from, alle_action, true);
} else {
setSelectOptionsbyObj (from, keine_action, true);
}
}
// Maximum exeeded ?
if (check > 0 && (to.length >= check || ((selectcount+to.length) > check))) { return; }
// Move them over
for (var i=0; i=0; i--) {
var o = from.options[i];
if (o.selected) {
from.options[i] = null;
}
}
if (sort == 1) {
sortSelect(from);
sortSelect(to);
}
from.selectedIndex = -1;
to.selectedIndex = -1;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
function moveAllOptions(from,to) {
selectAllOptions(from);
moveSelectedOptions(from,to);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
function copySelectedOptions(from,to,check,proove,sort,count) {
if (!this.hasOptions(from)) { return false; }
var options = new Object();
// Maximum exeeded ?
if (check > 0 && (to.length >= check || ((selectcount+to.length) > check))) { return; }
for (var i=0; i 1) {
for(var j=0; j=0; i--) {
var o=from.options[i];
if (o.selected) {
from.options[i] = null;
}
}
}
from.selectedIndex = -1;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
function setSelectOptions(the_form, the_select, do_check) {
var selectObject = document.forms[the_form].elements[the_select];
var selectCount = selectObject.length;
for (var i = 0; i < selectCount; i++) {
selectObject.options[i].selected = do_check;
} // end for
return true;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
function setSelectOptionbyId(the_form, the_select, option_number) {
if (option_number > 0) option_number = option_number-1;
var selectObject = document.forms[the_form].elements[the_select];
selectObject.options[option_number].selected = true;
return true;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
function setSelectOptionsbyObj ( obj, the_select, do_check) {
for (var i=0; i < obj.options.length; i++) {
var o = obj.options[i];
if (o.value == the_select) {
o.selected = do_check;
} else {
o.selected = false;
}
}
return true;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
function moveOptionUp(obj) {
if (!hasOptions(obj)) { return; }
for (i=0; i=0; i--) {
if (obj.options[i].selected) {
if (i != (obj.options.length-1) && ! obj.options[i+1].selected) {
swapOptions(obj,i,i+1);
obj.options[i+1].selected = true;
}
}
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
function moveOptionDownAjax(obj) {
if (!hasOptions(obj)) { return; }
for (i=obj.options.length-1; i>=0; i--) {
if (obj.options[i].selected) {
if (i != (obj.options.length-1) && ! obj.options[i+1].selected) {
swapOptions(obj,i,i+1);
obj.options[i+1].selected = true;
}
}
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
function swapOptions(obj,i,j) {
var o = obj.options;
var i_selected = o[i].selected;
var j_selected = o[j].selected;
var temp = new Option(o[i].text, o[i].value, o[i].defaultSelected, o[i].selected);
var temp2= new Option(o[j].text, o[j].value, o[j].defaultSelected, o[j].selected);
o[i] = temp2;
o[j] = temp;
o[i].selected = j_selected;
o[j].selected = i_selected;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
function timeRedirect (in_time, link) {
var current_date = new Date();
var current_time = Math.round((current_date.getTime() - start_time)/1000);
if (current_time >= (in_time+2)) {
self.location.href = link;
}
window.setTimeout('timeRedirect(' + in_time + ',\'' + link + '\')',1000);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
function sessionWarning (in_time) {
var current_date = new Date();
var current_time = Math.round((current_date.getTime() - start_time)/1000);
if (current_time >= (in_time-120) && show_session_layer == false) {
switch_layer(document.getElementById('session_warning'));
show_session_layer = true;
if (NS || IE) action = window.setInterval("sliding('session_warning')",50);
}
window.setTimeout('sessionWarning(' + in_time + ')',1000);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
function selectAllOptions(obj) {
//alert(obj.name);
if (!hasOptions(obj)) { return; }
obj.multiple=true;
for (var i=0; i= 3 check for Flash plugin in plugin array
if (navigator.plugins != null && navigator.plugins.length > 0) {
if (navigator.plugins["Shockwave Flash 2.0"] || navigator.plugins["Shockwave Flash"]) {
var swVer2 = navigator.plugins["Shockwave Flash 2.0"] ? " 2.0" : "";
var flashDescription = navigator.plugins["Shockwave Flash" + swVer2].description;
descArray = flashDescription.split(" ");
tempArrayMajor = descArray[2].split(".");
versionMajor = tempArrayMajor[0];
versionMinor = tempArrayMajor[1];
if ( descArray[3] != "" ) {
tempArrayMinor = descArray[3].split("r");
} else {
tempArrayMinor = descArray[4].split("r");
}
versionRevision = tempArrayMinor[1] > 0 ? tempArrayMinor[1] : 0;
flashVer = versionMajor + "." + versionMinor + "." + versionRevision;
} else {
flashVer = -1;
}
}
// MSN/WebTV 2.6 supports Flash 4
else if (navigator.userAgent.toLowerCase().indexOf("webtv/2.6") != -1) flashVer = 4;
// WebTV 2.5 supports Flash 3
else if (navigator.userAgent.toLowerCase().indexOf("webtv/2.5") != -1) flashVer = 3;
// older WebTV supports Flash 2
else if (navigator.userAgent.toLowerCase().indexOf("webtv") != -1) flashVer = 2;
// Can't detect in all other cases
else {
flashVer = -1;
}
return flashVer;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
// When called with reqMajorVer, reqMinorVer, reqRevision returns true if that version or greater is available
function DetectFlashVer(reqMajorVer, reqMinorVer, reqRevision)
{
reqVer = parseFloat(reqMajorVer + "." + reqRevision);
// loop backwards through the versions until we find the newest version
for (i=25;i>0;i--) {
if (isIE && isWin && !isOpera) {
versionStr = VBGetSwfVer(i);
} else {
versionStr = JSGetSwfVer(i);
}
if (versionStr == -1 ) {
return false;
} else if (versionStr != 0) {
if(isIE && isWin && !isOpera) {
tempArray = versionStr.split(" ");
tempString = tempArray[1];
versionArray = tempString .split(",");
} else {
versionArray = versionStr.split(".");
}
versionMajor = versionArray[0];
versionMinor = versionArray[1];
versionRevision = versionArray[2];
versionString = versionMajor + "." + versionRevision; // 7.0r24 == 7.24
versionNum = parseFloat(versionString);
// is the major.revision >= requested major.revision AND the minor version >= requested minor
if ( (versionMajor > reqMajorVer) && (versionNum >= reqVer) ) {
return true;
} else {
return ((versionNum >= reqVer && versionMinor >= reqMinorVer) ? true : false );
}
}
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
function updateParent(target) {
if(window.opener && window.opener.closed == false) {
window.opener.location.href = target;
window.opener.focus();
}
else
{
window.open(target,"Parent");
}
window.close();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
function fnSetInfo(text) {
if (text != '') {
text = text.replace(/§§/gi, '"');
text = text.replace(/</gi, '<');
event.dataTransfer.setData("Text", text);
event.dataTransfer.effectAllowed = "copy";
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
function fnGetInfo(formName, fieldName) {
event.returnValue = false;
event.dataTransfer.dropEffect = "copy";
document.forms[formName].elements[fieldName].value += event.dataTransfer.getData("Text");
document.forms[formName].elements[fieldName].focus();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
function fnCancelDefault() {
event.returnValue = false;
event.dataTransfer.dropEffect = "copy";
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
function radioCheck (name, current_value) {
for (i = 0; i < document.getElementsByName(name).length; i++) {
if (document.getElementsByName(name)[i].value != current_value) {
document.getElementsByName(name)[i].checked = false;
} else {
document.getElementsByName(name)[i].checked = true;
}
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
function formDynamicSubmit (name, field) {
var string = '';
if (field == null) field = 'Option';
for (i = 0; i < document.getElementsByName(name).length; i++) {
if (document.getElementsByName(name)[i].checked) {
string = document.getElementsByName(name)[i].value;
}
}
if (string != '') {
document.forms[string].submit();
} else {
alert ('Bitte wähle eine ' + field + ' durch Anklicken des Kreises vor der Option.');
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
function xorCrypt(text) {
key = "emailverschlüsselungfüradressenwegendenspammern";
result = '';
for (i = 0; i < text.length; i++){
j = (i >= text.length)? 0 : i;
result += String.fromCharCode(text.charCodeAt(i) ^ key.charCodeAt(j));
}
return result;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
function sendmail(mail) {
mail = 'mailto:'+xorCrypt(unescape(mail));
location.href=mail;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
String.prototype.removeTags = function() {
var tmp = this;
while (tmp.search(/\<[^>]*\>/) != -1){
tmp = tmp.replace(/\<[^>]*\>/,'').replace(/\n/,'').replace(/\r/,'');
}
return tmp.replace(/^(^\s*|\s*$)/, "").replace(/(^\s*|\s*$)$/, "");
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
String.prototype.trim = function(){
return this.replace(/(^\s*|\s*$)/, "");
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
function insertText(from,select,field){
var fieldset = $('id_'+field);
var obj = $('id_'+from);
var obj2 = document.getElementsByName(from);
var select1 = document.getElementsByName(select+'[]')[0];
var select2 = document.getElementsByName(select+'_unselected[]')[0];
var input = obj2[0].value;
var elementId = obj.g_id;
var object = document.getElementById('id_hidden_value_' + elementId);
object.value = input;
var cstring = '';
if (input.length > 10) cstring = input.slice(0,7) + '...';
else cstring = input;
if (fieldset != 'undefined') {Effect.Fade(fieldset);};
if (hasOptions(select1)){
for (var i=0; i 0){
for (var i=0; i -1)?obj.options[obj.selectedIndex].value:null;
if (index != null) {
var object = $('id_hidden_value_' + index);
var test2 = (object.replacetext == undefined || object.replacetext == null)? '' : new String(object.replacetext);
var outer_replace = test2.split('+++++');
var obj2 = document.getElementsByName(textobj);
$('id_'+textobj).g_id = obj.value;
for (i=0;i 0) {
moveAllOptions (to, from);
if (option_set > 1) {
setSelectOptionsbyObj (from, alle_action, true);
} else {
setSelectOptionsbyObj (from, keine_action, true);
}
}
// Maximum exeeded ?
if (check > 0 && (to.length >= check || ((selectcount+to.length) > check))) { return; }
// Move them over
for (var i=0; i=0; i--) {
var o = from.options[i];
if (o.selected) {
from.options[i] = null;
}
}
if (sort == 1) {
sortSelect(from);
sortSelect(to);
}
if (fieldset) {Effect.Fade(fieldset);};
from.selectedIndex = -1;
to.selectedIndex = -1;
}
/**
*
* UTF-8 data encode / decode
*
**/
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;
}
}
// This code is in the public domain. Feel free to link back to http://jan.moesen.nu/
function sprintf()
{
if (!arguments || arguments.length < 1 || !RegExp)
{
return;
}
var str = arguments[0];
var re = /([^%]*)%('.|0|\x20)?(-)?(\d+)?(\.\d+)?(%|b|c|d|u|f|o|s|x|X)(.*)/;
var a = b = [], numSubstitutions = 0, numMatches = 0;
while (a = re.exec(str))
{
var leftpart = a[1], pPad = a[2], pJustify = a[3], pMinLength = a[4];
var pPrecision = a[5], pType = a[6], rightPart = a[7];
//alert(a + '\n' + [a[0], leftpart, pPad, pJustify, pMinLength, pPrecision);
numMatches++;
if (pType == '%')
{
subst = '%';
}
else
{
numSubstitutions++;
if (numSubstitutions >= arguments.length)
{
alert('Error! Not enough function arguments (' + (arguments.length - 1) + ', excluding the string)\nfor the number of substitution parameters in string (' + numSubstitutions + ' so far).');
}
var param = arguments[numSubstitutions];
var pad = '';
if (pPad && pPad.substr(0,1) == "'") pad = leftpart.substr(1,1);
else if (pPad) pad = pPad;
var justifyRight = true;
if (pJustify && pJustify === "-") justifyRight = false;
var minLength = -1;
if (pMinLength) minLength = parseInt(pMinLength);
var precision = -1;
if (pPrecision && pType == 'f') precision = parseInt(pPrecision.substring(1));
var subst = param;
if (pType == 'b') subst = parseInt(param).toString(2);
else if (pType == 'c') subst = String.fromCharCode(parseInt(param));
else if (pType == 'd') subst = parseInt(param) ? parseInt(param) : 0;
else if (pType == 'u') subst = Math.abs(param);
else if (pType == 'f') subst = (precision > -1) ? Math.round(parseFloat(param) * Math.pow(10, precision)) / Math.pow(10, precision): parseFloat(param);
else if (pType == 'o') subst = parseInt(param).toString(8);
else if (pType == 's') subst = param;
else if (pType == 'x') subst = ('' + parseInt(param).toString(16)).toLowerCase();
else if (pType == 'X') subst = ('' + parseInt(param).toString(16)).toUpperCase();
}
str = leftpart + subst + rightPart;
}
return str;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
function blog_checkform_addcomment (form) {
var author = form.author;
var email = form.email;
var comment = form.comment_text;
var error = "";
if (author.value.match(/^\s*$/)) {
error = error + "- Bitte geben Sie Ihren Namen ein.\n";
}
if (comment.value.match(/^\s*$/)) {
error = error + "- Bitte geben Sie einen Kommentar an.\n";
}
if ((email.value.length > 0) && !email.value.match(/^.+\@.+\..+$/)) {
error = error + "- Bitte prüfen Sie Ihre Email-Adresse auf Gültigkeit (oder lassen Sie das Feld ganz leer).";
}
if (error.length != 0) {
alert("Folgende Felder sind nicht oder nicht korrekt ausgefüllt:\n" + error);
return false;
}
return true;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
/* Funktion zum Prüfen von Formulareingaben:
Benutzung im Formular-Eventhandler:
Feldtypen:
- email: (automatisch, wenn kein Feldtyp angegeben und der Feldname 'mail' enthält)
- text: optional können Minimal- und Maximallänge übergeben werden
- integer: optional können Minimal- und Maximalwert übergeben werden
Rückgabewert:
- bei Fehlern wird eine Meldung angezeigt
- Funktion gibt true oder false zurück
*/
function validForm (form, requiredFields) {
var error = false;
// ...
return error;
}
function validEmail (email) { // UNGETESTET!!!
if (String(email).match(/^.+\@.+\..+$/)) {
return true;
}
return false;
}
function validText (text, minlength, maxlength) { // UNGETESTET!!!
var t = String(text);
if (t.length >= minlength && t.length <= maxlength) {
return true;
}
return false;
}
function validInteger (integer, minvalue, maxvalue) { // UNGETESTET!!!
var i = Number(integer);
if (i.isNaN() || !i.isFinite || i < Number(minvalue) || i > Number(maxvalue)) {
return true;
}
return false;
}
function lightboxRequest(element,params,type,mode,my_index,autoplay,autoplaytiming){
if (type == undefined) type = 'gallery';
if (my_index == undefined) my_index = '1';
if (params == undefined) params = '';
if (autoplay == undefined) autoplay = false;
if (autoplaytiming == undefined) autoplaytiming = '10';
if(mode == 'gallery') {
url = '/data/gallery_getXML.php';
}
else {
url = '/data/photoalbum_getXML.php';
}
params = encodeURI(params+'&first_id=id_lightbox_photo_first&index='+my_index+'&type='+type);
var opt = {
// Use POST
method: 'post',
// Send this lovely data
postBody: params,
// Handle successful response
onSuccess: function(t) {
$(element).update(t.responseText);
first = $('id_lightbox_photo_first');
if (type == 'lightbox'){
//für lightbox
initLightbox();
myLightbox.start(first,autoplay,autoplaytiming);
} else {
//für lightview
Lightview.updateViews();
Lightview.show(first);
}
},
// Handle 404
on404: function(t) {
alert('Error 404: location \"' + t.statusText + '\" was not found.');
},
// Handle other errors
onFailure: function(t) {
alert('Error ' + t.status + ' -- ' + t.statusText);
}
}
new Ajax.Request(url, opt);
}
AIM = {
frame : function(c) {
var n = 'f' + Math.floor(Math.random() * 99999);
var d = document.createElement('DIV');
d.innerHTML = '';
document.body.appendChild(d);
var i = document.getElementById(n);
if (c && typeof(c.onComplete) == 'function') {
i.onComplete = c.onComplete;
}
if (c && c.options) {
i.options = c.options;
}
return n;
},
form : function(f, name) {
f.setAttribute('target', name);
},
submit : function(f, c) {
AIM.form(f, AIM.frame(c));
if (c && typeof(c.onStart) == 'function') {
return c.onStart();
} else {
return true;
}
},
loaded : function(id) {
var i = document.getElementById(id);
if (i.contentDocument) {
var d = i.contentDocument;
} else if (i.contentWindow) {
var d = i.contentWindow.document;
} else {
var d = window.frames[id].document;
}
if (d.location.href == "about:blank") {
return;
}
if (typeof(i.onComplete) == 'function') {
if (!d.body.getAttribute) {
i.onComplete(d.body.innerHTML,0);
} else {
i.onComplete(d.body.innerHTML,d.body.getAttribute('error'));
}
}
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
function defaultConfirmMessage (text, link, formName) {
if (text != '') {
text = text.replace("
", "\n");
text = text.replace("
", "\n");
Check = confirm(text);
if (Check == true) {
if (formName && formName != '') {
document.forms[formName].submit();
}
else if (link && link != '') {
location.href = link;
}
}
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
function clearText(str) {
str = str.replace(/ä/g,'ae');
str = str.replace(/Ä/g,'Ae');
str = str.replace(/ö/g,'oe');
str = str.replace(/Ö/g,'Oe');
str = str.replace(/ü/g,'ue');
str = str.replace(/Ü/g,'Ue');
str = str.replace(/ß/g,'ss');
re = /\$|,|@|#|Ä|§|\/|Ö|Ü|ä|ö|ü|ß| |~|`|\%|\*|\^|\&|\(|\)|\+|\=|\[|\-|\_|\]|\[|\}|\{|\;|\:|\'|\"|\<|\>|\?|\||\\|\!|\$|\./g;
// remove special characters like "$" and "," etc...
return str.replace(re, "_");
}
/*
**
** File 'JavaScriptFlashGateway.js'
**
*/
/*
Macromedia(r) Flash(r) JavaScript Integration Kit License
Copyright (c) 2005 Macromedia, inc. All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation and/or
other materials provided with the distribution.
3. The end-user documentation included with the redistribution, if any, must
include the following acknowledgment:
"This product includes software developed by Macromedia, Inc.
(http://www.macromedia.com)."
Alternately, this acknowledgment may appear in the software itself, if and
wherever such third-party acknowledgments normally appear.
4. The name Macromedia must not be used to endorse or promote products derived
from this software without prior written permission. For written permission,
please contact devrelations@macromedia.com.
5. Products derived from this software may not be called "Macromedia" or
"Macromedia Flash", nor may "Macromedia" or "Macromedia Flash" appear in their
name.
THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL MACROMEDIA OR
ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
DAMAGE.
--
This code is part of the Flash / JavaScript Integration Kit:
http://www.macromedia.com/go/flashjavascript/
Created by:
Christian Cantrell
http://weblogs.macromedia.com/cantrell/
mailto:cantrell@macromedia.com
Mike Chambers
http://weblogs.macromedia.com/mesh/
mailto:mesh@macromedia.com
Macromedia
*/
/**
* Create a new Exception object.
* name: The name of the exception.
* message: The exception message.
*/
function Exception(name, message)
{
if (name)
this.name = name;
if (message)
this.message = message;
}
/**
* Set the name of the exception.
*/
Exception.prototype.setName = function(name)
{
this.name = name;
}
/**
* Get the exception's name.
*/
Exception.prototype.getName = function()
{
return this.name;
}
/**
* Set a message on the exception.
*/
Exception.prototype.setMessage = function(msg)
{
this.message = msg;
}
/**
* Get the exception message.
*/
Exception.prototype.getMessage = function()
{
return this.message;
}
/**
* Generates a browser-specific Flash tag. Create a new instance, set whatever
* properties you need, then call either toString() to get the tag as a string, or
* call write() to write the tag out.
*/
/**
* Creates a new instance of the FlashTag.
* src: The path to the SWF file.
* width: The width of your Flash content.
* height: the height of your Flash content.
*/
function FlashTag(src, width, height)
{
this.src = src;
this.width = width;
this.height = height;
this.version = '7,0,14,0';
this.id = null;
this.bgcolor = 'ffffff';
this.fullscreen= 'true';
this.flashVars = null;
this.wmode = 0; // 1 -> transparent, funktioniert aber nicht mit videoplayer fullscreen
}
/**
* Sets the Flash version used in the Flash tag.
*/
FlashTag.prototype.setVersion = function(v)
{
this.version = v;
}
/**
* Sets the ID used in the Flash tag.
*/
FlashTag.prototype.setId = function(id)
{
this.id = id;
}
/**
* Kuborgh Bugfix!!!
*/
FlashTag.prototype.setWmode= function(mode)
{
this.wmode = mode;
}
/**
* Sets the background color used in the Flash tag.
*/
FlashTag.prototype.setBgcolor = function(bgc)
{
this.bgcolor = bgc;
}
/**
* Sets the background color used in the Flash tag.
*/
FlashTag.prototype.setFullscreen = function(fs)
{
this.fullscreen = fs;
}
/**
* Sets any variables to be passed into the Flash content.
*/
FlashTag.prototype.setFlashvars = function(fv)
{
this.flashVars = fv;
}
/**
* Get the Flash tag as a string.
*/
FlashTag.prototype.toString = function()
{
var ie = (navigator.appName.indexOf ("Microsoft") != -1) ? 1 : 0;
var flashTag = new String();
if (ie)
{
flashTag += '';
}
else
{
flashTag += '';
break;
case 'string':
doc.xml += ''+this._escapeXml(obj)+'';
break;
case 'number':
doc.xml += ''+obj+'';
break;
case 'boolean':
doc.xml += '';
break;
case 'object':
if (obj == null)
{
doc.xml += '';
}
else if (obj instanceof Date)
{
doc.xml += ''+obj.getTime()+'';
}
else if (obj instanceof Array)
{
doc.xml += '';
for (var i = 0; i < obj.length; ++i)
{
this._serializeNode(obj[i], doc, null);
}
doc.xml += '';
}
else
{
doc.xml += '';
for (var n in obj)
{
if (typeof(obj[n]) == 'function')
continue;
this._serializeNode(obj[n], doc, n);
}
doc.xml += '';
}
break;
default:
throw new Exception("FlashSerializationException",
"You can only serialize strings, numbers, booleans, objects, dates, arrays, nulls and undefined");
break;
}
}
/**
* Private
*/
FlashSerializer.prototype._addName= function(name)
{
if (name != null)
{
return ' name="'+name+'"';
}
return '';
}
/**
* Private
*/
FlashSerializer.prototype._escapeXml = function(str)
{
if (this.useCdata)
return '';
else
return str.replace(/&/g,'&').replace(/ -1,
Gecko: navigator.userAgent.indexOf('Gecko') > -1 && navigator.userAgent.indexOf('KHTML') == -1,
MobileSafari: !!navigator.userAgent.match(/Apple.*Mobile.*Safari/)
},
BrowserFeatures: {
XPath: !!document.evaluate,
ElementExtensions: !!window.HTMLElement,
SpecificElementExtensions:
document.createElement('div').__proto__ &&
document.createElement('div').__proto__ !==
document.createElement('form').__proto__
},
ScriptFragment: ']*>([\\S\\s]*?)<\/script>',
JSONFilter: /^\/\*-secure-([\s\S]*)\*\/\s*$/,
emptyFunction: function() { },
K: function(x) { return x }
};
if (Prototype.Browser.MobileSafari)
Prototype.BrowserFeatures.SpecificElementExtensions = false;
/* Based on Alex Arnell's inheritance implementation. */
var Class = {
create: function() {
var parent = null, properties = $A(arguments);
if (Object.isFunction(properties[0]))
parent = properties.shift();
function klass() {
this.initialize.apply(this, arguments);
}
Object.extend(klass, Class.Methods);
klass.superclass = parent;
klass.subclasses = [];
if (parent) {
var subclass = function() { };
subclass.prototype = parent.prototype;
klass.prototype = new subclass;
parent.subclasses.push(klass);
}
for (var i = 0; i < properties.length; i++)
klass.addMethods(properties[i]);
if (!klass.prototype.initialize)
klass.prototype.initialize = Prototype.emptyFunction;
klass.prototype.constructor = klass;
return klass;
}
};
Class.Methods = {
addMethods: function(source) {
var ancestor = this.superclass && this.superclass.prototype;
var properties = Object.keys(source);
if (!Object.keys({ toString: true }).length)
properties.push("toString", "valueOf");
for (var i = 0, length = properties.length; i < length; i++) {
var property = properties[i], value = source[property];
if (ancestor && Object.isFunction(value) &&
value.argumentNames().first() == "$super") {
var method = value, value = Object.extend((function(m) {
return function() { return ancestor[m].apply(this, arguments) };
})(property).wrap(method), {
valueOf: function() { return method },
toString: function() { return method.toString() }
});
}
this.prototype[property] = value;
}
return this;
}
};
var Abstract = { };
Object.extend = function(destination, source) {
for (var property in source)
destination[property] = source[property];
return destination;
};
Object.extend(Object, {
inspect: function(object) {
try {
if (Object.isUndefined(object)) return 'undefined';
if (object === null) return 'null';
return object.inspect ? object.inspect() : String(object);
} catch (e) {
if (e instanceof RangeError) return '...';
throw e;
}
},
toJSON: function(object) {
var type = typeof object;
switch (type) {
case 'undefined':
case 'function':
case 'unknown': return;
case 'boolean': return object.toString();
}
if (object === null) return 'null';
if (object.toJSON) return object.toJSON();
if (Object.isElement(object)) return;
var results = [];
for (var property in object) {
var value = Object.toJSON(object[property]);
if (!Object.isUndefined(value))
results.push(property.toJSON() + ': ' + value);
}
return '{' + results.join(', ') + '}';
},
toQueryString: function(object) {
return $H(object).toQueryString();
},
toHTML: function(object) {
return object && object.toHTML ? object.toHTML() : String.interpret(object);
},
keys: function(object) {
var keys = [];
for (var property in object)
keys.push(property);
return keys;
},
values: function(object) {
var values = [];
for (var property in object)
values.push(object[property]);
return values;
},
clone: function(object) {
return Object.extend({ }, object);
},
isElement: function(object) {
return object && object.nodeType == 1;
},
isArray: function(object) {
return object != null && typeof object == "object" &&
'splice' in object && 'join' in object;
},
isHash: function(object) {
return object instanceof Hash;
},
isFunction: function(object) {
return typeof object == "function";
},
isString: function(object) {
return typeof object == "string";
},
isNumber: function(object) {
return typeof object == "number";
},
isUndefined: function(object) {
return typeof object == "undefined";
}
});
Object.extend(Function.prototype, {
argumentNames: function() {
var names = this.toString().match(/^[\s\(]*function[^(]*\((.*?)\)/)[1].split(",").invoke("strip");
return names.length == 1 && !names[0] ? [] : names;
},
bind: function() {
if (arguments.length < 2 && Object.isUndefined(arguments[0])) return this;
var __method = this, args = $A(arguments), object = args.shift();
return function() {
return __method.apply(object, args.concat($A(arguments)));
}
},
bindAsEventListener: function() {
var __method = this, args = $A(arguments), object = args.shift();
return function(event) {
return __method.apply(object, [event || window.event].concat(args));
}
},
curry: function() {
if (!arguments.length) return this;
var __method = this, args = $A(arguments);
return function() {
return __method.apply(this, args.concat($A(arguments)));
}
},
delay: function() {
var __method = this, args = $A(arguments), timeout = args.shift() * 1000;
return window.setTimeout(function() {
return __method.apply(__method, args);
}, timeout);
},
wrap: function(wrapper) {
var __method = this;
return function() {
return wrapper.apply(this, [__method.bind(this)].concat($A(arguments)));
}
},
methodize: function() {
if (this._methodized) return this._methodized;
var __method = this;
return this._methodized = function() {
return __method.apply(null, [this].concat($A(arguments)));
};
}
});
Function.prototype.defer = Function.prototype.delay.curry(0.01);
Date.prototype.toJSON = function() {
return '"' + this.getUTCFullYear() + '-' +
(this.getUTCMonth() + 1).toPaddedString(2) + '-' +
this.getUTCDate().toPaddedString(2) + 'T' +
this.getUTCHours().toPaddedString(2) + ':' +
this.getUTCMinutes().toPaddedString(2) + ':' +
this.getUTCSeconds().toPaddedString(2) + 'Z"';
};
var Try = {
these: function() {
var returnValue;
for (var i = 0, length = arguments.length; i < length; i++) {
var lambda = arguments[i];
try {
returnValue = lambda();
break;
} catch (e) { }
}
return returnValue;
}
};
RegExp.prototype.match = RegExp.prototype.test;
RegExp.escape = function(str) {
return String(str).replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1');
};
/*--------------------------------------------------------------------------*/
var PeriodicalExecuter = Class.create({
initialize: function(callback, frequency) {
this.callback = callback;
this.frequency = frequency;
this.currentlyExecuting = false;
this.registerCallback();
},
registerCallback: function() {
this.timer = setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
},
execute: function() {
this.callback(this);
},
stop: function() {
if (!this.timer) return;
clearInterval(this.timer);
this.timer = null;
},
onTimerEvent: function() {
if (!this.currentlyExecuting) {
try {
this.currentlyExecuting = true;
this.execute();
} finally {
this.currentlyExecuting = false;
}
}
}
});
Object.extend(String, {
interpret: function(value) {
return value == null ? '' : String(value);
},
specialChar: {
'\b': '\\b',
'\t': '\\t',
'\n': '\\n',
'\f': '\\f',
'\r': '\\r',
'\\': '\\\\'
}
});
Object.extend(String.prototype, {
gsub: function(pattern, replacement) {
var result = '', source = this, match;
replacement = arguments.callee.prepareReplacement(replacement);
while (source.length > 0) {
if (match = source.match(pattern)) {
result += source.slice(0, match.index);
result += String.interpret(replacement(match));
source = source.slice(match.index + match[0].length);
} else {
result += source, source = '';
}
}
return result;
},
sub: function(pattern, replacement, count) {
replacement = this.gsub.prepareReplacement(replacement);
count = Object.isUndefined(count) ? 1 : count;
return this.gsub(pattern, function(match) {
if (--count < 0) return match[0];
return replacement(match);
});
},
scan: function(pattern, iterator) {
this.gsub(pattern, iterator);
return String(this);
},
truncate: function(length, truncation) {
length = length || 30;
truncation = Object.isUndefined(truncation) ? '...' : truncation;
return this.length > length ?
this.slice(0, length - truncation.length) + truncation : String(this);
},
strip: function() {
return this.replace(/^\s+/, '').replace(/\s+$/, '');
},
stripTags: function() {
return this.replace(/<\/?[^>]+>/gi, '');
},
stripScripts: function() {
return this.replace(new RegExp(Prototype.ScriptFragment, 'img'), '');
},
extractScripts: function() {
var matchAll = new RegExp(Prototype.ScriptFragment, 'img');
var matchOne = new RegExp(Prototype.ScriptFragment, 'im');
return (this.match(matchAll) || []).map(function(scriptTag) {
return (scriptTag.match(matchOne) || ['', ''])[1];
});
},
evalScripts: function() {
return this.extractScripts().map(function(script) { return eval(script) });
},
escapeHTML: function() {
var self = arguments.callee;
self.text.data = this;
return self.div.innerHTML;
},
unescapeHTML: function() {
var div = new Element('div');
div.innerHTML = this.stripTags();
return div.childNodes[0] ? (div.childNodes.length > 1 ?
$A(div.childNodes).inject('', function(memo, node) { return memo+node.nodeValue }) :
div.childNodes[0].nodeValue) : '';
},
toQueryParams: function(separator) {
var match = this.strip().match(/([^?#]*)(#.*)?$/);
if (!match) return { };
return match[1].split(separator || '&').inject({ }, function(hash, pair) {
if ((pair = pair.split('='))[0]) {
var key = decodeURIComponent(pair.shift());
var value = pair.length > 1 ? pair.join('=') : pair[0];
if (value != undefined) value = decodeURIComponent(value);
if (key in hash) {
if (!Object.isArray(hash[key])) hash[key] = [hash[key]];
hash[key].push(value);
}
else hash[key] = value;
}
return hash;
});
},
toArray: function() {
return this.split('');
},
succ: function() {
return this.slice(0, this.length - 1) +
String.fromCharCode(this.charCodeAt(this.length - 1) + 1);
},
times: function(count) {
return count < 1 ? '' : new Array(count + 1).join(this);
},
camelize: function() {
var parts = this.split('-'), len = parts.length;
if (len == 1) return parts[0];
var camelized = this.charAt(0) == '-'
? parts[0].charAt(0).toUpperCase() + parts[0].substring(1)
: parts[0];
for (var i = 1; i < len; i++)
camelized += parts[i].charAt(0).toUpperCase() + parts[i].substring(1);
return camelized;
},
capitalize: function() {
return this.charAt(0).toUpperCase() + this.substring(1).toLowerCase();
},
underscore: function() {
return this.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'#{1}_#{2}').gsub(/([a-z\d])([A-Z])/,'#{1}_#{2}').gsub(/-/,'_').toLowerCase();
},
dasherize: function() {
return this.gsub(/_/,'-');
},
inspect: function(useDoubleQuotes) {
var escapedString = this.gsub(/[\x00-\x1f\\]/, function(match) {
var character = String.specialChar[match[0]];
return character ? character : '\\u00' + match[0].charCodeAt().toPaddedString(2, 16);
});
if (useDoubleQuotes) return '"' + escapedString.replace(/"/g, '\\"') + '"';
return "'" + escapedString.replace(/'/g, '\\\'') + "'";
},
toJSON: function() {
return this.inspect(true);
},
unfilterJSON: function(filter) {
return this.sub(filter || Prototype.JSONFilter, '#{1}');
},
isJSON: function() {
var str = this;
if (str.blank()) return false;
str = this.replace(/\\./g, '@').replace(/"[^"\\\n\r]*"/g, '');
return (/^[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]*$/).test(str);
},
evalJSON: function(sanitize) {
var json = this.unfilterJSON();
try {
if (!sanitize || json.isJSON()) return eval('(' + json + ')');
} catch (e) { }
throw new SyntaxError('Badly formed JSON string: ' + this.inspect());
},
include: function(pattern) {
return this.indexOf(pattern) > -1;
},
startsWith: function(pattern) {
return this.indexOf(pattern) === 0;
},
endsWith: function(pattern) {
var d = this.length - pattern.length;
return d >= 0 && this.lastIndexOf(pattern) === d;
},
empty: function() {
return this == '';
},
blank: function() {
return /^\s*$/.test(this);
},
interpolate: function(object, pattern) {
return new Template(this, pattern).evaluate(object);
}
});
if (Prototype.Browser.WebKit || Prototype.Browser.IE) Object.extend(String.prototype, {
escapeHTML: function() {
return this.replace(/&/g,'&').replace(//g,'>');
},
unescapeHTML: function() {
return this.replace(/&/g,'&').replace(/</g,'<').replace(/>/g,'>');
}
});
String.prototype.gsub.prepareReplacement = function(replacement) {
if (Object.isFunction(replacement)) return replacement;
var template = new Template(replacement);
return function(match) { return template.evaluate(match) };
};
String.prototype.parseQuery = String.prototype.toQueryParams;
Object.extend(String.prototype.escapeHTML, {
div: document.createElement('div'),
text: document.createTextNode('')
});
with (String.prototype.escapeHTML) div.appendChild(text);
var Template = Class.create({
initialize: function(template, pattern) {
this.template = template.toString();
this.pattern = pattern || Template.Pattern;
},
evaluate: function(object) {
if (Object.isFunction(object.toTemplateReplacements))
object = object.toTemplateReplacements();
return this.template.gsub(this.pattern, function(match) {
if (object == null) return '';
var before = match[1] || '';
if (before == '\\') return match[2];
var ctx = object, expr = match[3];
var pattern = /^([^.[]+|\[((?:.*?[^\\])?)\])(\.|\[|$)/;
match = pattern.exec(expr);
if (match == null) return before;
while (match != null) {
var comp = match[1].startsWith('[') ? match[2].gsub('\\\\]', ']') : match[1];
ctx = ctx[comp];
if (null == ctx || '' == match[3]) break;
expr = expr.substring('[' == match[3] ? match[1].length : match[0].length);
match = pattern.exec(expr);
}
return before + String.interpret(ctx);
});
}
});
Template.Pattern = /(^|.|\r|\n)(#\{(.*?)\})/;
var $break = { };
var Enumerable = {
each: function(iterator, context) {
var index = 0;
iterator = iterator.bind(context);
try {
this._each(function(value) {
iterator(value, index++);
});
} catch (e) {
if (e != $break) throw e;
}
return this;
},
eachSlice: function(number, iterator, context) {
iterator = iterator ? iterator.bind(context) : Prototype.K;
var index = -number, slices = [], array = this.toArray();
while ((index += number) < array.length)
slices.push(array.slice(index, index+number));
return slices.collect(iterator, context);
},
all: function(iterator, context) {
iterator = iterator ? iterator.bind(context) : Prototype.K;
var result = true;
this.each(function(value, index) {
result = result && !!iterator(value, index);
if (!result) throw $break;
});
return result;
},
any: function(iterator, context) {
iterator = iterator ? iterator.bind(context) : Prototype.K;
var result = false;
this.each(function(value, index) {
if (result = !!iterator(value, index))
throw $break;
});
return result;
},
collect: function(iterator, context) {
iterator = iterator ? iterator.bind(context) : Prototype.K;
var results = [];
this.each(function(value, index) {
results.push(iterator(value, index));
});
return results;
},
detect: function(iterator, context) {
iterator = iterator.bind(context);
var result;
this.each(function(value, index) {
if (iterator(value, index)) {
result = value;
throw $break;
}
});
return result;
},
findAll: function(iterator, context) {
iterator = iterator.bind(context);
var results = [];
this.each(function(value, index) {
if (iterator(value, index))
results.push(value);
});
return results;
},
grep: function(filter, iterator, context) {
iterator = iterator ? iterator.bind(context) : Prototype.K;
var results = [];
if (Object.isString(filter))
filter = new RegExp(filter);
this.each(function(value, index) {
if (filter.match(value))
results.push(iterator(value, index));
});
return results;
},
include: function(object) {
if (Object.isFunction(this.indexOf))
if (this.indexOf(object) != -1) return true;
var found = false;
this.each(function(value) {
if (value == object) {
found = true;
throw $break;
}
});
return found;
},
inGroupsOf: function(number, fillWith) {
fillWith = Object.isUndefined(fillWith) ? null : fillWith;
return this.eachSlice(number, function(slice) {
while(slice.length < number) slice.push(fillWith);
return slice;
});
},
inject: function(memo, iterator, context) {
iterator = iterator.bind(context);
this.each(function(value, index) {
memo = iterator(memo, value, index);
});
return memo;
},
invoke: function(method) {
var args = $A(arguments).slice(1);
return this.map(function(value) {
return value[method].apply(value, args);
});
},
max: function(iterator, context) {
iterator = iterator ? iterator.bind(context) : Prototype.K;
var result;
this.each(function(value, index) {
value = iterator(value, index);
if (result == null || value >= result)
result = value;
});
return result;
},
min: function(iterator, context) {
iterator = iterator ? iterator.bind(context) : Prototype.K;
var result;
this.each(function(value, index) {
value = iterator(value, index);
if (result == null || value < result)
result = value;
});
return result;
},
partition: function(iterator, context) {
iterator = iterator ? iterator.bind(context) : Prototype.K;
var trues = [], falses = [];
this.each(function(value, index) {
(iterator(value, index) ?
trues : falses).push(value);
});
return [trues, falses];
},
pluck: function(property) {
var results = [];
this.each(function(value) {
results.push(value[property]);
});
return results;
},
reject: function(iterator, context) {
iterator = iterator.bind(context);
var results = [];
this.each(function(value, index) {
if (!iterator(value, index))
results.push(value);
});
return results;
},
sortBy: function(iterator, context) {
iterator = iterator.bind(context);
return this.map(function(value, index) {
return {value: value, criteria: iterator(value, index)};
}).sort(function(left, right) {
var a = left.criteria, b = right.criteria;
return a < b ? -1 : a > b ? 1 : 0;
}).pluck('value');
},
toArray: function() {
return this.map();
},
zip: function() {
var iterator = Prototype.K, args = $A(arguments);
if (Object.isFunction(args.last()))
iterator = args.pop();
var collections = [this].concat(args).map($A);
return this.map(function(value, index) {
return iterator(collections.pluck(index));
});
},
size: function() {
return this.toArray().length;
},
inspect: function() {
return '#';
}
};
Object.extend(Enumerable, {
map: Enumerable.collect,
find: Enumerable.detect,
select: Enumerable.findAll,
filter: Enumerable.findAll,
member: Enumerable.include,
entries: Enumerable.toArray,
every: Enumerable.all,
some: Enumerable.any
});
function $A(iterable) {
if (!iterable) return [];
if (iterable.toArray) return iterable.toArray();
var length = iterable.length || 0, results = new Array(length);
while (length--) results[length] = iterable[length];
return results;
}
if (Prototype.Browser.WebKit) {
$A = function(iterable) {
if (!iterable) return [];
if (!(Object.isFunction(iterable) && iterable == '[object NodeList]') &&
iterable.toArray) return iterable.toArray();
var length = iterable.length || 0, results = new Array(length);
while (length--) results[length] = iterable[length];
return results;
};
}
Array.from = $A;
Object.extend(Array.prototype, Enumerable);
if (!Array.prototype._reverse) Array.prototype._reverse = Array.prototype.reverse;
Object.extend(Array.prototype, {
_each: function(iterator) {
for (var i = 0, length = this.length; i < length; i++)
iterator(this[i]);
},
clear: function() {
this.length = 0;
return this;
},
first: function() {
return this[0];
},
last: function() {
return this[this.length - 1];
},
compact: function() {
return this.select(function(value) {
return value != null;
});
},
flatten: function() {
return this.inject([], function(array, value) {
return array.concat(Object.isArray(value) ?
value.flatten() : [value]);
});
},
without: function() {
var values = $A(arguments);
return this.select(function(value) {
return !values.include(value);
});
},
reverse: function(inline) {
return (inline !== false ? this : this.toArray())._reverse();
},
reduce: function() {
return this.length > 1 ? this : this[0];
},
uniq: function(sorted) {
return this.inject([], function(array, value, index) {
if (0 == index || (sorted ? array.last() != value : !array.include(value)))
array.push(value);
return array;
});
},
intersect: function(array) {
return this.uniq().findAll(function(item) {
return array.detect(function(value) { return item === value });
});
},
clone: function() {
return [].concat(this);
},
size: function() {
return this.length;
},
inspect: function() {
return '[' + this.map(Object.inspect).join(', ') + ']';
},
toJSON: function() {
var results = [];
this.each(function(object) {
var value = Object.toJSON(object);
if (!Object.isUndefined(value)) results.push(value);
});
return '[' + results.join(', ') + ']';
}
});
// use native browser JS 1.6 implementation if available
if (Object.isFunction(Array.prototype.forEach))
Array.prototype._each = Array.prototype.forEach;
if (!Array.prototype.indexOf) Array.prototype.indexOf = function(item, i) {
i || (i = 0);
var length = this.length;
if (i < 0) i = length + i;
for (; i < length; i++)
if (this[i] === item) return i;
return -1;
};
if (!Array.prototype.lastIndexOf) Array.prototype.lastIndexOf = function(item, i) {
i = isNaN(i) ? this.length : (i < 0 ? this.length + i : i) + 1;
var n = this.slice(0, i).reverse().indexOf(item);
return (n < 0) ? n : i - n - 1;
};
Array.prototype.toArray = Array.prototype.clone;
function $w(string) {
if (!Object.isString(string)) return [];
string = string.strip();
return string ? string.split(/\s+/) : [];
}
if (Prototype.Browser.Opera){
Array.prototype.concat = function() {
var array = [];
for (var i = 0, length = this.length; i < length; i++) array.push(this[i]);
for (var i = 0, length = arguments.length; i < length; i++) {
if (Object.isArray(arguments[i])) {
for (var j = 0, arrayLength = arguments[i].length; j < arrayLength; j++)
array.push(arguments[i][j]);
} else {
array.push(arguments[i]);
}
}
return array;
};
}
Object.extend(Number.prototype, {
toColorPart: function() {
return this.toPaddedString(2, 16);
},
succ: function() {
return this + 1;
},
times: function(iterator) {
$R(0, this, true).each(iterator);
return this;
},
toPaddedString: function(length, radix) {
var string = this.toString(radix || 10);
return '0'.times(length - string.length) + string;
},
toJSON: function() {
return isFinite(this) ? this.toString() : 'null';
}
});
$w('abs round ceil floor').each(function(method){
Number.prototype[method] = Math[method].methodize();
});
function $H(object) {
return new Hash(object);
};
var Hash = Class.create(Enumerable, (function() {
function toQueryPair(key, value) {
if (Object.isUndefined(value)) return key;
return key + '=' + encodeURIComponent(String.interpret(value));
}
return {
initialize: function(object) {
this._object = Object.isHash(object) ? object.toObject() : Object.clone(object);
},
_each: function(iterator) {
for (var key in this._object) {
var value = this._object[key], pair = [key, value];
pair.key = key;
pair.value = value;
iterator(pair);
}
},
set: function(key, value) {
return this._object[key] = value;
},
get: function(key) {
return this._object[key];
},
unset: function(key) {
var value = this._object[key];
delete this._object[key];
return value;
},
toObject: function() {
return Object.clone(this._object);
},
keys: function() {
return this.pluck('key');
},
values: function() {
return this.pluck('value');
},
index: function(value) {
var match = this.detect(function(pair) {
return pair.value === value;
});
return match && match.key;
},
merge: function(object) {
return this.clone().update(object);
},
update: function(object) {
return new Hash(object).inject(this, function(result, pair) {
result.set(pair.key, pair.value);
return result;
});
},
toQueryString: function() {
return this.map(function(pair) {
var key = encodeURIComponent(pair.key), values = pair.value;
if (values && typeof values == 'object') {
if (Object.isArray(values))
return values.map(toQueryPair.curry(key)).join('&');
}
return toQueryPair(key, values);
}).join('&');
},
inspect: function() {
return '#';
},
toJSON: function() {
return Object.toJSON(this.toObject());
},
clone: function() {
return new Hash(this);
}
}
})());
Hash.prototype.toTemplateReplacements = Hash.prototype.toObject;
Hash.from = $H;
var ObjectRange = Class.create(Enumerable, {
initialize: function(start, end, exclusive) {
this.start = start;
this.end = end;
this.exclusive = exclusive;
},
_each: function(iterator) {
var value = this.start;
while (this.include(value)) {
iterator(value);
value = value.succ();
}
},
include: function(value) {
if (value < this.start)
return false;
if (this.exclusive)
return value < this.end;
return value <= this.end;
}
});
var $R = function(start, end, exclusive) {
return new ObjectRange(start, end, exclusive);
};
var Ajax = {
getTransport: function() {
return Try.these(
function() {return new XMLHttpRequest()},
function() {return new ActiveXObject('Msxml2.XMLHTTP')},
function() {return new ActiveXObject('Microsoft.XMLHTTP')}
) || false;
},
activeRequestCount: 0
};
Ajax.Responders = {
responders: [],
_each: function(iterator) {
this.responders._each(iterator);
},
register: function(responder) {
if (!this.include(responder))
this.responders.push(responder);
},
unregister: function(responder) {
this.responders = this.responders.without(responder);
},
dispatch: function(callback, request, transport, json) {
this.each(function(responder) {
if (Object.isFunction(responder[callback])) {
try {
responder[callback].apply(responder, [request, transport, json]);
} catch (e) { }
}
});
}
};
Object.extend(Ajax.Responders, Enumerable);
Ajax.Responders.register({
onCreate: function() { Ajax.activeRequestCount++ },
onComplete: function() { Ajax.activeRequestCount-- }
});
Ajax.Base = Class.create({
initialize: function(options) {
this.options = {
method: 'post',
asynchronous: true,
contentType: 'application/x-www-form-urlencoded',
encoding: 'UTF-8',
parameters: '',
evalJSON: true,
evalJS: true
};
Object.extend(this.options, options || { });
this.options.method = this.options.method.toLowerCase();
if (Object.isString(this.options.parameters))
this.options.parameters = this.options.parameters.toQueryParams();
else if (Object.isHash(this.options.parameters))
this.options.parameters = this.options.parameters.toObject();
}
});
Ajax.Request = Class.create(Ajax.Base, {
_complete: false,
initialize: function($super, url, options) {
$super(options);
this.transport = Ajax.getTransport();
this.request(url);
},
request: function(url) {
this.url = url;
this.method = this.options.method;
var params = Object.clone(this.options.parameters);
if (!['get', 'post'].include(this.method)) {
// simulate other verbs over post
params['_method'] = this.method;
this.method = 'post';
}
this.parameters = params;
if (params = Object.toQueryString(params)) {
// when GET, append parameters to URL
if (this.method == 'get')
this.url += (this.url.include('?') ? '&' : '?') + params;
else if (/Konqueror|Safari|KHTML/.test(navigator.userAgent))
params += '&_=';
}
try {
var response = new Ajax.Response(this);
if (this.options.onCreate) this.options.onCreate(response);
Ajax.Responders.dispatch('onCreate', this, response);
this.transport.open(this.method.toUpperCase(), this.url,
this.options.asynchronous);
if (this.options.asynchronous) this.respondToReadyState.bind(this).defer(1);
this.transport.onreadystatechange = this.onStateChange.bind(this);
this.setRequestHeaders();
this.body = this.method == 'post' ? (this.options.postBody || params) : null;
this.transport.send(this.body);
/* Force Firefox to handle ready state 4 for synchronous requests */
if (!this.options.asynchronous && this.transport.overrideMimeType)
this.onStateChange();
}
catch (e) {
this.dispatchException(e);
}
},
onStateChange: function() {
var readyState = this.transport.readyState;
if (readyState > 1 && !((readyState == 4) && this._complete))
this.respondToReadyState(this.transport.readyState);
},
setRequestHeaders: function() {
var headers = {
'X-Requested-With': 'XMLHttpRequest',
'X-Prototype-Version': Prototype.Version,
'Accept': 'text/javascript, text/html, application/xml, text/xml, */*'
};
if (this.method == 'post') {
headers['Content-type'] = this.options.contentType +
(this.options.encoding ? '; charset=' + this.options.encoding : '');
/* Force "Connection: close" for older Mozilla browsers to work
* around a bug where XMLHttpRequest sends an incorrect
* Content-length header. See Mozilla Bugzilla #246651.
*/
if (this.transport.overrideMimeType &&
(navigator.userAgent.match(/Gecko\/(\d{4})/) || [0,2005])[1] < 2005)
headers['Connection'] = 'close';
}
// user-defined headers
if (typeof this.options.requestHeaders == 'object') {
var extras = this.options.requestHeaders;
if (Object.isFunction(extras.push))
for (var i = 0, length = extras.length; i < length; i += 2)
headers[extras[i]] = extras[i+1];
else
$H(extras).each(function(pair) { headers[pair.key] = pair.value });
}
for (var name in headers)
this.transport.setRequestHeader(name, headers[name]);
},
success: function() {
var status = this.getStatus();
return !status || (status >= 200 && status < 300);
},
getStatus: function() {
try {
return this.transport.status || 0;
} catch (e) { return 0 }
},
respondToReadyState: function(readyState) {
var state = Ajax.Request.Events[readyState], response = new Ajax.Response(this);
if (state == 'Complete') {
try {
this._complete = true;
(this.options['on' + response.status]
|| this.options['on' + (this.success() ? 'Success' : 'Failure')]
|| Prototype.emptyFunction)(response, response.headerJSON);
} catch (e) {
this.dispatchException(e);
}
var contentType = response.getHeader('Content-type');
if (this.options.evalJS == 'force'
|| (this.options.evalJS && this.isSameOrigin() && contentType
&& contentType.match(/^\s*(text|application)\/(x-)?(java|ecma)script(;.*)?\s*$/i)))
this.evalResponse();
}
try {
(this.options['on' + state] || Prototype.emptyFunction)(response, response.headerJSON);
Ajax.Responders.dispatch('on' + state, this, response, response.headerJSON);
} catch (e) {
this.dispatchException(e);
}
if (state == 'Complete') {
// avoid memory leak in MSIE: clean up
this.transport.onreadystatechange = Prototype.emptyFunction;
}
},
isSameOrigin: function() {
var m = this.url.match(/^\s*https?:\/\/[^\/]*/);
return !m || (m[0] == '#{protocol}//#{domain}#{port}'.interpolate({
protocol: location.protocol,
domain: document.domain,
port: location.port ? ':' + location.port : ''
}));
},
getHeader: function(name) {
try {
return this.transport.getResponseHeader(name) || null;
} catch (e) { return null }
},
evalResponse: function() {
try {
return eval((this.transport.responseText || '').unfilterJSON());
} catch (e) {
this.dispatchException(e);
}
},
dispatchException: function(exception) {
(this.options.onException || Prototype.emptyFunction)(this, exception);
Ajax.Responders.dispatch('onException', this, exception);
}
});
Ajax.Request.Events =
['Uninitialized', 'Loading', 'Loaded', 'Interactive', 'Complete'];
Ajax.Response = Class.create({
initialize: function(request){
this.request = request;
var transport = this.transport = request.transport,
readyState = this.readyState = transport.readyState;
if((readyState > 2 && !Prototype.Browser.IE) || readyState == 4) {
this.status = this.getStatus();
this.statusText = this.getStatusText();
this.responseText = String.interpret(transport.responseText);
this.headerJSON = this._getHeaderJSON();
}
if(readyState == 4) {
var xml = transport.responseXML;
this.responseXML = Object.isUndefined(xml) ? null : xml;
this.responseJSON = this._getResponseJSON();
}
},
status: 0,
statusText: '',
getStatus: Ajax.Request.prototype.getStatus,
getStatusText: function() {
try {
return this.transport.statusText || '';
} catch (e) { return '' }
},
getHeader: Ajax.Request.prototype.getHeader,
getAllHeaders: function() {
try {
return this.getAllResponseHeaders();
} catch (e) { return null }
},
getResponseHeader: function(name) {
return this.transport.getResponseHeader(name);
},
getAllResponseHeaders: function() {
return this.transport.getAllResponseHeaders();
},
_getHeaderJSON: function() {
var json = this.getHeader('X-JSON');
if (!json) return null;
json = decodeURIComponent(escape(json));
try {
return json.evalJSON(this.request.options.sanitizeJSON ||
!this.request.isSameOrigin());
} catch (e) {
this.request.dispatchException(e);
}
},
_getResponseJSON: function() {
var options = this.request.options;
if (!options.evalJSON || (options.evalJSON != 'force' &&
!(this.getHeader('Content-type') || '').include('application/json')) ||
this.responseText.blank())
return null;
try {
return this.responseText.evalJSON(options.sanitizeJSON ||
!this.request.isSameOrigin());
} catch (e) {
this.request.dispatchException(e);
}
}
});
Ajax.Updater = Class.create(Ajax.Request, {
initialize: function($super, container, url, options) {
this.container = {
success: (container.success || container),
failure: (container.failure || (container.success ? null : container))
};
options = Object.clone(options);
var onComplete = options.onComplete;
options.onComplete = (function(response, json) {
this.updateContent(response.responseText);
if (Object.isFunction(onComplete)) onComplete(response, json);
}).bind(this);
$super(url, options);
},
updateContent: function(responseText) {
var receiver = this.container[this.success() ? 'success' : 'failure'],
options = this.options;
if (!options.evalScripts) responseText = responseText.stripScripts();
if (receiver = $(receiver)) {
if (options.insertion) {
if (Object.isString(options.insertion)) {
var insertion = { }; insertion[options.insertion] = responseText;
receiver.insert(insertion);
}
else options.insertion(receiver, responseText);
}
else receiver.update(responseText);
}
}
});
Ajax.PeriodicalUpdater = Class.create(Ajax.Base, {
initialize: function($super, container, url, options) {
$super(options);
this.onComplete = this.options.onComplete;
this.frequency = (this.options.frequency || 2);
this.decay = (this.options.decay || 1);
this.updater = { };
this.container = container;
this.url = url;
this.start();
},
start: function() {
this.options.onComplete = this.updateComplete.bind(this);
this.onTimerEvent();
},
stop: function() {
this.updater.options.onComplete = undefined;
clearTimeout(this.timer);
(this.onComplete || Prototype.emptyFunction).apply(this, arguments);
},
updateComplete: function(response) {
if (this.options.decay) {
this.decay = (response.responseText == this.lastText ?
this.decay * this.options.decay : 1);
this.lastText = response.responseText;
}
this.timer = this.onTimerEvent.bind(this).delay(this.decay * this.frequency);
},
onTimerEvent: function() {
this.updater = new Ajax.Updater(this.container, this.url, this.options);
}
});
function $(element) {
if (arguments.length > 1) {
for (var i = 0, elements = [], length = arguments.length; i < length; i++)
elements.push($(arguments[i]));
return elements;
}
if (Object.isString(element))
element = document.getElementById(element);
return Element.extend(element);
}
if (Prototype.BrowserFeatures.XPath) {
document._getElementsByXPath = function(expression, parentElement) {
var results = [];
var query = document.evaluate(expression, $(parentElement) || document,
null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
for (var i = 0, length = query.snapshotLength; i < length; i++)
results.push(Element.extend(query.snapshotItem(i)));
return results;
};
}
/*--------------------------------------------------------------------------*/
if (!window.Node) var Node = { };
if (!Node.ELEMENT_NODE) {
// DOM level 2 ECMAScript Language Binding
Object.extend(Node, {
ELEMENT_NODE: 1,
ATTRIBUTE_NODE: 2,
TEXT_NODE: 3,
CDATA_SECTION_NODE: 4,
ENTITY_REFERENCE_NODE: 5,
ENTITY_NODE: 6,
PROCESSING_INSTRUCTION_NODE: 7,
COMMENT_NODE: 8,
DOCUMENT_NODE: 9,
DOCUMENT_TYPE_NODE: 10,
DOCUMENT_FRAGMENT_NODE: 11,
NOTATION_NODE: 12
});
}
(function() {
var element = this.Element;
this.Element = function(tagName, attributes) {
attributes = attributes || { };
tagName = tagName.toLowerCase();
var cache = Element.cache;
if (Prototype.Browser.IE && attributes.name) {
tagName = '<' + tagName + ' name="' + attributes.name + '">';
delete attributes.name;
return Element.writeAttribute(document.createElement(tagName), attributes);
}
if (!cache[tagName]) cache[tagName] = Element.extend(document.createElement(tagName));
return Element.writeAttribute(cache[tagName].cloneNode(false), attributes);
};
Object.extend(this.Element, element || { });
}).call(window);
Element.cache = { };
Element.Methods = {
visible: function(element) {
return $(element).style.display != 'none';
},
toggle: function(element) {
element = $(element);
Element[Element.visible(element) ? 'hide' : 'show'](element);
return element;
},
hide: function(element) {
$(element).style.display = 'none';
return element;
},
show: function(element) {
$(element).style.display = '';
return element;
},
remove: function(element) {
element = $(element);
element.parentNode.removeChild(element);
return element;
},
update: function(element, content) {
element = $(element);
if (content && content.toElement) content = content.toElement();
if (Object.isElement(content)) return element.update().insert(content);
content = Object.toHTML(content);
element.innerHTML = content.stripScripts();
content.evalScripts.bind(content).defer();
return element;
},
replace: function(element, content) {
element = $(element);
if (content && content.toElement) content = content.toElement();
else if (!Object.isElement(content)) {
content = Object.toHTML(content);
var range = element.ownerDocument.createRange();
range.selectNode(element);
content.evalScripts.bind(content).defer();
content = range.createContextualFragment(content.stripScripts());
}
element.parentNode.replaceChild(content, element);
return element;
},
insert: function(element, insertions) {
element = $(element);
if (Object.isString(insertions) || Object.isNumber(insertions) ||
Object.isElement(insertions) || (insertions && (insertions.toElement || insertions.toHTML)))
insertions = {bottom:insertions};
var content, insert, tagName, childNodes;
for (var position in insertions) {
content = insertions[position];
position = position.toLowerCase();
insert = Element._insertionTranslations[position];
if (content && content.toElement) content = content.toElement();
if (Object.isElement(content)) {
insert(element, content);
continue;
}
content = Object.toHTML(content);
tagName = ((position == 'before' || position == 'after')
? element.parentNode : element).tagName.toUpperCase();
childNodes = Element._getContentFromAnonymousElement(tagName, content.stripScripts());
if (position == 'top' || position == 'after') childNodes.reverse();
childNodes.each(insert.curry(element));
content.evalScripts.bind(content).defer();
}
return element;
},
wrap: function(element, wrapper, attributes) {
element = $(element);
if (Object.isElement(wrapper))
$(wrapper).writeAttribute(attributes || { });
else if (Object.isString(wrapper)) wrapper = new Element(wrapper, attributes);
else wrapper = new Element('div', wrapper);
if (element.parentNode)
element.parentNode.replaceChild(wrapper, element);
wrapper.appendChild(element);
return wrapper;
},
inspect: function(element) {
element = $(element);
var result = '<' + element.tagName.toLowerCase();
$H({'id': 'id', 'className': 'class'}).each(function(pair) {
var property = pair.first(), attribute = pair.last();
var value = (element[property] || '').toString();
if (value) result += ' ' + attribute + '=' + value.inspect(true);
});
return result + '>';
},
recursivelyCollect: function(element, property) {
element = $(element);
var elements = [];
while (element = element[property])
if (element.nodeType == 1)
elements.push(Element.extend(element));
return elements;
},
ancestors: function(element) {
return $(element).recursivelyCollect('parentNode');
},
descendants: function(element) {
return $(element).select("*");
},
firstDescendant: function(element) {
element = $(element).firstChild;
while (element && element.nodeType != 1) element = element.nextSibling;
return $(element);
},
immediateDescendants: function(element) {
if (!(element = $(element).firstChild)) return [];
while (element && element.nodeType != 1) element = element.nextSibling;
if (element) return [element].concat($(element).nextSiblings());
return [];
},
previousSiblings: function(element) {
return $(element).recursivelyCollect('previousSibling');
},
nextSiblings: function(element) {
return $(element).recursivelyCollect('nextSibling');
},
siblings: function(element) {
element = $(element);
return element.previousSiblings().reverse().concat(element.nextSiblings());
},
match: function(element, selector) {
if (Object.isString(selector))
selector = new Selector(selector);
return selector.match($(element));
},
up: function(element, expression, index) {
element = $(element);
if (arguments.length == 1) return $(element.parentNode);
var ancestors = element.ancestors();
return Object.isNumber(expression) ? ancestors[expression] :
Selector.findElement(ancestors, expression, index);
},
down: function(element, expression, index) {
element = $(element);
if (arguments.length == 1) return element.firstDescendant();
return Object.isNumber(expression) ? element.descendants()[expression] :
element.select(expression)[index || 0];
},
previous: function(element, expression, index) {
element = $(element);
if (arguments.length == 1) return $(Selector.handlers.previousElementSibling(element));
var previousSiblings = element.previousSiblings();
return Object.isNumber(expression) ? previousSiblings[expression] :
Selector.findElement(previousSiblings, expression, index);
},
next: function(element, expression, index) {
element = $(element);
if (arguments.length == 1) return $(Selector.handlers.nextElementSibling(element));
var nextSiblings = element.nextSiblings();
return Object.isNumber(expression) ? nextSiblings[expression] :
Selector.findElement(nextSiblings, expression, index);
},
select: function() {
var args = $A(arguments), element = $(args.shift());
return Selector.findChildElements(element, args);
},
adjacent: function() {
var args = $A(arguments), element = $(args.shift());
return Selector.findChildElements(element.parentNode, args).without(element);
},
identify: function(element) {
element = $(element);
var id = element.readAttribute('id'), self = arguments.callee;
if (id) return id;
do { id = 'anonymous_element_' + self.counter++ } while ($(id));
element.writeAttribute('id', id);
return id;
},
readAttribute: function(element, name) {
element = $(element);
if (Prototype.Browser.IE) {
var t = Element._attributeTranslations.read;
if (t.values[name]) return t.values[name](element, name);
if (t.names[name]) name = t.names[name];
if (name.include(':')) {
return (!element.attributes || !element.attributes[name]) ? null :
element.attributes[name].value;
}
}
return element.getAttribute(name);
},
writeAttribute: function(element, name, value) {
element = $(element);
var attributes = { }, t = Element._attributeTranslations.write;
if (typeof name == 'object') attributes = name;
else attributes[name] = Object.isUndefined(value) ? true : value;
for (var attr in attributes) {
name = t.names[attr] || attr;
value = attributes[attr];
if (t.values[attr]) name = t.values[attr](element, value);
if (value === false || value === null)
element.removeAttribute(name);
else if (value === true)
element.setAttribute(name, name);
else element.setAttribute(name, value);
}
return element;
},
getHeight: function(element) {
return $(element).getDimensions().height;
},
getWidth: function(element) {
return $(element).getDimensions().width;
},
classNames: function(element) {
return new Element.ClassNames(element);
},
hasClassName: function(element, className) {
if (!(element = $(element))) return;
var elementClassName = element.className;
return (elementClassName.length > 0 && (elementClassName == className ||
new RegExp("(^|\\s)" + className + "(\\s|$)").test(elementClassName)));
},
addClassName: function(element, className) {
if (!(element = $(element))) return;
if (!element.hasClassName(className))
element.className += (element.className ? ' ' : '') + className;
return element;
},
removeClassName: function(element, className) {
if (!(element = $(element))) return;
element.className = element.className.replace(
new RegExp("(^|\\s+)" + className + "(\\s+|$)"), ' ').strip();
return element;
},
toggleClassName: function(element, className) {
if (!(element = $(element))) return;
return element[element.hasClassName(className) ?
'removeClassName' : 'addClassName'](className);
},
// removes whitespace-only text node children
cleanWhitespace: function(element) {
element = $(element);
var node = element.firstChild;
while (node) {
var nextNode = node.nextSibling;
if (node.nodeType == 3 && !/\S/.test(node.nodeValue))
element.removeChild(node);
node = nextNode;
}
return element;
},
empty: function(element) {
return $(element).innerHTML.blank();
},
descendantOf: function(element, ancestor) {
element = $(element), ancestor = $(ancestor);
var originalAncestor = ancestor;
if (element.compareDocumentPosition)
return (element.compareDocumentPosition(ancestor) & 8) === 8;
if (element.sourceIndex && !Prototype.Browser.Opera) {
var e = element.sourceIndex, a = ancestor.sourceIndex,
nextAncestor = ancestor.nextSibling;
if (!nextAncestor) {
do { ancestor = ancestor.parentNode; }
while (!(nextAncestor = ancestor.nextSibling) && ancestor.parentNode);
}
if (nextAncestor && nextAncestor.sourceIndex)
return (e > a && e < nextAncestor.sourceIndex);
}
while (element = element.parentNode)
if (element == originalAncestor) return true;
return false;
},
scrollTo: function(element) {
element = $(element);
var pos = element.cumulativeOffset();
window.scrollTo(pos[0], pos[1]);
return element;
},
getStyle: function(element, style) {
element = $(element);
style = style == 'float' ? 'cssFloat' : style.camelize();
var value = element.style[style];
if (!value) {
var css = document.defaultView.getComputedStyle(element, null);
value = css ? css[style] : null;
}
if (style == 'opacity') return value ? parseFloat(value) : 1.0;
return value == 'auto' ? null : value;
},
getOpacity: function(element) {
return $(element).getStyle('opacity');
},
setStyle: function(element, styles) {
element = $(element);
var elementStyle = element.style, match;
if (Object.isString(styles)) {
element.style.cssText += ';' + styles;
return styles.include('opacity') ?
element.setOpacity(styles.match(/opacity:\s*(\d?\.?\d*)/)[1]) : element;
}
for (var property in styles)
if (property == 'opacity') element.setOpacity(styles[property]);
else
elementStyle[(property == 'float' || property == 'cssFloat') ?
(Object.isUndefined(elementStyle.styleFloat) ? 'cssFloat' : 'styleFloat') :
property] = styles[property];
return element;
},
setOpacity: function(element, value) {
element = $(element);
element.style.opacity = (value == 1 || value === '') ? '' :
(value < 0.00001) ? 0 : value;
return element;
},
getDimensions: function(element) {
element = $(element);
var display = $(element).getStyle('display');
if (display != 'none' && display != null) // Safari bug
return {width: element.offsetWidth, height: element.offsetHeight};
// All *Width and *Height properties give 0 on elements with display none,
// so enable the element temporarily
var els = element.style;
var originalVisibility = els.visibility;
var originalPosition = els.position;
var originalDisplay = els.display;
els.visibility = 'hidden';
els.position = 'absolute';
els.display = 'block';
var originalWidth = element.clientWidth;
var originalHeight = element.clientHeight;
els.display = originalDisplay;
els.position = originalPosition;
els.visibility = originalVisibility;
return {width: originalWidth, height: originalHeight};
},
makePositioned: function(element) {
element = $(element);
var pos = Element.getStyle(element, 'position');
if (pos == 'static' || !pos) {
element._madePositioned = true;
element.style.position = 'relative';
// Opera returns the offset relative to the positioning context, when an
// element is position relative but top and left have not been defined
if (window.opera) {
element.style.top = 0;
element.style.left = 0;
}
}
return element;
},
undoPositioned: function(element) {
element = $(element);
if (element._madePositioned) {
element._madePositioned = undefined;
element.style.position =
element.style.top =
element.style.left =
element.style.bottom =
element.style.right = '';
}
return element;
},
makeClipping: function(element) {
element = $(element);
if (element._overflow) return element;
element._overflow = Element.getStyle(element, 'overflow') || 'auto';
if (element._overflow !== 'hidden')
element.style.overflow = 'hidden';
return element;
},
undoClipping: function(element) {
element = $(element);
if (!element._overflow) return element;
element.style.overflow = element._overflow == 'auto' ? '' : element._overflow;
element._overflow = null;
return element;
},
cumulativeOffset: function(element) {
var valueT = 0, valueL = 0;
do {
valueT += element.offsetTop || 0;
valueL += element.offsetLeft || 0;
element = element.offsetParent;
} while (element);
return Element._returnOffset(valueL, valueT);
},
positionedOffset: function(element) {
var valueT = 0, valueL = 0;
do {
valueT += element.offsetTop || 0;
valueL += element.offsetLeft || 0;
element = element.offsetParent;
if (element) {
if (element.tagName == 'BODY') break;
var p = Element.getStyle(element, 'position');
if (p !== 'static') break;
}
} while (element);
return Element._returnOffset(valueL, valueT);
},
absolutize: function(element) {
element = $(element);
if (element.getStyle('position') == 'absolute') return;
// Position.prepare(); // To be done manually by Scripty when it needs it.
var offsets = element.positionedOffset();
var top = offsets[1];
var left = offsets[0];
var width = element.clientWidth;
var height = element.clientHeight;
element._originalLeft = left - parseFloat(element.style.left || 0);
element._originalTop = top - parseFloat(element.style.top || 0);
element._originalWidth = element.style.width;
element._originalHeight = element.style.height;
element.style.position = 'absolute';
element.style.top = top + 'px';
element.style.left = left + 'px';
element.style.width = width + 'px';
element.style.height = height + 'px';
return element;
},
relativize: function(element) {
element = $(element);
if (element.getStyle('position') == 'relative') return;
// Position.prepare(); // To be done manually by Scripty when it needs it.
element.style.position = 'relative';
var top = parseFloat(element.style.top || 0) - (element._originalTop || 0);
var left = parseFloat(element.style.left || 0) - (element._originalLeft || 0);
element.style.top = top + 'px';
element.style.left = left + 'px';
element.style.height = element._originalHeight;
element.style.width = element._originalWidth;
return element;
},
cumulativeScrollOffset: function(element) {
var valueT = 0, valueL = 0;
do {
valueT += element.scrollTop || 0;
valueL += element.scrollLeft || 0;
element = element.parentNode;
} while (element);
return Element._returnOffset(valueL, valueT);
},
getOffsetParent: function(element) {
if (element.offsetParent) return $(element.offsetParent);
if (element == document.body) return $(element);
while ((element = element.parentNode) && element != document.body)
if (Element.getStyle(element, 'position') != 'static')
return $(element);
return $(document.body);
},
viewportOffset: function(forElement) {
var valueT = 0, valueL = 0;
var element = forElement;
do {
valueT += element.offsetTop || 0;
valueL += element.offsetLeft || 0;
// Safari fix
if (element.offsetParent == document.body &&
Element.getStyle(element, 'position') == 'absolute') break;
} while (element = element.offsetParent);
element = forElement;
do {
if (!Prototype.Browser.Opera || element.tagName == 'BODY') {
valueT -= element.scrollTop || 0;
valueL -= element.scrollLeft || 0;
}
} while (element = element.parentNode);
return Element._returnOffset(valueL, valueT);
},
clonePosition: function(element, source) {
var options = Object.extend({
setLeft: true,
setTop: true,
setWidth: true,
setHeight: true,
offsetTop: 0,
offsetLeft: 0
}, arguments[2] || { });
// find page position of source
source = $(source);
var p = source.viewportOffset();
// find coordinate system to use
element = $(element);
var delta = [0, 0];
var parent = null;
// delta [0,0] will do fine with position: fixed elements,
// position:absolute needs offsetParent deltas
if (Element.getStyle(element, 'position') == 'absolute') {
parent = element.getOffsetParent();
delta = parent.viewportOffset();
}
// correct by body offsets (fixes Safari)
if (parent == document.body) {
delta[0] -= document.body.offsetLeft;
delta[1] -= document.body.offsetTop;
}
// set position
if (options.setLeft) element.style.left = (p[0] - delta[0] + options.offsetLeft) + 'px';
if (options.setTop) element.style.top = (p[1] - delta[1] + options.offsetTop) + 'px';
if (options.setWidth) element.style.width = source.offsetWidth + 'px';
if (options.setHeight) element.style.height = source.offsetHeight + 'px';
return element;
}
};
Element.Methods.identify.counter = 1;
Object.extend(Element.Methods, {
getElementsBySelector: Element.Methods.select,
childElements: Element.Methods.immediateDescendants
});
Element._attributeTranslations = {
write: {
names: {
className: 'class',
htmlFor: 'for'
},
values: { }
}
};
if (Prototype.Browser.Opera) {
Element.Methods.getStyle = Element.Methods.getStyle.wrap(
function(proceed, element, style) {
switch (style) {
case 'left': case 'top': case 'right': case 'bottom':
if (proceed(element, 'position') === 'static') return null;
case 'height': case 'width':
// returns '0px' for hidden elements; we want it to return null
if (!Element.visible(element)) return null;
// returns the border-box dimensions rather than the content-box
// dimensions, so we subtract padding and borders from the value
var dim = parseInt(proceed(element, style), 10);
if (dim !== element['offset' + style.capitalize()])
return dim + 'px';
var properties;
if (style === 'height') {
properties = ['border-top-width', 'padding-top',
'padding-bottom', 'border-bottom-width'];
}
else {
properties = ['border-left-width', 'padding-left',
'padding-right', 'border-right-width'];
}
return properties.inject(dim, function(memo, property) {
var val = proceed(element, property);
return val === null ? memo : memo - parseInt(val, 10);
}) + 'px';
default: return proceed(element, style);
}
}
);
Element.Methods.readAttribute = Element.Methods.readAttribute.wrap(
function(proceed, element, attribute) {
if (attribute === 'title') return element.title;
return proceed(element, attribute);
}
);
}
else if (Prototype.Browser.IE) {
// IE doesn't report offsets correctly for static elements, so we change them
// to "relative" to get the values, then change them back.
Element.Methods.getOffsetParent = Element.Methods.getOffsetParent.wrap(
function(proceed, element) {
element = $(element);
var position = element.getStyle('position');
if (position !== 'static') return proceed(element);
element.setStyle({ position: 'relative' });
var value = proceed(element);
element.setStyle({ position: position });
return value;
}
);
$w('positionedOffset viewportOffset').each(function(method) {
Element.Methods[method] = Element.Methods[method].wrap(
function(proceed, element) {
element = $(element);
var position = element.getStyle('position');
if (position !== 'static') return proceed(element);
// Trigger hasLayout on the offset parent so that IE6 reports
// accurate offsetTop and offsetLeft values for position: fixed.
var offsetParent = element.getOffsetParent();
if (offsetParent && offsetParent.getStyle('position') === 'fixed')
offsetParent.setStyle({ zoom: 1 });
element.setStyle({ position: 'relative' });
var value = proceed(element);
element.setStyle({ position: position });
return value;
}
);
});
Element.Methods.getStyle = function(element, style) {
element = $(element);
style = (style == 'float' || style == 'cssFloat') ? 'styleFloat' : style.camelize();
var value = element.style[style];
if (!value && element.currentStyle) value = element.currentStyle[style];
if (style == 'opacity') {
if (value = (element.getStyle('filter') || '').match(/alpha\(opacity=(.*)\)/))
if (value[1]) return parseFloat(value[1]) / 100;
return 1.0;
}
if (value == 'auto') {
if ((style == 'width' || style == 'height') && (element.getStyle('display') != 'none'))
return element['offset' + style.capitalize()] + 'px';
return null;
}
return value;
};
Element.Methods.setOpacity = function(element, value) {
function stripAlpha(filter){
return filter.replace(/alpha\([^\)]*\)/gi,'');
}
element = $(element);
var currentStyle = element.currentStyle;
if ((currentStyle && !currentStyle.hasLayout) ||
(!currentStyle && element.style.zoom == 'normal'))
element.style.zoom = 1;
var filter = element.getStyle('filter'), style = element.style;
if (value == 1 || value === '') {
(filter = stripAlpha(filter)) ?
style.filter = filter : style.removeAttribute('filter');
return element;
} else if (value < 0.00001) value = 0;
style.filter = stripAlpha(filter) +
'alpha(opacity=' + (value * 100) + ')';
return element;
};
Element._attributeTranslations = {
read: {
names: {
'class': 'className',
'for': 'htmlFor'
},
values: {
_getAttr: function(element, attribute) {
return element.getAttribute(attribute, 2);
},
_getAttrNode: function(element, attribute) {
var node = element.getAttributeNode(attribute);
return node ? node.value : "";
},
_getEv: function(element, attribute) {
attribute = element.getAttribute(attribute);
return attribute ? attribute.toString().slice(23, -2) : null;
},
_flag: function(element, attribute) {
return $(element).hasAttribute(attribute) ? attribute : null;
},
style: function(element) {
return element.style.cssText.toLowerCase();
},
title: function(element) {
return element.title;
}
}
}
};
Element._attributeTranslations.write = {
names: Object.extend({
cellpadding: 'cellPadding',
cellspacing: 'cellSpacing'
}, Element._attributeTranslations.read.names),
values: {
checked: function(element, value) {
element.checked = !!value;
},
style: function(element, value) {
element.style.cssText = value ? value : '';
}
}
};
Element._attributeTranslations.has = {};
$w('colSpan rowSpan vAlign dateTime accessKey tabIndex ' +
'encType maxLength readOnly longDesc').each(function(attr) {
Element._attributeTranslations.write.names[attr.toLowerCase()] = attr;
Element._attributeTranslations.has[attr.toLowerCase()] = attr;
});
(function(v) {
Object.extend(v, {
href: v._getAttr,
src: v._getAttr,
type: v._getAttr,
action: v._getAttrNode,
disabled: v._flag,
checked: v._flag,
readonly: v._flag,
multiple: v._flag,
onload: v._getEv,
onunload: v._getEv,
onclick: v._getEv,
ondblclick: v._getEv,
onmousedown: v._getEv,
onmouseup: v._getEv,
onmouseover: v._getEv,
onmousemove: v._getEv,
onmouseout: v._getEv,
onfocus: v._getEv,
onblur: v._getEv,
onkeypress: v._getEv,
onkeydown: v._getEv,
onkeyup: v._getEv,
onsubmit: v._getEv,
onreset: v._getEv,
onselect: v._getEv,
onchange: v._getEv
});
})(Element._attributeTranslations.read.values);
}
else if (Prototype.Browser.Gecko && /rv:1\.8\.0/.test(navigator.userAgent)) {
Element.Methods.setOpacity = function(element, value) {
element = $(element);
element.style.opacity = (value == 1) ? 0.999999 :
(value === '') ? '' : (value < 0.00001) ? 0 : value;
return element;
};
}
else if (Prototype.Browser.WebKit) {
Element.Methods.setOpacity = function(element, value) {
element = $(element);
element.style.opacity = (value == 1 || value === '') ? '' :
(value < 0.00001) ? 0 : value;
if (value == 1)
if(element.tagName == 'IMG' && element.width) {
element.width++; element.width--;
} else try {
var n = document.createTextNode(' ');
element.appendChild(n);
element.removeChild(n);
} catch (e) { }
return element;
};
// Safari returns margins on body which is incorrect if the child is absolutely
// positioned. For performance reasons, redefine Element#cumulativeOffset for
// KHTML/WebKit only.
Element.Methods.cumulativeOffset = function(element) {
var valueT = 0, valueL = 0;
do {
valueT += element.offsetTop || 0;
valueL += element.offsetLeft || 0;
if (element.offsetParent == document.body)
if (Element.getStyle(element, 'position') == 'absolute') break;
element = element.offsetParent;
} while (element);
return Element._returnOffset(valueL, valueT);
};
}
if (Prototype.Browser.IE || Prototype.Browser.Opera) {
// IE and Opera are missing .innerHTML support for TABLE-related and SELECT elements
Element.Methods.update = function(element, content) {
element = $(element);
if (content && content.toElement) content = content.toElement();
if (Object.isElement(content)) return element.update().insert(content);
content = Object.toHTML(content);
var tagName = element.tagName.toUpperCase();
if (tagName in Element._insertionTranslations.tags) {
$A(element.childNodes).each(function(node) { element.removeChild(node) });
Element._getContentFromAnonymousElement(tagName, content.stripScripts())
.each(function(node) { element.appendChild(node) });
}
else element.innerHTML = content.stripScripts();
content.evalScripts.bind(content).defer();
return element;
};
}
if ('outerHTML' in document.createElement('div')) {
Element.Methods.replace = function(element, content) {
element = $(element);
if (content && content.toElement) content = content.toElement();
if (Object.isElement(content)) {
element.parentNode.replaceChild(content, element);
return element;
}
content = Object.toHTML(content);
var parent = element.parentNode, tagName = parent.tagName.toUpperCase();
if (Element._insertionTranslations.tags[tagName]) {
var nextSibling = element.next();
var fragments = Element._getContentFromAnonymousElement(tagName, content.stripScripts());
parent.removeChild(element);
if (nextSibling)
fragments.each(function(node) { parent.insertBefore(node, nextSibling) });
else
fragments.each(function(node) { parent.appendChild(node) });
}
else element.outerHTML = content.stripScripts();
content.evalScripts.bind(content).defer();
return element;
};
}
Element._returnOffset = function(l, t) {
var result = [l, t];
result.left = l;
result.top = t;
return result;
};
Element._getContentFromAnonymousElement = function(tagName, html) {
var div = new Element('div'), t = Element._insertionTranslations.tags[tagName];
if (t) {
div.innerHTML = t[0] + html + t[1];
t[2].times(function() { div = div.firstChild });
} else div.innerHTML = html;
return $A(div.childNodes);
};
Element._insertionTranslations = {
before: function(element, node) {
element.parentNode.insertBefore(node, element);
},
top: function(element, node) {
element.insertBefore(node, element.firstChild);
},
bottom: function(element, node) {
element.appendChild(node);
},
after: function(element, node) {
element.parentNode.insertBefore(node, element.nextSibling);
},
tags: {
TABLE: ['', 1],
TBODY: ['', 2],
TR: ['', 3],
TD: ['', 4],
SELECT: ['', 1]
}
};
(function() {
Object.extend(this.tags, {
THEAD: this.tags.TBODY,
TFOOT: this.tags.TBODY,
TH: this.tags.TD
});
}).call(Element._insertionTranslations);
Element.Methods.Simulated = {
hasAttribute: function(element, attribute) {
attribute = Element._attributeTranslations.has[attribute] || attribute;
var node = $(element).getAttributeNode(attribute);
return node && node.specified;
}
};
Element.Methods.ByTag = { };
Object.extend(Element, Element.Methods);
if (!Prototype.BrowserFeatures.ElementExtensions &&
document.createElement('div').__proto__) {
window.HTMLElement = { };
window.HTMLElement.prototype = document.createElement('div').__proto__;
Prototype.BrowserFeatures.ElementExtensions = true;
}
Element.extend = (function() {
if (Prototype.BrowserFeatures.SpecificElementExtensions)
return Prototype.K;
var Methods = { }, ByTag = Element.Methods.ByTag;
var extend = Object.extend(function(element) {
if (!element || element._extendedByPrototype ||
element.nodeType != 1 || element == window) return element;
var methods = Object.clone(Methods),
tagName = element.tagName, property, value;
// extend methods for specific tags
if (ByTag[tagName]) Object.extend(methods, ByTag[tagName]);
for (property in methods) {
value = methods[property];
if (Object.isFunction(value) && !(property in element))
element[property] = value.methodize();
}
element._extendedByPrototype = Prototype.emptyFunction;
return element;
}, {
refresh: function() {
// extend methods for all tags (Safari doesn't need this)
if (!Prototype.BrowserFeatures.ElementExtensions) {
Object.extend(Methods, Element.Methods);
Object.extend(Methods, Element.Methods.Simulated);
}
}
});
extend.refresh();
return extend;
})();
Element.hasAttribute = function(element, attribute) {
if (element.hasAttribute) return element.hasAttribute(attribute);
return Element.Methods.Simulated.hasAttribute(element, attribute);
};
Element.addMethods = function(methods) {
var F = Prototype.BrowserFeatures, T = Element.Methods.ByTag;
if (!methods) {
Object.extend(Form, Form.Methods);
Object.extend(Form.Element, Form.Element.Methods);
Object.extend(Element.Methods.ByTag, {
"FORM": Object.clone(Form.Methods),
"INPUT": Object.clone(Form.Element.Methods),
"SELECT": Object.clone(Form.Element.Methods),
"TEXTAREA": Object.clone(Form.Element.Methods)
});
}
if (arguments.length == 2) {
var tagName = methods;
methods = arguments[1];
}
if (!tagName) Object.extend(Element.Methods, methods || { });
else {
if (Object.isArray(tagName)) tagName.each(extend);
else extend(tagName);
}
function extend(tagName) {
tagName = tagName.toUpperCase();
if (!Element.Methods.ByTag[tagName])
Element.Methods.ByTag[tagName] = { };
Object.extend(Element.Methods.ByTag[tagName], methods);
}
function copy(methods, destination, onlyIfAbsent) {
onlyIfAbsent = onlyIfAbsent || false;
for (var property in methods) {
var value = methods[property];
if (!Object.isFunction(value)) continue;
if (!onlyIfAbsent || !(property in destination))
destination[property] = value.methodize();
}
}
function findDOMClass(tagName) {
var klass;
var trans = {
"OPTGROUP": "OptGroup", "TEXTAREA": "TextArea", "P": "Paragraph",
"FIELDSET": "FieldSet", "UL": "UList", "OL": "OList", "DL": "DList",
"DIR": "Directory", "H1": "Heading", "H2": "Heading", "H3": "Heading",
"H4": "Heading", "H5": "Heading", "H6": "Heading", "Q": "Quote",
"INS": "Mod", "DEL": "Mod", "A": "Anchor", "IMG": "Image", "CAPTION":
"TableCaption", "COL": "TableCol", "COLGROUP": "TableCol", "THEAD":
"TableSection", "TFOOT": "TableSection", "TBODY": "TableSection", "TR":
"TableRow", "TH": "TableCell", "TD": "TableCell", "FRAMESET":
"FrameSet", "IFRAME": "IFrame"
};
if (trans[tagName]) klass = 'HTML' + trans[tagName] + 'Element';
if (window[klass]) return window[klass];
klass = 'HTML' + tagName + 'Element';
if (window[klass]) return window[klass];
klass = 'HTML' + tagName.capitalize() + 'Element';
if (window[klass]) return window[klass];
window[klass] = { };
window[klass].prototype = document.createElement(tagName).__proto__;
return window[klass];
}
if (F.ElementExtensions) {
copy(Element.Methods, HTMLElement.prototype);
copy(Element.Methods.Simulated, HTMLElement.prototype, true);
}
if (F.SpecificElementExtensions) {
for (var tag in Element.Methods.ByTag) {
var klass = findDOMClass(tag);
if (Object.isUndefined(klass)) continue;
copy(T[tag], klass.prototype);
}
}
Object.extend(Element, Element.Methods);
delete Element.ByTag;
if (Element.extend.refresh) Element.extend.refresh();
Element.cache = { };
};
document.viewport = {
getDimensions: function() {
var dimensions = { };
var B = Prototype.Browser;
$w('width height').each(function(d) {
var D = d.capitalize();
dimensions[d] = (B.WebKit && !document.evaluate) ? self['inner' + D] :
(B.Opera) ? document.body['client' + D] : document.documentElement['client' + D];
});
return dimensions;
},
getWidth: function() {
return this.getDimensions().width;
},
getHeight: function() {
return this.getDimensions().height;
},
getScrollOffsets: function() {
return Element._returnOffset(
window.pageXOffset || document.documentElement.scrollLeft || document.body.scrollLeft,
window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop);
}
};
/* Portions of the Selector class are derived from Jack Slocum’s DomQuery,
* part of YUI-Ext version 0.40, distributed under the terms of an MIT-style
* license. Please see http://www.yui-ext.com/ for more information. */
var Selector = Class.create({
initialize: function(expression) {
this.expression = expression.strip();
this.compileMatcher();
},
shouldUseXPath: function() {
if (!Prototype.BrowserFeatures.XPath) return false;
var e = this.expression;
// Safari 3 chokes on :*-of-type and :empty
if (Prototype.Browser.WebKit &&
(e.include("-of-type") || e.include(":empty")))
return false;
// XPath can't do namespaced attributes, nor can it read
// the "checked" property from DOM nodes
if ((/(\[[\w-]*?:|:checked)/).test(this.expression))
return false;
return true;
},
compileMatcher: function() {
if (this.shouldUseXPath())
return this.compileXPathMatcher();
var e = this.expression, ps = Selector.patterns, h = Selector.handlers,
c = Selector.criteria, le, p, m;
if (Selector._cache[e]) {
this.matcher = Selector._cache[e];
return;
}
this.matcher = ["this.matcher = function(root) {",
"var r = root, h = Selector.handlers, c = false, n;"];
while (e && le != e && (/\S/).test(e)) {
le = e;
for (var i in ps) {
p = ps[i];
if (m = e.match(p)) {
this.matcher.push(Object.isFunction(c[i]) ? c[i](m) :
new Template(c[i]).evaluate(m));
e = e.replace(m[0], '');
break;
}
}
}
this.matcher.push("return h.unique(n);\n}");
eval(this.matcher.join('\n'));
Selector._cache[this.expression] = this.matcher;
},
compileXPathMatcher: function() {
var e = this.expression, ps = Selector.patterns,
x = Selector.xpath, le, m;
if (Selector._cache[e]) {
this.xpath = Selector._cache[e]; return;
}
this.matcher = ['.//*'];
while (e && le != e && (/\S/).test(e)) {
le = e;
for (var i in ps) {
if (m = e.match(ps[i])) {
this.matcher.push(Object.isFunction(x[i]) ? x[i](m) :
new Template(x[i]).evaluate(m));
e = e.replace(m[0], '');
break;
}
}
}
this.xpath = this.matcher.join('');
Selector._cache[this.expression] = this.xpath;
},
findElements: function(root) {
root = root || document;
if (this.xpath) return document._getElementsByXPath(this.xpath, root);
return this.matcher(root);
},
match: function(element) {
this.tokens = [];
var e = this.expression, ps = Selector.patterns, as = Selector.assertions;
var le, p, m;
while (e && le !== e && (/\S/).test(e)) {
le = e;
for (var i in ps) {
p = ps[i];
if (m = e.match(p)) {
// use the Selector.assertions methods unless the selector
// is too complex.
if (as[i]) {
this.tokens.push([i, Object.clone(m)]);
e = e.replace(m[0], '');
} else {
// reluctantly do a document-wide search
// and look for a match in the array
return this.findElements(document).include(element);
}
}
}
}
var match = true, name, matches;
for (var i = 0, token; token = this.tokens[i]; i++) {
name = token[0], matches = token[1];
if (!Selector.assertions[name](element, matches)) {
match = false; break;
}
}
return match;
},
toString: function() {
return this.expression;
},
inspect: function() {
return "#";
}
});
Object.extend(Selector, {
_cache: { },
xpath: {
descendant: "//*",
child: "/*",
adjacent: "/following-sibling::*[1]",
laterSibling: '/following-sibling::*',
tagName: function(m) {
if (m[1] == '*') return '';
return "[local-name()='" + m[1].toLowerCase() +
"' or local-name()='" + m[1].toUpperCase() + "']";
},
className: "[contains(concat(' ', @class, ' '), ' #{1} ')]",
id: "[@id='#{1}']",
attrPresence: function(m) {
m[1] = m[1].toLowerCase();
return new Template("[@#{1}]").evaluate(m);
},
attr: function(m) {
m[1] = m[1].toLowerCase();
m[3] = m[5] || m[6];
return new Template(Selector.xpath.operators[m[2]]).evaluate(m);
},
pseudo: function(m) {
var h = Selector.xpath.pseudos[m[1]];
if (!h) return '';
if (Object.isFunction(h)) return h(m);
return new Template(Selector.xpath.pseudos[m[1]]).evaluate(m);
},
operators: {
'=': "[@#{1}='#{3}']",
'!=': "[@#{1}!='#{3}']",
'^=': "[starts-with(@#{1}, '#{3}')]",
'$=': "[substring(@#{1}, (string-length(@#{1}) - string-length('#{3}') + 1))='#{3}']",
'*=': "[contains(@#{1}, '#{3}')]",
'~=': "[contains(concat(' ', @#{1}, ' '), ' #{3} ')]",
'|=': "[contains(concat('-', @#{1}, '-'), '-#{3}-')]"
},
pseudos: {
'first-child': '[not(preceding-sibling::*)]',
'last-child': '[not(following-sibling::*)]',
'only-child': '[not(preceding-sibling::* or following-sibling::*)]',
'empty': "[count(*) = 0 and (count(text()) = 0 or translate(text(), ' \t\r\n', '') = '')]",
'checked': "[@checked]",
'disabled': "[@disabled]",
'enabled': "[not(@disabled)]",
'not': function(m) {
var e = m[6], p = Selector.patterns,
x = Selector.xpath, le, v;
var exclusion = [];
while (e && le != e && (/\S/).test(e)) {
le = e;
for (var i in p) {
if (m = e.match(p[i])) {
v = Object.isFunction(x[i]) ? x[i](m) : new Template(x[i]).evaluate(m);
exclusion.push("(" + v.substring(1, v.length - 1) + ")");
e = e.replace(m[0], '');
break;
}
}
}
return "[not(" + exclusion.join(" and ") + ")]";
},
'nth-child': function(m) {
return Selector.xpath.pseudos.nth("(count(./preceding-sibling::*) + 1) ", m);
},
'nth-last-child': function(m) {
return Selector.xpath.pseudos.nth("(count(./following-sibling::*) + 1) ", m);
},
'nth-of-type': function(m) {
return Selector.xpath.pseudos.nth("position() ", m);
},
'nth-last-of-type': function(m) {
return Selector.xpath.pseudos.nth("(last() + 1 - position()) ", m);
},
'first-of-type': function(m) {
m[6] = "1"; return Selector.xpath.pseudos['nth-of-type'](m);
},
'last-of-type': function(m) {
m[6] = "1"; return Selector.xpath.pseudos['nth-last-of-type'](m);
},
'only-of-type': function(m) {
var p = Selector.xpath.pseudos; return p['first-of-type'](m) + p['last-of-type'](m);
},
nth: function(fragment, m) {
var mm, formula = m[6], predicate;
if (formula == 'even') formula = '2n+0';
if (formula == 'odd') formula = '2n+1';
if (mm = formula.match(/^(\d+)$/)) // digit only
return '[' + fragment + "= " + mm[1] + ']';
if (mm = formula.match(/^(-?\d*)?n(([+-])(\d+))?/)) { // an+b
if (mm[1] == "-") mm[1] = -1;
var a = mm[1] ? Number(mm[1]) : 1;
var b = mm[2] ? Number(mm[2]) : 0;
predicate = "[((#{fragment} - #{b}) mod #{a} = 0) and " +
"((#{fragment} - #{b}) div #{a} >= 0)]";
return new Template(predicate).evaluate({
fragment: fragment, a: a, b: b });
}
}
}
},
criteria: {
tagName: 'n = h.tagName(n, r, "#{1}", c); c = false;',
className: 'n = h.className(n, r, "#{1}", c); c = false;',
id: 'n = h.id(n, r, "#{1}", c); c = false;',
attrPresence: 'n = h.attrPresence(n, r, "#{1}", c); c = false;',
attr: function(m) {
m[3] = (m[5] || m[6]);
return new Template('n = h.attr(n, r, "#{1}", "#{3}", "#{2}", c); c = false;').evaluate(m);
},
pseudo: function(m) {
if (m[6]) m[6] = m[6].replace(/"/g, '\\"');
return new Template('n = h.pseudo(n, "#{1}", "#{6}", r, c); c = false;').evaluate(m);
},
descendant: 'c = "descendant";',
child: 'c = "child";',
adjacent: 'c = "adjacent";',
laterSibling: 'c = "laterSibling";'
},
patterns: {
// combinators must be listed first
// (and descendant needs to be last combinator)
laterSibling: /^\s*~\s*/,
child: /^\s*>\s*/,
adjacent: /^\s*\+\s*/,
descendant: /^\s/,
// selectors follow
tagName: /^\s*(\*|[\w\-]+)(\b|$)?/,
id: /^#([\w\-\*]+)(\b|$)/,
className: /^\.([\w\-\*]+)(\b|$)/,
pseudo:
/^:((first|last|nth|nth-last|only)(-child|-of-type)|empty|checked|(en|dis)abled|not)(\((.*?)\))?(\b|$|(?=\s|[:+~>]))/,
attrPresence: /^\[([\w]+)\]/,
attr: /\[((?:[\w-]*:)?[\w-]+)\s*(?:([!^$*~|]?=)\s*((['"])([^\4]*?)\4|([^'"][^\]]*?)))?\]/
},
// for Selector.match and Element#match
assertions: {
tagName: function(element, matches) {
return matches[1].toUpperCase() == element.tagName.toUpperCase();
},
className: function(element, matches) {
return Element.hasClassName(element, matches[1]);
},
id: function(element, matches) {
return element.id === matches[1];
},
attrPresence: function(element, matches) {
return Element.hasAttribute(element, matches[1]);
},
attr: function(element, matches) {
var nodeValue = Element.readAttribute(element, matches[1]);
return nodeValue && Selector.operators[matches[2]](nodeValue, matches[5] || matches[6]);
}
},
handlers: {
// UTILITY FUNCTIONS
// joins two collections
concat: function(a, b) {
for (var i = 0, node; node = b[i]; i++)
a.push(node);
return a;
},
// marks an array of nodes for counting
mark: function(nodes) {
var _true = Prototype.emptyFunction;
for (var i = 0, node; node = nodes[i]; i++)
node._countedByPrototype = _true;
return nodes;
},
unmark: function(nodes) {
for (var i = 0, node; node = nodes[i]; i++)
node._countedByPrototype = undefined;
return nodes;
},
// mark each child node with its position (for nth calls)
// "ofType" flag indicates whether we're indexing for nth-of-type
// rather than nth-child
index: function(parentNode, reverse, ofType) {
parentNode._countedByPrototype = Prototype.emptyFunction;
if (reverse) {
for (var nodes = parentNode.childNodes, i = nodes.length - 1, j = 1; i >= 0; i--) {
var node = nodes[i];
if (node.nodeType == 1 && (!ofType || node._countedByPrototype)) node.nodeIndex = j++;
}
} else {
for (var i = 0, j = 1, nodes = parentNode.childNodes; node = nodes[i]; i++)
if (node.nodeType == 1 && (!ofType || node._countedByPrototype)) node.nodeIndex = j++;
}
},
// filters out duplicates and extends all nodes
unique: function(nodes) {
if (nodes.length == 0) return nodes;
var results = [], n;
for (var i = 0, l = nodes.length; i < l; i++)
if (!(n = nodes[i])._countedByPrototype) {
n._countedByPrototype = Prototype.emptyFunction;
results.push(Element.extend(n));
}
return Selector.handlers.unmark(results);
},
// COMBINATOR FUNCTIONS
descendant: function(nodes) {
var h = Selector.handlers;
for (var i = 0, results = [], node; node = nodes[i]; i++)
h.concat(results, node.getElementsByTagName('*'));
return results;
},
child: function(nodes) {
var h = Selector.handlers;
for (var i = 0, results = [], node; node = nodes[i]; i++) {
for (var j = 0, child; child = node.childNodes[j]; j++)
if (child.nodeType == 1 && child.tagName != '!') results.push(child);
}
return results;
},
adjacent: function(nodes) {
for (var i = 0, results = [], node; node = nodes[i]; i++) {
var next = this.nextElementSibling(node);
if (next) results.push(next);
}
return results;
},
laterSibling: function(nodes) {
var h = Selector.handlers;
for (var i = 0, results = [], node; node = nodes[i]; i++)
h.concat(results, Element.nextSiblings(node));
return results;
},
nextElementSibling: function(node) {
while (node = node.nextSibling)
if (node.nodeType == 1) return node;
return null;
},
previousElementSibling: function(node) {
while (node = node.previousSibling)
if (node.nodeType == 1) return node;
return null;
},
// TOKEN FUNCTIONS
tagName: function(nodes, root, tagName, combinator) {
var uTagName = tagName.toUpperCase();
var results = [], h = Selector.handlers;
if (nodes) {
if (combinator) {
// fastlane for ordinary descendant combinators
if (combinator == "descendant") {
for (var i = 0, node; node = nodes[i]; i++)
h.concat(results, node.getElementsByTagName(tagName));
return results;
} else nodes = this[combinator](nodes);
if (tagName == "*") return nodes;
}
for (var i = 0, node; node = nodes[i]; i++)
if (node.tagName.toUpperCase() === uTagName) results.push(node);
return results;
} else return root.getElementsByTagName(tagName);
},
id: function(nodes, root, id, combinator) {
var targetNode = $(id), h = Selector.handlers;
if (!targetNode) return [];
if (!nodes && root == document) return [targetNode];
if (nodes) {
if (combinator) {
if (combinator == 'child') {
for (var i = 0, node; node = nodes[i]; i++)
if (targetNode.parentNode == node) return [targetNode];
} else if (combinator == 'descendant') {
for (var i = 0, node; node = nodes[i]; i++)
if (Element.descendantOf(targetNode, node)) return [targetNode];
} else if (combinator == 'adjacent') {
for (var i = 0, node; node = nodes[i]; i++)
if (Selector.handlers.previousElementSibling(targetNode) == node)
return [targetNode];
} else nodes = h[combinator](nodes);
}
for (var i = 0, node; node = nodes[i]; i++)
if (node == targetNode) return [targetNode];
return [];
}
return (targetNode && Element.descendantOf(targetNode, root)) ? [targetNode] : [];
},
className: function(nodes, root, className, combinator) {
if (nodes && combinator) nodes = this[combinator](nodes);
return Selector.handlers.byClassName(nodes, root, className);
},
byClassName: function(nodes, root, className) {
if (!nodes) nodes = Selector.handlers.descendant([root]);
var needle = ' ' + className + ' ';
for (var i = 0, results = [], node, nodeClassName; node = nodes[i]; i++) {
nodeClassName = node.className;
if (nodeClassName.length == 0) continue;
if (nodeClassName == className || (' ' + nodeClassName + ' ').include(needle))
results.push(node);
}
return results;
},
attrPresence: function(nodes, root, attr, combinator) {
if (!nodes) nodes = root.getElementsByTagName("*");
if (nodes && combinator) nodes = this[combinator](nodes);
var results = [];
for (var i = 0, node; node = nodes[i]; i++)
if (Element.hasAttribute(node, attr)) results.push(node);
return results;
},
attr: function(nodes, root, attr, value, operator, combinator) {
if (!nodes) nodes = root.getElementsByTagName("*");
if (nodes && combinator) nodes = this[combinator](nodes);
var handler = Selector.operators[operator], results = [];
for (var i = 0, node; node = nodes[i]; i++) {
var nodeValue = Element.readAttribute(node, attr);
if (nodeValue === null) continue;
if (handler(nodeValue, value)) results.push(node);
}
return results;
},
pseudo: function(nodes, name, value, root, combinator) {
if (nodes && combinator) nodes = this[combinator](nodes);
if (!nodes) nodes = root.getElementsByTagName("*");
return Selector.pseudos[name](nodes, value, root);
}
},
pseudos: {
'first-child': function(nodes, value, root) {
for (var i = 0, results = [], node; node = nodes[i]; i++) {
if (Selector.handlers.previousElementSibling(node)) continue;
results.push(node);
}
return results;
},
'last-child': function(nodes, value, root) {
for (var i = 0, results = [], node; node = nodes[i]; i++) {
if (Selector.handlers.nextElementSibling(node)) continue;
results.push(node);
}
return results;
},
'only-child': function(nodes, value, root) {
var h = Selector.handlers;
for (var i = 0, results = [], node; node = nodes[i]; i++)
if (!h.previousElementSibling(node) && !h.nextElementSibling(node))
results.push(node);
return results;
},
'nth-child': function(nodes, formula, root) {
return Selector.pseudos.nth(nodes, formula, root);
},
'nth-last-child': function(nodes, formula, root) {
return Selector.pseudos.nth(nodes, formula, root, true);
},
'nth-of-type': function(nodes, formula, root) {
return Selector.pseudos.nth(nodes, formula, root, false, true);
},
'nth-last-of-type': function(nodes, formula, root) {
return Selector.pseudos.nth(nodes, formula, root, true, true);
},
'first-of-type': function(nodes, formula, root) {
return Selector.pseudos.nth(nodes, "1", root, false, true);
},
'last-of-type': function(nodes, formula, root) {
return Selector.pseudos.nth(nodes, "1", root, true, true);
},
'only-of-type': function(nodes, formula, root) {
var p = Selector.pseudos;
return p['last-of-type'](p['first-of-type'](nodes, formula, root), formula, root);
},
// handles the an+b logic
getIndices: function(a, b, total) {
if (a == 0) return b > 0 ? [b] : [];
return $R(1, total).inject([], function(memo, i) {
if (0 == (i - b) % a && (i - b) / a >= 0) memo.push(i);
return memo;
});
},
// handles nth(-last)-child, nth(-last)-of-type, and (first|last)-of-type
nth: function(nodes, formula, root, reverse, ofType) {
if (nodes.length == 0) return [];
if (formula == 'even') formula = '2n+0';
if (formula == 'odd') formula = '2n+1';
var h = Selector.handlers, results = [], indexed = [], m;
h.mark(nodes);
for (var i = 0, node; node = nodes[i]; i++) {
if (!node.parentNode._countedByPrototype) {
h.index(node.parentNode, reverse, ofType);
indexed.push(node.parentNode);
}
}
if (formula.match(/^\d+$/)) { // just a number
formula = Number(formula);
for (var i = 0, node; node = nodes[i]; i++)
if (node.nodeIndex == formula) results.push(node);
} else if (m = formula.match(/^(-?\d*)?n(([+-])(\d+))?/)) { // an+b
if (m[1] == "-") m[1] = -1;
var a = m[1] ? Number(m[1]) : 1;
var b = m[2] ? Number(m[2]) : 0;
var indices = Selector.pseudos.getIndices(a, b, nodes.length);
for (var i = 0, node, l = indices.length; node = nodes[i]; i++) {
for (var j = 0; j < l; j++)
if (node.nodeIndex == indices[j]) results.push(node);
}
}
h.unmark(nodes);
h.unmark(indexed);
return results;
},
'empty': function(nodes, value, root) {
for (var i = 0, results = [], node; node = nodes[i]; i++) {
// IE treats comments as element nodes
if (node.tagName == '!' || (node.firstChild && !node.innerHTML.match(/^\s*$/))) continue;
results.push(node);
}
return results;
},
'not': function(nodes, selector, root) {
var h = Selector.handlers, selectorType, m;
var exclusions = new Selector(selector).findElements(root);
h.mark(exclusions);
for (var i = 0, results = [], node; node = nodes[i]; i++)
if (!node._countedByPrototype) results.push(node);
h.unmark(exclusions);
return results;
},
'enabled': function(nodes, value, root) {
for (var i = 0, results = [], node; node = nodes[i]; i++)
if (!node.disabled) results.push(node);
return results;
},
'disabled': function(nodes, value, root) {
for (var i = 0, results = [], node; node = nodes[i]; i++)
if (node.disabled) results.push(node);
return results;
},
'checked': function(nodes, value, root) {
for (var i = 0, results = [], node; node = nodes[i]; i++)
if (node.checked) results.push(node);
return results;
}
},
operators: {
'=': function(nv, v) { return nv == v; },
'!=': function(nv, v) { return nv != v; },
'^=': function(nv, v) { return nv.startsWith(v); },
'$=': function(nv, v) { return nv.endsWith(v); },
'*=': function(nv, v) { return nv.include(v); },
'~=': function(nv, v) { return (' ' + nv + ' ').include(' ' + v + ' '); },
'|=': function(nv, v) { return ('-' + nv.toUpperCase() + '-').include('-' + v.toUpperCase() + '-'); }
},
split: function(expression) {
var expressions = [];
expression.scan(/(([\w#:.~>+()\s-]+|\*|\[.*?\])+)\s*(,|$)/, function(m) {
expressions.push(m[1].strip());
});
return expressions;
},
matchElements: function(elements, expression) {
var matches = $$(expression), h = Selector.handlers;
h.mark(matches);
for (var i = 0, results = [], element; element = elements[i]; i++)
if (element._countedByPrototype) results.push(element);
h.unmark(matches);
return results;
},
findElement: function(elements, expression, index) {
if (Object.isNumber(expression)) {
index = expression; expression = false;
}
return Selector.matchElements(elements, expression || '*')[index || 0];
},
findChildElements: function(element, expressions) {
expressions = Selector.split(expressions.join(','));
var results = [], h = Selector.handlers;
for (var i = 0, l = expressions.length, selector; i < l; i++) {
selector = new Selector(expressions[i].strip());
h.concat(results, selector.findElements(element));
}
return (l > 1) ? h.unique(results) : results;
}
});
if (Prototype.Browser.IE) {
Object.extend(Selector.handlers, {
// IE returns comment nodes on getElementsByTagName("*").
// Filter them out.
concat: function(a, b) {
for (var i = 0, node; node = b[i]; i++)
if (node.tagName !== "!") a.push(node);
return a;
},
// IE improperly serializes _countedByPrototype in (inner|outer)HTML.
unmark: function(nodes) {
for (var i = 0, node; node = nodes[i]; i++)
node.removeAttribute('_countedByPrototype');
return nodes;
}
});
}
function $$() {
return Selector.findChildElements(document, $A(arguments));
}
var Form = {
reset: function(form) {
$(form).reset();
return form;
},
serializeElements: function(elements, options) {
if (typeof options != 'object') options = { hash: !!options };
else if (Object.isUndefined(options.hash)) options.hash = true;
var key, value, submitted = false, submit = options.submit;
var data = elements.inject({ }, function(result, element) {
if (!element.disabled && element.name) {
key = element.name; value = $(element).getValue();
if (value != null && (element.type != 'submit' || (!submitted &&
submit !== false && (!submit || key == submit) && (submitted = true)))) {
if (key in result) {
// a key is already present; construct an array of values
if (!Object.isArray(result[key])) result[key] = [result[key]];
result[key].push(value);
}
else result[key] = value;
}
}
return result;
});
return options.hash ? data : Object.toQueryString(data);
}
};
Form.Methods = {
serialize: function(form, options) {
return Form.serializeElements(Form.getElements(form), options);
},
getElements: function(form) {
return $A($(form).getElementsByTagName('*')).inject([],
function(elements, child) {
if (Form.Element.Serializers[child.tagName.toLowerCase()])
elements.push(Element.extend(child));
return elements;
}
);
},
getInputs: function(form, typeName, name) {
form = $(form);
var inputs = form.getElementsByTagName('input');
if (!typeName && !name) return $A(inputs).map(Element.extend);
for (var i = 0, matchingInputs = [], length = inputs.length; i < length; i++) {
var input = inputs[i];
if ((typeName && input.type != typeName) || (name && input.name != name))
continue;
matchingInputs.push(Element.extend(input));
}
return matchingInputs;
},
disable: function(form) {
form = $(form);
Form.getElements(form).invoke('disable');
return form;
},
enable: function(form) {
form = $(form);
Form.getElements(form).invoke('enable');
return form;
},
findFirstElement: function(form) {
var elements = $(form).getElements().findAll(function(element) {
return 'hidden' != element.type && !element.disabled;
});
var firstByIndex = elements.findAll(function(element) {
return element.hasAttribute('tabIndex') && element.tabIndex >= 0;
}).sortBy(function(element) { return element.tabIndex }).first();
return firstByIndex ? firstByIndex : elements.find(function(element) {
return ['input', 'select', 'textarea'].include(element.tagName.toLowerCase());
});
},
focusFirstElement: function(form) {
form = $(form);
form.findFirstElement().activate();
return form;
},
request: function(form, options) {
form = $(form), options = Object.clone(options || { });
var params = options.parameters, action = form.readAttribute('action') || '';
if (action.blank()) action = window.location.href;
options.parameters = form.serialize(true);
if (params) {
if (Object.isString(params)) params = params.toQueryParams();
Object.extend(options.parameters, params);
}
if (form.hasAttribute('method') && !options.method)
options.method = form.method;
return new Ajax.Request(action, options);
}
};
/*--------------------------------------------------------------------------*/
Form.Element = {
focus: function(element) {
$(element).focus();
return element;
},
select: function(element) {
$(element).select();
return element;
}
};
Form.Element.Methods = {
serialize: function(element) {
element = $(element);
if (!element.disabled && element.name) {
var value = element.getValue();
if (value != undefined) {
var pair = { };
pair[element.name] = value;
return Object.toQueryString(pair);
}
}
return '';
},
getValue: function(element) {
element = $(element);
var method = element.tagName.toLowerCase();
return Form.Element.Serializers[method](element);
},
setValue: function(element, value) {
element = $(element);
var method = element.tagName.toLowerCase();
Form.Element.Serializers[method](element, value);
return element;
},
clear: function(element) {
$(element).value = '';
return element;
},
present: function(element) {
return $(element).value != '';
},
activate: function(element) {
element = $(element);
try {
element.focus();
if (element.select && (element.tagName.toLowerCase() != 'input' ||
!['button', 'reset', 'submit'].include(element.type)))
element.select();
} catch (e) { }
return element;
},
disable: function(element) {
element = $(element);
element.blur();
element.disabled = true;
return element;
},
enable: function(element) {
element = $(element);
element.disabled = false;
return element;
}
};
/*--------------------------------------------------------------------------*/
var Field = Form.Element;
var $F = Form.Element.Methods.getValue;
/*--------------------------------------------------------------------------*/
Form.Element.Serializers = {
input: function(element, value) {
switch (element.type.toLowerCase()) {
case 'checkbox':
case 'radio':
return Form.Element.Serializers.inputSelector(element, value);
default:
return Form.Element.Serializers.textarea(element, value);
}
},
inputSelector: function(element, value) {
if (Object.isUndefined(value)) return element.checked ? element.value : null;
else element.checked = !!value;
},
textarea: function(element, value) {
if (Object.isUndefined(value)) return element.value;
else element.value = value;
},
select: function(element, index) {
if (Object.isUndefined(index))
return this[element.type == 'select-one' ?
'selectOne' : 'selectMany'](element);
else {
var opt, value, single = !Object.isArray(index);
for (var i = 0, length = element.length; i < length; i++) {
opt = element.options[i];
value = this.optionValue(opt);
if (single) {
if (value == index) {
opt.selected = true;
return;
}
}
else opt.selected = index.include(value);
}
}
},
selectOne: function(element) {
var index = element.selectedIndex;
return index >= 0 ? this.optionValue(element.options[index]) : null;
},
selectMany: function(element) {
var values, length = element.length;
if (!length) return null;
for (var i = 0, values = []; i < length; i++) {
var opt = element.options[i];
if (opt.selected) values.push(this.optionValue(opt));
}
return values;
},
optionValue: function(opt) {
// extend element because hasAttribute may not be native
return Element.extend(opt).hasAttribute('value') ? opt.value : opt.text;
}
};
/*--------------------------------------------------------------------------*/
Abstract.TimedObserver = Class.create(PeriodicalExecuter, {
initialize: function($super, element, frequency, callback) {
$super(callback, frequency);
this.element = $(element);
this.lastValue = this.getValue();
},
execute: function() {
var value = this.getValue();
if (Object.isString(this.lastValue) && Object.isString(value) ?
this.lastValue != value : String(this.lastValue) != String(value)) {
this.callback(this.element, value);
this.lastValue = value;
}
}
});
Form.Element.Observer = Class.create(Abstract.TimedObserver, {
getValue: function() {
return Form.Element.getValue(this.element);
}
});
Form.Observer = Class.create(Abstract.TimedObserver, {
getValue: function() {
return Form.serialize(this.element);
}
});
/*--------------------------------------------------------------------------*/
Abstract.EventObserver = Class.create({
initialize: function(element, callback) {
this.element = $(element);
this.callback = callback;
this.lastValue = this.getValue();
if (this.element.tagName.toLowerCase() == 'form')
this.registerFormCallbacks();
else
this.registerCallback(this.element);
},
onElementEvent: function() {
var value = this.getValue();
if (this.lastValue != value) {
this.callback(this.element, value);
this.lastValue = value;
}
},
registerFormCallbacks: function() {
Form.getElements(this.element).each(this.registerCallback, this);
},
registerCallback: function(element) {
if (element.type) {
switch (element.type.toLowerCase()) {
case 'checkbox':
case 'radio':
Event.observe(element, 'click', this.onElementEvent.bind(this));
break;
default:
Event.observe(element, 'change', this.onElementEvent.bind(this));
break;
}
}
}
});
Form.Element.EventObserver = Class.create(Abstract.EventObserver, {
getValue: function() {
return Form.Element.getValue(this.element);
}
});
Form.EventObserver = Class.create(Abstract.EventObserver, {
getValue: function() {
return Form.serialize(this.element);
}
});
if (!window.Event) var Event = { };
Object.extend(Event, {
KEY_BACKSPACE: 8,
KEY_TAB: 9,
KEY_RETURN: 13,
KEY_ESC: 27,
KEY_LEFT: 37,
KEY_UP: 38,
KEY_RIGHT: 39,
KEY_DOWN: 40,
KEY_DELETE: 46,
KEY_HOME: 36,
KEY_END: 35,
KEY_PAGEUP: 33,
KEY_PAGEDOWN: 34,
KEY_INSERT: 45,
cache: { },
relatedTarget: function(event) {
var element;
switch(event.type) {
case 'mouseover': element = event.fromElement; break;
case 'mouseout': element = event.toElement; break;
default: return null;
}
return Element.extend(element);
}
});
Event.Methods = (function() {
var isButton;
if (Prototype.Browser.IE) {
var buttonMap = { 0: 1, 1: 4, 2: 2 };
isButton = function(event, code) {
return event.button == buttonMap[code];
};
} else if (Prototype.Browser.WebKit) {
isButton = function(event, code) {
switch (code) {
case 0: return event.which == 1 && !event.metaKey;
case 1: return event.which == 1 && event.metaKey;
default: return false;
}
};
} else {
isButton = function(event, code) {
return event.which ? (event.which === code + 1) : (event.button === code);
};
}
return {
isLeftClick: function(event) { return isButton(event, 0) },
isMiddleClick: function(event) { return isButton(event, 1) },
isRightClick: function(event) { return isButton(event, 2) },
element: function(event) {
var node = Event.extend(event).target;
return (node)?Element.extend(node.nodeType == Node.TEXT_NODE ? node.parentNode : node):null;
},
findElement: function(event, expression) {
var element = Event.element(event);
if (!expression) return element;
var elements = [element].concat(element.ancestors());
return Selector.findElement(elements, expression, 0);
},
pointer: function(event) {
return {
x: event.pageX || (event.clientX +
(document.documentElement.scrollLeft || document.body.scrollLeft)),
y: event.pageY || (event.clientY +
(document.documentElement.scrollTop || document.body.scrollTop))
};
},
pointerX: function(event) { return Event.pointer(event).x },
pointerY: function(event) { return Event.pointer(event).y },
stop: function(event) {
Event.extend(event);
event.preventDefault();
event.stopPropagation();
event.stopped = true;
}
};
})();
Event.extend = (function() {
var methods = Object.keys(Event.Methods).inject({ }, function(m, name) {
m[name] = Event.Methods[name].methodize();
return m;
});
if (Prototype.Browser.IE) {
Object.extend(methods, {
stopPropagation: function() { this.cancelBubble = true },
preventDefault: function() { this.returnValue = false },
inspect: function() { return "[object Event]" }
});
return function(event) {
if (!event) return false;
if (event._extendedByPrototype) return event;
event._extendedByPrototype = Prototype.emptyFunction;
var pointer = Event.pointer(event);
Object.extend(event, {
target: event.srcElement,
relatedTarget: Event.relatedTarget(event),
pageX: pointer.x,
pageY: pointer.y
});
return Object.extend(event, methods);
};
} else {
Event.prototype = Event.prototype || document.createEvent("HTMLEvents").__proto__;
Object.extend(Event.prototype, methods);
return Prototype.K;
}
})();
Object.extend(Event, (function() {
var cache = Event.cache;
function getEventID(element) {
if (element._prototypeEventID) return element._prototypeEventID[0];
arguments.callee.id = arguments.callee.id || 1;
return element._prototypeEventID = [++arguments.callee.id];
}
function getDOMEventName(eventName) {
if (eventName && eventName.include(':')) return "dataavailable";
return eventName;
}
function getCacheForID(id) {
return cache[id] = cache[id] || { };
}
function getWrappersForEventName(id, eventName) {
var c = getCacheForID(id);
return c[eventName] = c[eventName] || [];
}
function createWrapper(element, eventName, handler) {
var id = getEventID(element);
var c = getWrappersForEventName(id, eventName);
if (c.pluck("handler").include(handler)) return false;
var wrapper = function(event) {
if (!Event || !Event.extend ||
(event.eventName && event.eventName != eventName))
return false;
Event.extend(event);
handler.call(element, event);
};
wrapper.handler = handler;
c.push(wrapper);
return wrapper;
}
function findWrapper(id, eventName, handler) {
var c = getWrappersForEventName(id, eventName);
return c.find(function(wrapper) { return wrapper.handler == handler });
}
function destroyWrapper(id, eventName, handler) {
var c = getCacheForID(id);
if (!c[eventName]) return false;
c[eventName] = c[eventName].without(findWrapper(id, eventName, handler));
}
function destroyCache() {
for (var id in cache)
for (var eventName in cache[id])
cache[id][eventName] = null;
}
if (window.attachEvent) {
window.attachEvent("onunload", destroyCache);
}
return {
observe: function(element, eventName, handler) {
element = $(element);
var name = getDOMEventName(eventName);
var wrapper = createWrapper(element, eventName, handler);
if (!wrapper) return element;
if (element.addEventListener) {
element.addEventListener(name, wrapper, false);
} else {
element.attachEvent("on" + name, wrapper);
}
return element;
},
stopObserving: function(element, eventName, handler) {
element = $(element);
var id = getEventID(element), name = getDOMEventName(eventName);
if (!handler && eventName) {
getWrappersForEventName(id, eventName).each(function(wrapper) {
element.stopObserving(eventName, wrapper.handler);
});
return element;
} else if (!eventName) {
Object.keys(getCacheForID(id)).each(function(eventName) {
element.stopObserving(eventName);
});
return element;
}
var wrapper = findWrapper(id, eventName, handler);
if (!wrapper) return element;
if (element.removeEventListener) {
element.removeEventListener(name, wrapper, false);
} else {
element.detachEvent("on" + name, wrapper);
}
destroyWrapper(id, eventName, handler);
return element;
},
fire: function(element, eventName, memo) {
element = $(element);
if (element == document && document.createEvent && !element.dispatchEvent)
element = document.documentElement;
var event;
if (document.createEvent) {
event = document.createEvent("HTMLEvents");
event.initEvent("dataavailable", true, true);
} else {
event = document.createEventObject();
event.eventType = "ondataavailable";
}
event.eventName = eventName;
event.memo = memo || { };
if (document.createEvent) {
element.dispatchEvent(event);
} else {
element.fireEvent(event.eventType, event);
}
return Event.extend(event);
}
};
})());
Object.extend(Event, Event.Methods);
Element.addMethods({
fire: Event.fire,
observe: Event.observe,
stopObserving: Event.stopObserving
});
Object.extend(document, {
fire: Element.Methods.fire.methodize(),
observe: Element.Methods.observe.methodize(),
stopObserving: Element.Methods.stopObserving.methodize(),
loaded: false
});
(function() {
/* Support for the DOMContentLoaded event is based on work by Dan Webb,
Matthias Miller, Dean Edwards and John Resig. */
var timer;
function fireContentLoadedEvent() {
if (document.loaded) return;
if (timer) window.clearInterval(timer);
document.fire("dom:loaded");
document.loaded = true;
}
if (document.addEventListener) {
if (Prototype.Browser.WebKit) {
timer = window.setInterval(function() {
if (/loaded|complete/.test(document.readyState))
fireContentLoadedEvent();
}, 0);
Event.observe(window, "load", fireContentLoadedEvent);
} else {
document.addEventListener("DOMContentLoaded",
fireContentLoadedEvent, false);
}
} else {
document.write("');
}
var newPrototype = ((typeof Prototype != 'undefined') || convertVersionString(Prototype.Version) < convertVersionString('1.6.0'))
function createListener(id,method){
//declaring the class
alert(id+ ' ' + method);
var CheckboxWatcher = Class.create();
//defining the rest of the class implementation
CheckboxWatcher.prototype = {
initialize: function(chkBox, message) {
this.chkBox = $(chkBox);
this.message = message;
//assigning our method to the event
this.chkBox.onclick = this.showMessage.bindAsEventListener(this);
},
showMessage: function(evt) {
alert(this.message + ' (' + evt.type + ')');
}
};
var watcher = new CheckboxWatcher(id, method);
}
/**
@param string rowid the id o fthe row you want to make disappear
@param oject opts Effect options such as {duration:3}
*/
function fadeTableRow(rowid,opts){
element = $(rowid);
if(!opts){
opts = {};
}
if(Element.visible(element)) {
var row = $(rowid);
var cells= row.childNodes;
for(i=0;i 0)) show_error_container_id = show_error_id+'_container';
show_error_id = (show_error_id == undefined || show_error_id.length <= 0)?'global_error_stack_output':show_error_id;
show_error_container_id = (show_error_container_id == undefined || show_error_container_id.length <= 0)?'global_error_stack_output_container':show_error_container_id;
show_error_element = (show_error_id == undefined || show_error_id.length <= 0 || !show_error_id || $(show_error_id) == null)?false:$(show_error_id);
show_error_element_container = (show_error_container_id == undefined || show_error_container_id.length <= 0 || !show_error_container_id || $(show_error_container_id) == null)?false:$(show_error_container_id);
attach = (attach == undefined || attach.length <= 0 || attach == 0 || attach == false)?false:true;
fade = (fade == 0 || fade == false)?false:true;
update = (update == 0 || update == false)?false:true;
blind = (blind == 0 || blind == false || blind == undefined)?false:true;
collect = (collect == undefined)?false:collect;
enctype = (enctype == undefined || enctype.length <= 0)?'multipart/form-data':enctype;
element = $(id);
var formParams = (collect)?getFormParams(document,true):'';
var post = (formParams != '')?formParams:'';
if (params != '' && params != undefined && params != null){
if (typeof post == 'object' || typeof params == 'object'){
if (typeof post != 'object') post = new Object();
if (typeof params == 'string') params = params.toQueryParams();
Object.extend(post,params);
} else {
post += (post != '')?'&':'';
post += (params);
}
}
if (url.search('index') < 0){
Object.extend(post,{'action' : url});
}
// var postObj = post.toQueryParams();
if (typeof post == 'object' ) post = (post.toQueryString)?post.toQueryString():$H(post).toQueryString() ;
var opt = {
// Use POST
method: 'post',
// Send this lovely data
postBody: post,
// Encoding
encoding: 'ISO-8859-1',
// Handle successful response
onSuccess: function(t) {
var new_content = unescape(t.responseText);
// *#*#*#*#*#*#* ersetzen...
if (new_content.search(/\*#\*#\*#\*#\*#\*#\*/g) >= 0){
new_content = new_content.replace(/\*#\*#\*#\*#\*#\*#\*/g, '\\');
} else {
new_content = new_content;
}
//alert(new_content);
// Error Handling...
if (new_content.indexOf('error;') == 0){
if (show_error_element != false){
var errormessage = new_content.replace(/error;/,'');
Element.update(show_error_element,errormessage);
new Effect.Appear(show_error_element_container,{queue:'end'});
new Effect.Fade(show_error_element_container,{queue:'end',delay:10});
}
} else {
if (update){
if (new_content != 'kb_error' && (element != null || id == '')){
if (id != ''){
new_content = (attach)? element.innerHTML + new_content : new_content;
Element.update(element,new_content.getInnerHtmlById(id,1));
}
if (success_extra != undefined && success_extra.length > 0 && new_content.indexOf('error;') != 0){
//alert('executing success_extra!');
eval(success_extra);
}
} else {
//alert('an error occurred!');
if (element == null) alert('Das Element mit der id '+id+' existiert nicht !!!');
if (new_content == 'kb_error') alert('interner Fehler !!!');
}
if (blind && element != null && (!element.visible() || element.style.opacity <= 0.5)) new Effect.BlindDown(id,{ duration: 1.0, queue: 'end' });
if ((!is_ie6) && fade && element != null && (!element.visible() || element.style.opacity <= 0.5)) new Effect.Opacity(id,{ duration: 1.0,transition: Effect.Transitions.linear,from: 0.01, to: 1.0, queue: 'end' });
} else {
if (success_extra != undefined && success_extra.length > 0){
eval(success_extra);
}
}
}
},
// Handle 404
on404: function(t) {
alert('Error 404: location "' + t.statusText + '" was not found.');
},
// Handle other errors
onFailure: function(t) {
alert('Error ' + t.status + ' -- ' + t.statusText);
}
}
if (update){
if (blind && element != null && (element.visible() || element.style.opacity > 0.5)) new Effect.BlindUp(id,{ duration: 1.0});
if ((!is_ie6) && fade && element != null && (element.visible() || element.style.opacity > 0.5)) new Effect.Opacity(id,{ duration: 0.5,transition: Effect.Transitions.linear,from: 1.0, to: 0.01 });
}
new Ajax.Request(url, opt);
}
function kb_request(options){
var url = (options && options.url)?options.url : '/index.php';
var action = (options && options.action)? $H({ action: options.action}) : $H({});
var id = (options && options.id )?options.id : 'column2_right_main_without_teaser';
var params = (options && options.params )?options.params : {};
var collect = (options && options.collect != undefined )?options.collect : false;
var attach = (options && options.attach != undefined )?options.attach : false;
var fade = (options && options.fade != undefined )?options.fade : true;
var blind = (options && options.blind != undefined )?options.blind : false;
var update = (options && options.update != undefined )?options.update : true;
var clean = (options && options.clean != undefined )?options.clean : 0;
var submitted_form_element_ids = (options && options.submitted_form_element_ids != undefined )?options.submitted_form_element_ids : [];
var success_extra = (options && options.onComplete )?options.onComplete : '';
var show_error_id = (options && options.errorId )?options.errorId : 'global_error_stack_output';
var show_error_container_id = (options && options.errorContainerId )?options.errorContainerId : 'global_error_stack_output_container';
var element = $(id);
show_error_element = (show_error_id == undefined || show_error_id.length <= 0 || !show_error_id || $(show_error_id) == null)?false:$(show_error_id);
show_error_element_container = (show_error_container_id == undefined || show_error_container_id.length <= 0 || !show_error_container_id || $(show_error_container_id) == null)?false:$(show_error_container_id);
var formParams = (collect)?getFormParams($(collect),true):'';
var post = (formParams != '') ? formParams:'';
submitted_form_element_ids.each(function(el){
element = $(el);
if (element){
eval('Object.extend(params,element.collectValues());');
}
});
var destId = (formParams && formParams.get && formParams.get('destId') != undefined)?formParams.get('destId'):'';
destId = (Object.isString(destId))?destId : (destId[0])?destId[0] : '';
if (!element && destId){
element = $(destId);
id = destId;
}
if (params != '' && params != undefined && params != null){
if (typeof post == 'object' || typeof params == 'object'){
if (typeof post != 'object') post = new Object();
if (typeof params == 'string') params = params.toQueryParams();
Object.extend(post,params);
} else {
post += (post != '')?'&':'';
post += (params);
}
}
post = $H(post).merge(action);
if (typeof post == 'object' ) post = (post.toQueryString)?post.toQueryString():$H(post).toQueryString() ;
var opt = {
// Use POST
method: 'post',
// Send this lovely data
postBody: post,
// Encoding
encoding: 'ISO-8859-1',
// Handle successful response
onSuccess: function(t) {
var new_content = unescape(t.responseText);
// *#*#*#*#*#*#* ersetzen...
if (new_content.search(/\*#\*#\*#\*#\*#\*#\*/g) >= 0){
new_content = new_content.replace(/\*#\*#\*#\*#\*#\*#\*/g, '\\');
} else {
new_content = new_content;
}
// Error Handling...
if (show_error_element != false && new_content.indexOf('error;') == 0){
var errormessage = new_content.replace(/error;/,'');
Element.update(show_error_element,errormessage);
new Effect.Appear(show_error_element_container,{queue:'end'});
// new Effect.Opacity(show_error_element,{ duration: 0.5,transition: Effect.Transitions.linear,from: 0.001, to: 1.0 ,queue:'end'});
new Effect.Fade(show_error_element_container,{queue:'end',delay:10});
// new Effect.Opacity(show_error_element,{ duration: 0.5,transition: Effect.Transitions.linear,from: 1.0, to: 0.001 ,queue:'end',delay:5});
} else {
if (update){
if (new_content != 'kb_error' && (element != null || id == '')){
if (id != ''){
new_content = (attach)? element.innerHTML + new_content : new_content;
Element.update(element,new_content.getInnerHtmlById(id));
}
if (success_extra != undefined && success_extra.length > 0 && new_content.indexOf('error;') != 0){
eval(success_extra);
}
} else {
if (element == null) alert('Das Element mit der id '+id+' existiert nicht !!!');
if (new_content == 'kb_error') alert('interner Fehler !!!');
}
if (blind && element != null && (!element.visible() || element.style.opacity <= 0.5)) new Effect.BlindDown(id,{ duration: 1.0, queue: 'end' });
if ((!is_ie6) && fade && element != null && (!element.visible() || element.style.opacity <= 0.5)) new Effect.Opacity(id,{ duration: 1.0,transition: Effect.Transitions.linear,from: 0.01, to: 1.0, queue: 'end' });
} else {
if (success_extra != undefined && success_extra.length > 0){
eval(success_extra);
}
}
}
},
// Handle 404
on404: function(t) {
alert('Error 404: location "' + t.statusText + '" was not found.');
},
// Handle other errors
onFailure: function(t) {
alert('Error ' + t.status + ' -- ' + t.statusText);
}
}
if (update){
if (blind && element != null && (element.visible() || element.style.opacity > 0.5)) new Effect.BlindUp(id,{ duration: 1.0});
if ((!is_ie6) && fade && element != null && (element.visible() || element.style.opacity > 0.5)) new Effect.Opacity(id,{ duration: 0.5,transition: Effect.Transitions.linear,from: 1.0, to: 0.51 });
}
new Ajax.Request(url, opt);
}
function upload(){
// hide old iframe
var par = window.parent.document;
var num = par.getElementsByTagName('iframe').length - 1;
var iframe = par.getElementsByTagName('iframe')[num];
iframe.className = 'hidden';
// create new iframe
var new_iframe = par.createElement('iframe');
new_iframe.src = 'data/upload.php';
new_iframe.frameBorder = '0';
par.getElementById('iframe').appendChild(new_iframe);
// add image progress
var list = par.getElementById('list');
var new_div = par.createElement('div');
var new_img = par.createElement('img');
new_img.src = '/img/lightbox/loading.gif';
new_img.className = 'load';
new_div.appendChild(new_img);
list.appendChild(new_div);
// send
var imgnum = list.getElementsByTagName('div').length - 1;
document.iform.imgnum.value = imgnum;
document.iform.submit();
}
function startCallback(){
//alert('start');
if ($('systemWorking') != null) new Effect.Appear('systemWorking',{ duration: 0.5 });
if ((!is_ie6)){
new Effect.Opacity('album_fotos_id',
{ duration: 1.0,
transition: Effect.Transitions.linear,
from: 1.0, to: 0.2 });
new Effect.Opacity('group_new_pictures_id',
{ duration: 1.0,
transition: Effect.Transitions.linear,
from: 1.0, to: 0.2 });
}
return true;
}
function completeCallback(response,error){
//alert('complete');
if ($('systemWorking') != null) new Effect.Fade('systemWorking',{ duration: 0.5 });
response = unescape(response);
error = response.indexOf('error;') == 0;
var errormessage = response.replace(/error;/,'');
if (!error){
$('album_fotos_id').innerHTML += unescape(errormessage);
} else {
Element.update('global_error_stack_output',unescape(errormessage));
new Effect.Appear('global_error_stack_output_container',{queue:'end'});
new Effect.Fade('global_error_stack_output_container',{queue:'end',delay:10});
}
if ((!is_ie6)){
new Effect.Opacity('album_fotos_id',
{ duration: 1.0,
transition: Effect.Transitions.linear,
from: 0.2, to: 1.0 });
new Effect.Opacity('group_new_pictures_id',
{ duration: 1.0,
transition: Effect.Transitions.linear,
from: 0.2, to: 1.0 })
}
/*
$template_output = '';
$template_output.= ''."\n";*/
clearFormParams('group_new_pictures_id');
}
function switchElements(element1,element2,fade){
fade = (fade == 1 || fade == true)?true:false;
element1 = $(element1);
element2 = $(element2);
hide = ((element2.style.display == 'none' || !element2.visible) || !(element1.style.display == 'none' || !element1.visible))?element1:element2;
show = ((element2.style.display == 'none' || !element2.visible) || !(element1.style.display == 'none' || !element1.visible))?element2:element1;
// new Effect.Opacity(hide,{ duration: 0.5,transition: Effect.Transitions.linear,from: 1.0, to: 0.001 });
// new Effect.Opacity(show,{ duration: 0.5,transition: Effect.Transitions.linear,from: 0.001, to: 1.0, queue: 'end' });
if (!is_ie6 && fade && false){
new Effect.Fade(hide, {duration:0.1});
new Effect.Appear(show,{ queue: 'end', duration:0.1});
} else {
Element.hide(hide);
Element.show(show);
}
}
function numVal(element) {
var num = element.value.charAt(element.value.length-1);
var ValidChars = "0123456789";
if (ValidChars.indexOf(num) == -1) {
element.value = element.value.substring(0, element.value.length-1);
}
//alert(element.value + ' -> '+num);
}
//
function getInnerHtmlById(n) {
secure = 4000; /* SicherheitsZähler der zur Not die schleife abbricht... */
var errorResult = (this.search(/]*>/) > -1 || this.search(/]*>/) > -1 || this.search(/]*>/) > -1)? '' : this;
typeExpr = new RegExp("<([a-zA-Z]*)[^>]*id=."+n+"[^>]*>");
if ((n.length == 0) || (this.indexOf(n) == -1) || this.search(typeExpr) == -1) return (errorResult);
type = this.match(typeExpr)[1];
var front = ''
var end = ''
if (type == null || type == undefined) return false;
startExpression = new RegExp("<"+type+"[^>]*id=."+n+"[^>]*>");
startDivExp = new RegExp("<"+type+"[^>]*>");
endDivExp = new RegExp("");
startTag = new String(this.match(startExpression));
startIndex = this.search(startTag) + startTag.length;
var txt = new String(this.substr(startIndex)).replace(//,'');
endMatch = txt.match(endDivExp);
endIndex = 6 + txt.search(endDivExp);
front = txt.substr(0,endIndex);
end = txt.substr(endIndex);
var lastIndex = endIndex;
startMatch = front.split('<'+type);
frontCount = 0;
if (startMatch != null){
startMatch = startMatch.uniq();
frontCount += startMatch.length-1;
}
while (frontCount > 0 && --secure){
endMatch = end.match(endDivExp);
endIndex = 6 + end.search(endDivExp);
lastIndex += endIndex;
front = end.substr(0,endIndex);
end = end.substr(endIndex);
startMatch = front.split('<'+type);
if (startMatch != null){
startMatch = startMatch.uniq();
frontCount += startMatch.length-1;
}
frontCount--;
}
result = txt.substr(0,lastIndex-6);
//alert(result);
return result;
}
String.prototype.getInnerHtmlById = getInnerHtmlById
var AjaxQueue = {
batchSize: 1, //No.of simultaneous AJAX requests allowed, Default : 1
urlQueue: [], //Request URLs will be pushed into this array
elementsQueue: [], //Element IDs of elements to be updated on completion of a request ( as in Ajax.Updater )
optionsQueue: [], //Request options will be pushed into this array
setBatchSize: function(bSize){ //Method to set a different batch size. Recommended: Set batchSize before making requests
this.batchSize = bSize;
},
push: function(url, options, elementID){ //Push the request in the queue. elementID is optional and required only for Ajax.Updater calls
this.urlQueue.push(url);
this.optionsQueue.push(options);
if(elementID!=null){
this.elementsQueue.push(elementID);
} else {
this.elementsQueue.push("NOTSPECIFIED");
}
this._processNext();
},
_processNext: function() { // Method for processing the requests in the queue. Private method. Don't call it explicitly
if(Ajax.activeRequestCount < AjaxQueue.batchSize) // Check if the currently processing request count is less than batch size
{
if(AjaxQueue.elementsQueue.first()=="NOTSPECIFIED") { //Check if an elementID was specified
// Call Ajax.Request if no ElementID specified
//Call Ajax.Request on the first item in the queue and remove it from the queue
new Ajax.Request(AjaxQueue.urlQueue.shift(), AjaxQueue.optionsQueue.shift());
var junk = AjaxQueue.elementsQueue.shift();
} else {
// Call Ajax.Updater if an ElementID was specified.
//Call Ajax.Updater on the first item in the queue and remove it from the queue
new Ajax.Updater(AjaxQueue.elementsQueue.shift(), AjaxQueue.urlQueue.shift(), AjaxQueue.optionsQueue.shift());
}
}
}
};
Ajax.Responders.register({
//Call AjaxQueue._processNext on completion ( success / failure) of any AJAX call.
onComplete: AjaxQueue._processNext
});
setPrevLink = function(current){
var link = $('photobox_prev_link');
var imgNext = $('photobox_next_img');
var imgPrev = $('photobox_prev_img');
if (current == 1){
imgPrev.src = '/tmpl/onefamily/img/photobox_prev.gif';
// alert(imgPrev.src);
} else if (current == 2) {
imgPrev.src = '/tmpl/onefamily/img/photobox_prev_active.gif';
// alert(imgPrev.src);
}
}
setNextLink = function(current){
var link = $('photobox_next_link');
var imgNext = $('photobox_next_img');
var imgPrev = $('photobox_prev_img');
if (current == pages){
imgNext.src = '/tmpl/onefamily/img/photobox_next.gif';
// alert(imgNext.src);
} else if (current == pages-1) {
imgNext.src = '/tmpl/onefamily/img/photobox_next_active.gif';
// alert(imgNext.src);
}
}
setNaviLinks = function(current){
// alert(current);
setPrevLink(current);
setNextLink(current);
}
function increaseIndexRec(node,options){
if (!node) return;
if (!node.getAttribute) return;
if (!node.getAttribute('id')) return;
var regexpr = (options && options.regexpr)?options.regexpr:'';
regexpr = (regexpr.length > 0)?new RegExp(regexpr):'';
node = Element.cleanWhitespace(node);
if (node.hasChildNodes && node.hasChildNodes()){
for (var i=0;i 0)?new RegExp(regexpr):'';
node = Element.cleanWhitespace(node);
if (node.hasChildNodes && node.hasChildNodes()){
for (var i=0;i 0 && typeof regexpr == 'string' )?new RegExp(regexpr):regexpr;
node = Element.cleanWhitespace(node);
if (node.hasChildNodes && node.hasChildNodes()){
for (var i=0;i 0){
var oldFuncRegExp = new RegExp(jFunction+'\([^\)]*\)');
var oldFunc = value.match(oldFuncRegExp);
var newFunc = (regexpr.length > 0 && oldFunc.search(regexpr) > -1)?oldFunc.replace(regexpr,replace):oldFunc;
newValue = value.replace(oldFuncRegExp,newFunc);
} else {
newValue = (regexpr.length > 0 && value.search(myregexpr) > -1)?value.replace(myregexpr,replace):value;
}
evalString = 'node[\''+targetattribute+'\'] = function(){'+newValue+'return false;}';
eval(evalString);
// if (attribute == 'onclick'){
// node.onclick = newValue;
// } else {
// node.setAttribute(attribute,newValue);
// }
// alert(node.onclick);
}
}
params2Object = function(options){
var cDivider = (options && options.divider)?options.divider:new Array();
var result = new Array();
tmp = this.split(((cDivider[0])?cDivider[0]:'&'));
for (i=0;i tmpIndex1 || tmpIndex2 < tmpIndex1){
tmpIndex2 = tmpIndex1;
index2 = 0;
++index1;
result[index1] = new Array();
} else {
++index2;
}
result[index1][index2] = value[1];
}
return result;
}
String.prototype.toParamObject = params2Object;
String.prototype.toParamArray = params2Array;
buildNewsTag = function (parameters){
var name = (parameters.name)?parameters.name:'';
var source = (parameters.source)?parameters.source:'';
source = $(source);
var returnString = '';
var params = getFormParams(source);
var paramsObject = new Object();
paramsObject = params.toParamObject();
var id = (paramsObject[name])?paramsObject[name]:'';
var group = (paramsObject[name+'_my_group_id'])?paramsObject[name+'_my_group_id']:'';
var limit = (paramsObject[name+'_my_limit'])?paramsObject[name+'_my_limit']:'';
var random = (paramsObject[name+'_my_random'])?paramsObject[name+'_my_random']:'';
var style = (paramsObject[name+'_my_style'])?paramsObject[name+'_my_style']:'';
/*
$vals[0]['attributes']['GROUP_ID'] = (isset ($params_array[0]) && is_numeric($params_array[0])) ? $params_array[0] : null;
$vals[0]['attributes']['STYLE'] = (isset ($params_array[1])) ? $params_array[1] : null;
$vals[0]['attributes']['LIMIT'] = (isset ($params_array[2])) ? $params_array[2] : null;
$vals[0]['attributes']['RANDOM'] = (isset ($params_array[3])) ? $params_array[3] : null;
*/
returnString = 'NEWS['+group+','+style+','+limit+','+random+']NEWS';
var adv_news = $(name+'_id');
if (adv_news){
adv_news.value=returnString;
} else {
var hidden_string = document.createElement("input");
hidden_string.type = 'hidden';
hidden_string.id = name+'_id';
hidden_string.value = returnString;
hidden_string.name = name;
parent_node = source.parentNode.parentNode;
parent_node.appendChild(hidden_string);
}
return encodeURI(returnString);
}
buildCategoryTag = function (parameters){
var name = (parameters.name)?parameters.name:'';
var source = (parameters.source)?parameters.source:'';
source = $(source);
if (!source) return '';
var returnString = '';
var params = getFormParams(source);
var paramsObject = new Object();
paramsObject = params.toParamObject();
var id = (paramsObject[name])?paramsObject[name]:'';
var site = (paramsObject[name+'_my_site_id'])?paramsObject[name+'_my_site_id']:'';
var type = (paramsObject[name+'_my_type'])?paramsObject[name+'_my_type']:'';
var order = (paramsObject[name+'_my_order'])?paramsObject[name+'_my_order']:'';
var count = (paramsObject[name+'_my_count'])?paramsObject[name+'_my_count']:'';
var template = (paramsObject[name+'_my_template'])?paramsObject[name+'_my_template']:'';
returnString = 'CATEGORYPAGE['+site+','+type+','+order+','+count+','+template+']CATEGORYPAGE';
var adv_cat = $(name+'_id');
if (adv_cat){
adv_cat.value=returnString;
} else {
var hidden_string = document.createElement("input");
hidden_string.type = 'hidden';
hidden_string.id = name+'_id';
hidden_string.value = returnString;
hidden_string.name = name;
parent_node = source.parentNode.parentNode;
parent_node.appendChild(hidden_string);
}
return encodeURI(returnString);
}
buildListTag = function (parameters){
var returnString = '';
var returnHeader = '';
var returnElements = '';
header = (parameters.header)?parameters.header:'';
element = (parameters.values)?parameters.values:'';
rowCount = (parameters.rows)?parameters.rows:'';
colCount = (parameters.cols)?parameters.cols:2;
showHeadline = (parameters.show_headline)?parameters.show_headline:0;
snippet = (parameters.snippet)?parameters.snippet:'';
request_name = (parameters.name)?parameters.name:'';
returnHeader+= snippet+'|'+colCount+'|'+showHeadline;
//LISTEN HEADER
if (typeof header == 'string') header = $(header);
if (header && header.getElementsByTagName){
var params = getFormParams(header,true);
params = params.toArray();
if (params.length > 0){
//var paramsObject = params.toParamArray();
var paramsObject = params;
/*for (var i=0;i0)?',':'';
returnHeader += paramsObject[i][j];
}
}
}*/
for (var i=0;i0)?',':'';
returnElements += paramsObject[i][j];
}
}
}*/
}
returnString = 'ADV_LIST['+returnHeader+returnElements+']ADV_LIST';
var adv_list = $(request_name+'_id');
if (adv_list){
adv_list.value=returnString;
} else {
var hidden_string = document.createElement("input");
hidden_string.type = 'hidden';
hidden_string.id = request_name+'_id';
hidden_string.value = returnString;
hidden_string.name = request_name;
parent_node = element.parentNode.parentNode;
parent_node.appendChild(hidden_string);
}
return encodeURI(returnString);
}
moveToList = function(source,element,globalindex,id){
// element_id = id;
// --element_id;
what = (typeof source == 'string')? $(source):source;
if (typeof where == 'string') where = $(where);
params = getFormParams(what,true);
//clonable = $(element+(element_id));
clonable = $(element);
var tmpNode = clonable.cloneNode(true);
tmpNode.style.display = '';
tmpNode.id = id.replace(/%d/,globalindex);
increaseIndexRec(tmpNode);
increaseNameRec(tmpNode,{regexpr:'\\d+'});
setFunctionIds(tmpNode,{regexpr: id.replace(/%d/,'\\d+'),replace: tmpNode.id});
//increaseIndexRec(what);
synchNode(tmpNode,params);
var p = clonable.parentNode;
p = Element.cleanWhitespace(p);
clonable.nextSibling.appendChild(tmpNode);
}
editListNode = function(node,options){
node = $(node);
var p = node.parentNode;
var params = getFormParams(node,true);
// var paramsObject = params.toArray();
var paramsObject = params.toArray();
//paramsObject = (paramsObject[0])?paramsObject[0]:new Array();
var editElement = (options && options.editElement)?options.editElement:'';
var editId = (options && options.editId)?options.editId:'';
var editName = (options && options.editName)?options.editName:'';
p = Element.cleanWhitespace(p);
editElement = $(editElement);
if (!editElement) return;
var tmpEdit = editElement.cloneNode(true);
tmpEdit.id = node.id.replace(/row/,'edit');
setFunctionIds(tmpEdit,{regexpr: 'asset_list_row_edit',replace: tmpEdit.id});
if (!tmpEdit.getElementsByTagName) return;
var inputs = tmpEdit.getElementsByTagName('input');
for (var i=0; i");
targetStr = targetStr.replace(r, "
");
targetStr = targetStr.replace(n, "
");
targetStr = targetStr.replace(t, " ");
return targetStr;
}
br2newLine = function (targetStr) {
targetStr = targetStr.replace(/
/, "\r\n");
targetStr = targetStr.replace(/
/, "\r\n");
targetStr = targetStr.replace(//, "\r\n");
targetStr = targetStr.replace(/ /, "\t");
return targetStr;
}
String.prototype.toRegExpString = function() { // nicht fuer netscape 4;
return this.replace(/([\^\$\.\*\+\?\=\!\:\|\\\/\(\)\[\]\{\}])/g,"\\$1");
};
function convertVersionString(versionString){
var r = versionString.split('.');
return parseInt(r[0])*100000 + parseInt(r[1])*1000 + parseInt(r[2]);}
function toCursorPointer(e){
e.element().style.cursor='pointer'
};
function toMovePointer(){this.style.cursor='move'};
function toggleElements(elements){
if (!Object.isArray(elements)) return false;
var options = Object.extend({
duration: 0.001,
afterFinish: function(effect) { }
}, arguments[1] || {});
var effects = [];
elements.each(function(e){
e = $(e);
if (e.visible()){
effects.push(new Effect.Fade(e, { sync: true, duration: 0.001 }));
} else {
effects.push(new Effect.Appear(e, { sync: true, duration: 0.001 }));
}
});
new Effect.Parallel(effects,options);
return true
}
function setActive(element){
var element = $(element);
if (!element) return;
var options = Object.extend({
}, arguments[1] || { });
$(element.parentNode).siblings().each(function(e){
if (e.hasClassName('active')) e.removeClassName('active');
});
if (!$(element.parentNode).hasClassName('active')) $(element.parentNode).addClassName('active');
}
/*
**
** File 'domFunctions.js'
**
*/
var cleardiv = document.createElement('div');
cleardiv.setAttribute('class','clear');
cleardiv.appendChild(document.createElement('br'));
function appendAfter(obj,node) {
if (obj.nextSibling) {
obj.parentNode.insertBefore(node,obj.nextSibling);
} else {
obj.parentNode.appendChild(node);
}
}
function appendBefore(obj,node) {
if (obj.nextSibling) {
obj.parentNode.insertBefore(node,obj.nextSibling);
} else {
obj.parentNode.appendChild(node);
}
}
function eval_elements (options) {
var elements;
var element = $((options.id)?options.id:'');
var attrib = (options.attribute)?options.attribute:'onclick';
var excludeInvisible = (options.excludeInvisible)?options.excludeInvisible:true;
var regex = (options.regex)?options.regex:'*';
var precondition = (options.precondition)?options.precondition:'';
var type = (options.type)?options.type:'input';
my_regex = new RegExp(regex);
//alert(Element.inspect(element));
if (element && element.getElementsByTagName ) {
element = Element.cleanWhitespace(element);
elements = element.getElementsByTagName(type);
if (precondition != ''){ precondition = eval(precondition);}
else {precondition == true;}
for (var i=0; i= 0) && (!excludeInvisible || $(e).visible())){
var evaluate = e.getAttribute(attrib);
evaluate = evaluate.replace(/javascript:/,'');
eval(evaluate);
} else if (precondition && is_ie && e && e.getAttribute && e.getAttribute(attrib) && (!excludeInvisible || $(e).visible())){
var evaluate = e.getAttribute(attrib);
eval(evaluate);
}
}
}
}
function synchNode(node,params){
node = $(node);
arrayparams = (params.toArray)? params.toArray():params;
if (!node) return;
if (!node.getAttribute) return;
if (arrayparams.length == 0) return;
var index = new Number();
hidden = node.getElementsByTagName('input');
show = node.getElementsByTagName('div');
for (i=0;i 0)?value:'';
}
}
for (i=0;i 0)?value:' ';
}
}
}
nodeUp = function(node){
node = $(node);
var p = node.parentNode;
p = Element.cleanWhitespace(p);
prev_node = node.previousSibling;
if (prev_node && prev_node.getAttribute && prev_node.getAttribute('id')) {
node.parentNode.insertBefore(node,prev_node);
}
}
nodeDown = function(node){
node = $(node);
var p = node.parentNode;
p = Element.cleanWhitespace(p);
next_node = node.nextSibling;
if (next_node && next_node.getAttribute && next_node.getAttribute('id')) {
node.parentNode.insertBefore(node,next_node.nextSibling);
} else if (next_node && next_node.nextSibling && next_node.nextSibling.getAttribute && next_node.nextSibling.getAttribute('id')){
node.parentNode.insertBefore(node,next_node.nextSibling.nextSibling);
} else {
node.parentNode.appendChild(node);
}
}
switchParentSelectChild = function(node,options){
node = $(node);
var root = $((options && $((options.root))?options.root:''));
if ( !node && !root) return;
if (root && root.cleanWhitespace) root.cleanWhitespace();
if (node && node.cleanWhitespace) node.cleanWhitespace();
if (node){
// Alle Geschwisterknoten ausblenden
nodeSiblings = node.siblings();
nodeSiblings.each(function(n){
if (n.tagName.toLowerCase() == 'div' && n.visible()) n.hide();
});
node.show();
} else {
var childnodes = new Array();
nodes = (root.immediateDescendants)?root.immediateDescendants():new Array();
for (var i=0;i 1) ? (this.imageDim.width/this.containerDim.width) :1;
this.draggable = new Draggable(this.imageEl.id, {
starteffect:false,
reverteffect:false,
endeffect:false,
snap:this.contain.bind(this)
});
var sliderValue = this.slider.value;
this.slider = new Control.Slider(this.handleEl.id, this.trackEl.id, {
axis:'horizontal',
minimum:0,
maximum:Element.getDimensions(this.trackEl).width,
alignX:0,
increment:1,
sliderValue:sliderValue,
onSlide:this.scale.bind(this),
onChange:this.scale.bind(this)
});
this.scale(this.scalefactor);
if (this.containerParent && hidden) {
this.containerParent.hide();
this.containerParent.setStyle({opacity:'1'});
}
},
initialize: function(imageEl, trackEl, handleEl, zoomInEl, zoomOutEl){
this.containerEl = $(imageEl).parentNode;
this.imageEl = $(imageEl);
this.handleEl = $(handleEl);
this.trackEl = $(trackEl);
var hidden = 0;
this.containerParent = this.containerEl.parentNode;
if (this.containerParent && !this.containerParent.visible()) {
hidden = 1;
this.containerParent.setStyle({opacity:'0.1'});
this.containerParent.show();
}
this.containerDim = Element.getDimensions(this.containerEl);
this.imageDim = Element.getDimensions(this.imageEl);
this.imageDim.ratio = this.imageDim.width/this.imageDim.height;
this.floorZoom = 1;
this.ceilingZoom = ((this.imageDim.width/this.containerDim.width) > 1) ? (this.imageDim.width/this.containerDim.width) :1;
this.imageX = 0;
this.imageY = 0;
this.imageZoom = 1;
this.sliderSpeed = 0;
this.sliderAccel = 0;
this.zoomBtnPressed = false;
this.showFull = false;
this.selects = document.getElementsByTagName('select');
this.draggable = new Draggable(imageEl, {
starteffect:false,
reverteffect:false,
endeffect:false,
snap:this.contain.bind(this)
});
this.slider = new Control.Slider(handleEl, trackEl, {
axis:'horizontal',
minimum:0,
maximum:Element.getDimensions(this.trackEl).width,
alignX:0,
increment:1,
sliderValue:0,
onSlide:this.scale.bind(this),
onChange:this.scale.bind(this)
});
this.scale(0.00);
if (this.containerParent && hidden) {
this.containerParent.hide();
this.containerParent.setStyle({opacity:'1'});
}
// Event.observe(this.imageEl, 'dblclick', this.toggleFull.bind(this));
Event.observe($(zoomInEl), 'mousedown', this.startZoomIn.bind(this));
Event.observe($(zoomInEl), 'mouseup', this.stopZooming.bind(this));
Event.observe($(zoomInEl), 'mouseout', this.stopZooming.bind(this));
Event.observe($(zoomOutEl), 'mousedown', this.startZoomOut.bind(this));
Event.observe($(zoomOutEl), 'mouseup', this.stopZooming.bind(this));
Event.observe($(zoomOutEl), 'mouseout', this.stopZooming.bind(this));
},
toggleFull: function () {
this.showFull = !this.showFull;
//TODO: hide selects for IE only
for (i=0; ixMin ? xMin : x;
x = xyMin ? yMin : y;
y = y0)?0:y;
this.imageEl.style.left = this.imageX+'px';
this.imageEl.style.top = this.imageY+'px';
return [x,y];
}
}
/*
**
** File 'kbPrototypes.js'
**
*/
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////// ELEMENT FUNKTIONEN //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
var elemMethods = {
highlightBox: function(element,index){
var boxIndex = index;
var childNodes = $(element).childElements();
childNodes.each(function(value,index){
if ($(value)){
var style = $H($(value).style);
if ($(value).id == 'container'+boxIndex){
$(value).setStyle({borderColor:'#0000ff'});
} else {
$(value).setStyle({borderColor:'#000'});
}
}
});
return $(element);
},
clone: function(element,options){
element = $(element);
if (!(element && element.cloneNode)) return null;
var result = $(element.cloneNode(true));
options = (options)?options:{};
result.writeAttribute((options));
return $(result);
},
incAttribute: function(element,options){
element = $(element);
var offset = options.offset || 0;
var attribute = (options && options.attribute)?options.attribute : 'id';
attributeValue = new String(element.getAttribute(attribute)).replace(/\[\]/,'');
var index = (attributeValue.match(/_\d/))?attributeValue.match(/_\d/):'1';
var postfix = new String(element.getAttribute(attribute)).match(/\[\]/) || '';
if (index && typeof index == 'object'){
index = index.last();
index = index.match(/\d/);
index = new Number(index.last()) + 1;
element.setAttribute(attribute,attributeValue.replace(/_\d/,'_'+(Number(index)+Number(offset))) + postfix);
} else {
element.setAttribute(attribute, attributeValue + '_'+(Number(index)+Number(offset)) + postfix);
}
return $(element);
},
collectValues: function(element){
var result = $H({});
var element = $(element) || $(document.getElementsByTagName("body").item(0));
element.select('input, textarea, select').concat([element]).each(function(e){
var elementname = (e.getAttribute('name'))?e.getAttribute('name'):'';
var value = (e.getAttribute('value'))?e.getAttribute('value'):'';
var type = (e.getAttribute('type'))?e.getAttribute('type'):'';
var nodeType = e.tagName.toLowerCase()
var twoselect = (e.readAttribute('rel') == 'twoselect');
if (elementname == 'action' || type.search(/^(submit|reset|image|button)$/i) != -1) return;
if (!(result.get(elementname) || result.get(elementname+'[]'))) result.set(elementname,[]);
if (type == 'checkbox') value = (e.checked)?1:0;
if (nodeType == 'select'){
$A(e.options).each(function(option){
if (option.selected || twoselect ) {
result.get(elementname).push(option.value);
}
});
} else {
result.get(elementname).push(value);
}
});
result = result.inject($H({}),function (obj, item){
var key = (Object.isArray(item.value) && item.value.length > 1 && item.key.search(/\[\]$/i) == -1)? item.key+'[]' : item.key;
var value = (Object.isArray(item.value) && item.value.length == 1 && item.key.search(/\[\]$/i) == -1)? item.value.first() : item.value;
if (!key.empty()) obj.set(key,value);
return obj;
}).toObject();
return result;
},
clearValues: function(element){
element = $(element);
var element = $(element) || $(document.getElementsByTagName("body").item(0));
element.select('input, textarea, select').concat([element]).each(function(e){
var elementname = (e.getAttribute('name'))?e.getAttribute('name'):'';
var value = (e.getAttribute('value'))?e.getAttribute('value'):'';
var type = (e.getAttribute('type'))?e.getAttribute('type'):'';
var nodeType = e.tagName.toLowerCase()
var twoselect = (e.readAttribute('rel') == 'twoselect');
if (elementname == 'action' || type.search(/^(submit|reset|image|button)$/i) != -1) return;
if (!(result.get(elementname) || result.get(elementname+'[]'))) result.set(elementname,[]);
if (nodeType == 'select'){
$A(e.options).each(function(option){
if (option.selected || twoselect ) {
result.get(elementname).push(option.value);
}
});
} else {
if (type == 'checkbox') e.checked = false;
}
});
return element;
},
getBgColor: function(element){
element = $(element);
var options = Object.extend({
hex: true
}, ((arguments[1] && Object.isString(arguments[1]) && unescape(arguments[1]).isJSON())? unescape(arguments[1]).evalJSON() : (arguments[1] || {} )));
var element = $(element) || $(document.getElementsByTagName("body").item(0));
var result = "transparent";
if (element.getStyle('backgroundColor') != result){
result = element.getStyle('backgroundColor');
} else {
var parent = element.ancestors().find(function(e){
return e.getStyle('backgroundColor') != result;
});
if (parent) result = parent.getStyle('backgroundColor');
}
return result.getColorVersions();
},
/** liefert das erste gefundene eingabe Element zurück
* param Element (nötig für Prototype)
*/
firstInput: function(element){
element = $(element);
return (['input', 'select', 'textarea'].include(element.tagName.toLowerCase())) ? element : element.descendants().find(function(element){
return element.type != 'hidden' && !element.disabled &&['input','select','textarea'] .include(element.tagName.toLowerCase());
});
},
clearFloats:function(element,where){
element = $(element);
var where = (where)? where : 'bottom';
eval('var options = {'+where+': \'\'};');
Element.insert(element,options);
return $(element);
}
};
Element.addMethods(elemMethods);
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////// STRING FUNKTIONEN //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Object.extend(String.prototype,{
/**
* formatiert "style.cssText"-attribut-strings nach einem einheitlichen schema;
*/
cssTextTrim: function(){
return((this.replace(/\s*\:\s*/g,":").replace(/\s*\(\s*/g,"(").replace(/\s*\)\s*/g,")").replace(/\s*,\s*/g,",").replace(/\s*;\s*/g,";").replace(/\s+/g," ").replace(/^\s/,"").replace(/\s$/,"").replace(/;+/g,";").replace(/^;/,"").replace(/;$/,"")+";").toLowerCase());
},
/*
* erzeugt, wenn moeglich, 3 varianten von "cssText" sobald eine "#xxyyzz"- bzw. "rgb(aaa,bbb,ccc)"-anweisung in "cssText" gefunden wird;
* die varianten sind notwendig, um styles auch dann noch eindeutig identifizieren zu koennen, wenn diese z.b. durch den mozilla intern aus dem
* hexadezimalen ":#xxyyzz"- in das dezimale "rgb(aaa,bbb,ccc)"-format umgerechnet, oder falls styles mit mischungen aus diesen beiden formaten
* versehen wurden, oder aber wenn anwender die kurzschreibweise fuer das hexadezimale format beutzen - statt "#ffcc00" eben "#fc0";
* varianten:
* rgb(255,204,0) - /rgb\s*\(\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*\)/i - mit RegExp.$1,RegExp.$21,RegExp.$3;
* #ffcc00 - /#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})/i - mit RegExp.$1,RegExp.$21,RegExp.$3;
* #fc0 - /#([0-9a-f]{1})([0-9a-f]{1})([0-9a-f]{1})([;\s])/i - mit RegExp.$1,RegExp.$21,RegExp.$3,RegExp.$4;
*
* @return der rueckgabewert ist ein objekt mit den eigenschaften "rgb", "hex" und "half"; ("short" ist im javascript-sprachraum ein reserviertes wort)
*/
getColorVersions: function(){
var cssText = this.cssTextTrim(); // formatiert "style.cssText"-attribut-strings nach einem einheitlichen schema;
var versions = null;
if ((cssText.search(/rgb\s*\(\s*[0-9]{1,3}\s*,\s*[0-9]{1,3}\s*,\s*[0-9]{1,3}\s*\)/i) >= 0) || (cssText.search(/#[0-9a-f]{1}[0-9a-f]{1}[0-9a-f]{1}[;\s]/i) >= 0) || (cssText.search(/#[0-9a-f]{2}[0-9a-f]{2}[0-9a-f]{2}/i) >= 0)) {
var regX = null, regX_$1 = "", regX_$2 = "", regX_$3 = "", regX_$4 = "";
versions = {}; // alle moeglichen farbschemata:
versions.rgb = null; // - dezimale schreibweise mit "rgb"-praefix;
versions.hex = null; // - klassische hexadezimal-schreibweise;
versions.half = null; // - halbe hexadezimal-schreibweise;
versions.cleanHex = null; // - klassische hexadezimal-schreibweise ohne #;
// - als ausgangsbasis fuer cssText dient die dezimale schreibweise mit "rgb"-praefix;
// - diese grundlage muss unter umstaenden erst einmal geschaffen werden;
// - die 3 moeglichen varianten werden dann vom ur-style abgeleitet;
regX = /#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})/i;
while (regX.test(cssText)) {
regX.exec(cssText);
regX_$1 = parseInt(RegExp.$1,16);
regX_$2 = parseInt(RegExp.$2,16);
regX_$3 = parseInt(RegExp.$3,16);
cssText = cssText.replace(regX,("rgb(" + regX_$1 + "," + regX_$2 + "," + regX_$3 + ")"));
}
regX = /#([0-9a-f]{1})([0-9a-f]{1})([0-9a-f]{1})([;\s])/i;
while (regX.test(cssText)) {
regX.exec(cssText);
regX_$1 = parseInt((RegExp.$1 + RegExp.$1),16);
regX_$2 = parseInt((RegExp.$2 + RegExp.$2),16);
regX_$3 = parseInt((RegExp.$3 + RegExp.$3),16);
regX_$4 = RegExp.$4;
cssText = cssText.replace(regX,("rgb(" + regX_$1 + "," + regX_$2 + "," + regX_$3 + ")" + regX_$4));
}
//alert("]" + cssText + "[");
versions.rgb = cssText; // "cssText"-basis !!
regX = /rgb\s*\(\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*\)/i;
while (regX.test(cssText)) {
regX.exec(cssText);
regX_$1 = parseInt(RegExp.$1).toString(16);regX_$1 = ((regX_$1.length == 1) ? ("0" + regX_$1) : (regX_$1));
regX_$2 = parseInt(RegExp.$2).toString(16);regX_$2 = ((regX_$2.length == 1) ? ("0" + regX_$2) : (regX_$2));
regX_$3 = parseInt(RegExp.$3).toString(16);regX_$3 = ((regX_$3.length == 1) ? ("0" + regX_$3) : (regX_$3));
cssText = cssText.replace(regX,("#" + regX_$1 + regX_$2 + regX_$3));
}
versions.hex = cssText;
cssText = versions.rgb;
while (regX.test(cssText)) {
regX.exec(cssText);
regX_$1 = parseInt(RegExp.$1).toString(16);regX_$1 = ((regX_$1.length == 1) ? ("0" + regX_$1) : (regX_$1));
regX_$2 = parseInt(RegExp.$2).toString(16);regX_$2 = ((regX_$2.length == 1) ? ("0" + regX_$2) : (regX_$2));
regX_$3 = parseInt(RegExp.$3).toString(16);regX_$3 = ((regX_$3.length == 1) ? ("0" + regX_$3) : (regX_$3));
if ((regX_$1.charAt(0) == regX_$1.charAt(1)) && (regX_$2.charAt(0) == regX_$2.charAt(1)) && (regX_$3.charAt(0) == regX_$3.charAt(1))) {
cssText = cssText.replace(regX,("#" + regX_$1.charAt(0) + regX_$2.charAt(0) + regX_$3.charAt(0)));
} else {
cssText = cssText.replace(regX,("#" + regX_$1 + regX_$2 + regX_$3));
}
}
versions.half = cssText;
versions.cleanHex = versions.hex.match(/[\dabcdef]{3,6}/).first();
}
return versions;
},
/**
* Sucht nach übereinstimmenden Tags im String und gibt den Inhalt des Tags zurück
* @param {String} id
* @return String innerHTML
*/
getInnerHtml: function (n) {
secure = 4000; /* SicherheitsZähler der zur Not die schleife abbricht... */
// Wennn String eine ganze HTML Seite enthält wird im Fehlerfall ein leerer String Zurückgegeben,
// sonst der String selbst
var errorResult = (this.search(/]*>/) > -1 || this.search(/]*>/) > -1 || this.search(/]*>/) > -1)? '' : this;
typeExpr = new RegExp("<([a-zA-Z]*)[^>]*id=."+n+"[^>]*>");
if ((n.length == 0) || (this.indexOf(n) == -1) || this.search(typeExpr) == -1) return (errorResult);
type = this.match(typeExpr)[1];
var front = ''
var end = ''
if (type == null || type == undefined) return false;
startExpression = new RegExp("<"+type+"[^>]*id=."+n+"[^>]*>");
startDivExp = new RegExp("<"+type+"[^>]*>");
endDivExp = new RegExp("");
startTag = new String(this.match(startExpression));
startIndex = this.search(startTag) + startTag.length;
var txt = new String(this.substr(startIndex)).replace(//,'');
endMatch = txt.match(endDivExp);
endIndex = 6 + txt.search(endDivExp);
front = txt.substr(0,endIndex);
end = txt.substr(endIndex);
var lastIndex = endIndex;
startMatch = front.split('<'+type);
frontCount = 0;
if (startMatch != null){
startMatch = startMatch.uniq();
frontCount += startMatch.length-1;
}
while (frontCount > 0 && --secure){
endMatch = end.match(endDivExp);
endIndex = 6 + end.search(endDivExp);
lastIndex += endIndex;
front = end.substr(0,endIndex);
end = end.substr(endIndex);
startMatch = front.split('<'+type);
if (startMatch != null){
startMatch = startMatch.uniq();
frontCount += startMatch.length-1;
}
frontCount--;
}
result = txt.substr(0,lastIndex-(''.length));
return result;
},
addslashes: function() {
var str = this;
str = str.replace(/\'/g,'\\\'');
str = str.replace(/\"/g,'\\"');
str = str.replace(/\\/g,'\\\\');
str = str.replace(/\0/g,'\\0');
return str;
},
stripslashes: function() {
var str = this;
str=str.replace(/\\'/g,'\'');
str=str.replace(/\\"/g,'"');
str=str.replace(/\\\\/g,'\\');
str=str.replace(/\\0/g,'\0');
return str;
},
maskRegExpString: function() { // nicht fuer netscape 4;
return this.replace(/([\^\$\.\*\+\?\=\!\:\|\\\/\(\)\[\]\{\}])/g,"\\$1");
}
});
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////// WRAPPER FUNKTIONEN //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Element.update = Element.update.wrap(
function(proceed, element, contents) {
element = proceed(element, contents);
if ($(element)) $(element).fire("content:changed");
return $(element);
}
);
/*
**
** File 'kbEvents.js'
**
*/
/**
* Kuborgh Eventverwaltung
*/
var KuborghEvents = {
events : $H({}),
submitStop: 0,
/**
* Registriert ein Formelement. Läd gegebenfalls die zugehörige JS Datei nach
* @param {Object} Object
*/
require: function(){
// Extend default options
var options = Object.extend({
libraryName:'',
libraryPath:'',
id:'',
lang_code: 'de',
type: ''
}, ((arguments[0] && Object.isString(arguments[0]) && unescape(arguments[0]).isJSON())? unescape(arguments[0]).evalJSON() : (arguments[0] || {} )));
var init = false;
if (!this.isRegistered(options)){
try {
eval('Object.isUndefined('+ options.libraryName+ ');');
} catch (e) {
//alert(e);
document.write('