/*
**
** File 'functions.utf8.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 = {};
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(new RegExp(decode('%A7%A7'),'gi'), '"');
text = text.replace(new RegExp(decode('%26lt%3B'),'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 (unescape('Bitte w%E4hle eine ' + field + ' durch Anklicken des Kreises vor der Option.'));
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
function xorCrypt(text) {
key = "123456789123456789123456789123456789123456789123456789";
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 + unescape("- Bitte pr%FCfen Sie Ihre Email-Adresse auf G%FCltigkeit (oder lassen Sie das Feld ganz leer).");
}
if (error.length != 0) {
alert(unescape("Folgende Felder sind nicht oder nicht korrekt ausgef%FCllt:\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(new RegExp(unescape("%E4"),"g"),'ae');
str = str.replace(new RegExp(unescape("%F6"),"g"),'oe');
str = str.replace(new RegExp(unescape("%FC"),"g"),'ue');
str = str.replace(new RegExp(unescape("%C4"),"g"),'Ae');
str = str.replace(new RegExp(unescape("%D6"),"g"),'Oe');
str = str.replace(new RegExp(unescape("%DC"),"g"),'Ue');
str = str.replace(new RegExp(unescape("%DF"),"g"),'ss');
restr = unescape("%5C%24%7C%2C%7C%B4%7C%B0%7C%40%7C%23%7C%C4%7C%A7%7C%5C%2F%7C%D6%7C%DC%7C%E4%7C%F6%7C%FC%7C%DF%7C %7C~%7C%60%7C%5C%25%7C%5C*%7C%5C%5E%7C%5C%26%7C%5C(%7C%5C)%7C%5C%2B%7C%5C%3D%7C%5C%5B%7C%5C%5D%7C%5C%7D%7C%5C%7B%7C%5C%3B%7C%5C%3A%7C%5C'%7C%5C%22%7C%5C%3C%7C%5C%3E%7C%5C%3F%7C%5C%7C%7C%5C%5C%7C%5C!%7C%5C%24%7C%5C.");
// Entspricht "\$|,|´|°|@|#|Ä|§|\/|Ö|Ü|ä|ö|ü|ß| |~|`|\%|\*|\^|\&|\(|\)|\+|\=|\[|\]|\}|\{|\;|\:|\'|\"|\<|\>|\?|\||\\|\!|\$|\."
// Wichtig: nach urlencode das + gegen leerzeichern austauschen
re = new RegExp(restr,"g");
// 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,version, wmode)
{
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;
if (!wmode)
wmode=0;
this.wmode = wmode; // 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,
WebKit: navigator.userAgent.indexOf('AppleWebKit/') > -1,
Gecko: navigator.userAgent.indexOf('Gecko') > -1 &&
navigator.userAgent.indexOf('KHTML') === -1,
MobileSafari: !!navigator.userAgent.match(/Apple.*Mobile.*Safari/)
},
BrowserFeatures: {
XPath: !!document.evaluate,
SelectorsAPI: !!document.querySelector,
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;
var Abstract = { };
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;
}
};
/* Based on Alex Arnell's inheritance implementation. */
var Class = (function() {
function create() {
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;
}
function addMethods(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 = (function(m) {
return function() { return ancestor[m].apply(this, arguments); };
})(property).wrap(method);
value.valueOf = method.valueOf.bind(method);
value.toString = method.toString.bind(method);
}
this.prototype[property] = value;
}
return this;
}
return {
create: create,
Methods: {
addMethods: addMethods
}
};
})();
(function() {
function getClass(object) {
return Object.prototype.toString.call(object)
.match(/^\[object\s(.*)\]$/)[1];
}
function extend(destination, source) {
for (var property in source)
destination[property] = source[property];
return destination;
}
function inspect(object) {
try {
if (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;
}
}
function toJSON(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 (isElement(object)) return;
var results = [];
for (var property in object) {
var value = toJSON(object[property]);
if (!isUndefined(value))
results.push(property.toJSON() + ': ' + value);
}
return '{' + results.join(', ') + '}';
}
function toQueryString(object) {
return $H(object).toQueryString();
}
function toHTML(object) {
return object && object.toHTML ? object.toHTML() : String.interpret(object);
}
function keys(object) {
var results = [];
for (var property in object)
results.push(property);
return results;
}
function values(object) {
var results = [];
for (var property in object)
results.push(object[property]);
return results;
}
function clone(object) {
return extend({ }, object);
}
function isElement(object) {
return !!(object && object.nodeType == 1);
}
function isArray(object) {
return getClass(object) === "Array";
}
function isHash(object) {
return object instanceof Hash;
}
function isFunction(object) {
return typeof object === "function";
}
function isString(object) {
return getClass(object) === "String";
}
function isNumber(object) {
return getClass(object) === "Number";
}
function isUndefined(object) {
return typeof object === "undefined";
}
extend(Object, {
extend: extend,
inspect: inspect,
toJSON: toJSON,
toQueryString: toQueryString,
toHTML: toHTML,
keys: keys,
values: values,
clone: clone,
isElement: isElement,
isArray: isArray,
isHash: isHash,
isFunction: isFunction,
isString: isString,
isNumber: isNumber,
isUndefined: isUndefined
});
})();
Object.extend(Function.prototype, (function() {
var slice = Array.prototype.slice;
function update(array, args) {
var arrayLength = array.length, length = args.length;
while (length--) array[arrayLength + length] = args[length];
return array;
}
function merge(array, args) {
array = slice.call(array, 0);
return update(array, args);
}
function argumentNames() {
var names = this.toString().match(/^[\s\(]*function[^(]*\(([^)]*)\)/)[1]
.replace(/\/\/.*?[\r\n]|\/\*(?:.|[\r\n])*?\*\//g, '')
.replace(/\s+/g, '').split(',');
return names.length == 1 && !names[0] ? [] : names;
}
function bind(context) {
if (arguments.length < 2 && Object.isUndefined(arguments[0])) return this;
var __method = this, args = slice.call(arguments, 1);
return function() {
var a = merge(args, arguments);
return __method.apply(context, a);
}
}
function bindAsEventListener(context) {
var __method = this, args = slice.call(arguments, 1);
return function(event) {
var a = update([event || window.event], args);
return __method.apply(context, a);
}
}
function curry() {
if (!arguments.length) return this;
var __method = this, args = slice.call(arguments, 0);
return function() {
var a = merge(args, arguments);
return __method.apply(this, a);
}
}
function delay(timeout) {
var __method = this, args = slice.call(arguments, 1);
timeout = timeout * 1000
return window.setTimeout(function() {
return __method.apply(__method, args);
}, timeout);
}
function defer() {
var args = update([0.01], arguments);
return this.delay.apply(this, args);
}
function wrap(wrapper) {
var __method = this;
return function() {
var a = update([__method.bind(this)], arguments);
return wrapper.apply(this, a);
}
}
function methodize() {
if (this._methodized) return this._methodized;
var __method = this;
return this._methodized = function() {
var a = update([this], arguments);
return __method.apply(null, a);
};
}
return {
argumentNames: argumentNames,
bind: bind,
bindAsEventListener: bindAsEventListener,
curry: curry,
delay: delay,
defer: defer,
wrap: wrap,
methodize: methodize
}
})());
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"';
};
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, (function() {
function prepareReplacement(replacement) {
if (Object.isFunction(replacement)) return replacement;
var template = new Template(replacement);
return function(match) { return template.evaluate(match) };
}
function gsub(pattern, replacement) {
var result = '', source = this, match;
replacement = 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;
}
function sub(pattern, replacement, count) {
replacement = prepareReplacement(replacement);
count = Object.isUndefined(count) ? 1 : count;
return this.gsub(pattern, function(match) {
if (--count < 0) return match[0];
return replacement(match);
});
}
function scan(pattern, iterator) {
this.gsub(pattern, iterator);
return String(this);
}
function truncate(length, truncation) {
length = length || 30;
truncation = Object.isUndefined(truncation) ? '...' : truncation;
return this.length > length ?
this.slice(0, length - truncation.length) + truncation : String(this);
}
function strip() {
return this.replace(/^\s+/, '').replace(/\s+$/, '');
}
function stripTags() {
return this.replace(/<\/?[^>]+>/gi, '');
}
function stripScripts() {
return this.replace(new RegExp(Prototype.ScriptFragment, 'img'), '');
}
function extractScripts() {
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];
});
}
function evalScripts() {
return this.extractScripts().map(function(script) { return eval(script) });
}
function escapeHTML() {
escapeHTML.text.data = this;
return escapeHTML.div.innerHTML;
}
function unescapeHTML() {
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) : '';
}
function toQueryParams(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;
});
}
function toArray() {
return this.split('');
}
function succ() {
return this.slice(0, this.length - 1) +
String.fromCharCode(this.charCodeAt(this.length - 1) + 1);
}
function times(count) {
return count < 1 ? '' : new Array(count + 1).join(this);
}
function camelize() {
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;
}
function capitalize() {
return this.charAt(0).toUpperCase() + this.substring(1).toLowerCase();
}
function underscore() {
return this.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'#{1}_#{2}').gsub(/([a-z\d])([A-Z])/,'#{1}_#{2}').gsub(/-/,'_').toLowerCase();
}
function dasherize() {
return this.gsub(/_/,'-');
}
function inspect(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, '\\\'') + "'";
}
function toJSON() {
return this.inspect(true);
}
function unfilterJSON(filter) {
return this.sub(filter || Prototype.JSONFilter, '#{1}');
}
function isJSON() {
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);
}
function evalJSON(sanitize) {
var json = this.unfilterJSON();
try {
if (!sanitize || json.isJSON()) return eval('(' + json + ')');
} catch (e) { }
throw new SyntaxError('Badly formed JSON string: ' + this.inspect());
}
function include(pattern) {
return this.indexOf(pattern) > -1;
}
function startsWith(pattern) {
return this.indexOf(pattern) === 0;
}
function endsWith(pattern) {
var d = this.length - pattern.length;
return d >= 0 && this.lastIndexOf(pattern) === d;
}
function empty() {
return this == '';
}
function blank() {
return /^\s*$/.test(this);
}
function interpolate(object, pattern) {
return new Template(this, pattern).evaluate(object);
}
return {
gsub: gsub,
sub: sub,
scan: scan,
truncate: truncate,
strip: strip,
stripTags: stripTags,
stripScripts: stripScripts,
extractScripts: extractScripts,
evalScripts: evalScripts,
escapeHTML: escapeHTML,
unescapeHTML: unescapeHTML,
toQueryParams: toQueryParams,
parseQuery: toQueryParams,
toArray: toArray,
succ: succ,
times: times,
camelize: camelize,
capitalize: capitalize,
underscore: underscore,
dasherize: dasherize,
inspect: inspect,
toJSON: toJSON,
unfilterJSON: unfilterJSON,
isJSON: isJSON,
evalJSON: evalJSON,
include: include,
startsWith: startsWith,
endsWith: endsWith,
empty: empty,
blank: blank,
interpolate: interpolate
};
})());
if (Prototype.Browser.WebKit || Prototype.Browser.IE) Object.extend(String.prototype, {
escapeHTML: function() {
return this.replace(/&/g,'&').replace(//g,'>');
},
unescapeHTML: function() {
return this.stripTags().replace(/&/g,'&').replace(/</g,'<').replace(/>/g,'>');
}
});
Object.extend(String.prototype.escapeHTML, {
div: document.createElement('div'),
text: document.createTextNode('')
});
String.prototype.escapeHTML.div.appendChild(String.prototype.escapeHTML.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 = (function() {
function each(iterator, context) {
var index = 0;
try {
this._each(function(value) {
iterator.call(context, value, index++);
});
} catch (e) {
if (e != $break) throw e;
}
return this;
}
function eachSlice(number, iterator, context) {
var index = -number, slices = [], array = this.toArray();
if (number < 1) return array;
while ((index += number) < array.length)
slices.push(array.slice(index, index+number));
return slices.collect(iterator, context);
}
function all(iterator, context) {
iterator = iterator || Prototype.K;
var result = true;
this.each(function(value, index) {
result = result && !!iterator.call(context, value, index);
if (!result) throw $break;
});
return result;
}
function any(iterator, context) {
iterator = iterator || Prototype.K;
var result = false;
this.each(function(value, index) {
if (result = !!iterator.call(context, value, index))
throw $break;
});
return result;
}
function collect(iterator, context) {
iterator = iterator || Prototype.K;
var results = [];
this.each(function(value, index) {
results.push(iterator.call(context, value, index));
});
return results;
}
function detect(iterator, context) {
var result;
this.each(function(value, index) {
if (iterator.call(context, value, index)) {
result = value;
throw $break;
}
});
return result;
}
function findAll(iterator, context) {
var results = [];
this.each(function(value, index) {
if (iterator.call(context, value, index))
results.push(value);
});
return results;
}
function grep(filter, iterator, context) {
iterator = iterator || Prototype.K;
var results = [];
if (Object.isString(filter))
filter = new RegExp(RegExp.escape(filter));
this.each(function(value, index) {
if (filter.match(value))
results.push(iterator.call(context, value, index));
});
return results;
}
function include(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;
}
function inGroupsOf(number, fillWith) {
fillWith = Object.isUndefined(fillWith) ? null : fillWith;
return this.eachSlice(number, function(slice) {
while(slice.length < number) slice.push(fillWith);
return slice;
});
}
function inject(memo, iterator, context) {
this.each(function(value, index) {
memo = iterator.call(context, memo, value, index);
});
return memo;
}
function invoke(method) {
var args = $A(arguments).slice(1);
return this.map(function(value) {
return value[method].apply(value, args);
});
}
function max(iterator, context) {
iterator = iterator || Prototype.K;
var result;
this.each(function(value, index) {
value = iterator.call(context, value, index);
if (result == null || value >= result)
result = value;
});
return result;
}
function min(iterator, context) {
iterator = iterator || Prototype.K;
var result;
this.each(function(value, index) {
value = iterator.call(context, value, index);
if (result == null || value < result)
result = value;
});
return result;
}
function partition(iterator, context) {
iterator = iterator || Prototype.K;
var trues = [], falses = [];
this.each(function(value, index) {
(iterator.call(context, value, index) ?
trues : falses).push(value);
});
return [trues, falses];
}
function pluck(property) {
var results = [];
this.each(function(value) {
results.push(value[property]);
});
return results;
}
function reject(iterator, context) {
var results = [];
this.each(function(value, index) {
if (!iterator.call(context, value, index))
results.push(value);
});
return results;
}
function sortBy(iterator, context) {
return this.map(function(value, index) {
return {
value: value,
criteria: iterator.call(context, value, index)
};
}).sort(function(left, right) {
var a = left.criteria, b = right.criteria;
return a < b ? -1 : a > b ? 1 : 0;
}).pluck('value');
}
function toArray() {
return this.map();
}
function zip() {
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));
});
}
function size() {
return this.toArray().length;
}
function inspect() {
return '#';
}
return {
each: each,
eachSlice: eachSlice,
all: all,
every: all,
any: any,
some: any,
collect: collect,
map: collect,
detect: detect,
findAll: findAll,
select: findAll,
filter: findAll,
grep: grep,
include: include,
member: include,
inGroupsOf: inGroupsOf,
inject: inject,
invoke: invoke,
max: max,
min: min,
partition: partition,
pluck: pluck,
reject: reject,
sortBy: sortBy,
toArray: toArray,
entries: toArray,
zip: zip,
size: size,
inspect: inspect,
find: detect
};
})();
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 [];
// In Safari, only use the `toArray` method if it's not a NodeList.
// A NodeList is a function, has an function `item` property, and a numeric
// `length` property. Adapted from Google Doctype.
if (!(typeof iterable === 'function' && typeof iterable.length ===
'number' && typeof iterable.item === 'function') && iterable.toArray)
return iterable.toArray();
var length = iterable.length || 0, results = new Array(length);
while (length--) results[length] = iterable[length];
return results;
};
}
function $w(string) {
if (!Object.isString(string)) return [];
string = string.strip();
return string ? string.split(/\s+/) : [];
}
Array.from = $A;
(function() {
var arrayProto = Array.prototype,
slice = arrayProto.slice,
_each = arrayProto.forEach; // use native browser JS 1.6 implementation if available
function each(iterator) {
for (var i = 0, length = this.length; i < length; i++)
iterator(this[i]);
}
if (!_each) _each = each;
function clear() {
this.length = 0;
return this;
}
function first() {
return this[0];
}
function last() {
return this[this.length - 1];
}
function compact() {
return this.select(function(value) {
return value != null;
});
}
function flatten() {
return this.inject([], function(array, value) {
if (Object.isArray(value))
return array.concat(value.flatten());
array.push(value);
return array;
});
}
function without() {
var values = slice.call(arguments, 0);
return this.select(function(value) {
return !values.include(value);
});
}
function reverse(inline) {
return (inline !== false ? this : this.toArray())._reverse();
}
function reduce() {
return this.length > 1 ? this : this[0];
}
function uniq(sorted) {
return this.inject([], function(array, value, index) {
if (0 == index || (sorted ? array.last() != value : !array.include(value)))
array.push(value);
return array;
});
}
function intersect(array) {
return this.uniq().findAll(function(item) {
return array.detect(function(value) { return item === value });
});
}
function clone() {
return slice.call(this, 0);
}
function size() {
return this.length;
}
function inspect() {
return '[' + this.map(Object.inspect).join(', ') + ']';
}
function toJSON() {
var results = [];
this.each(function(object) {
var value = Object.toJSON(object);
if (!Object.isUndefined(value)) results.push(value);
});
return '[' + results.join(', ') + ']';
}
function indexOf(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;
}
function lastIndexOf(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;
}
function concat() {
var array = slice.call(this, 0), item;
for (var i = 0, length = arguments.length; i < length; i++) {
item = arguments[i];
if (Object.isArray(item) && !('callee' in item)) {
for (var j = 0, arrayLength = item.length; j < arrayLength; j++)
array.push(item[j]);
} else {
array.push(item);
}
}
return array;
}
Object.extend(arrayProto, Enumerable);
if (!arrayProto._reverse)
arrayProto._reverse = arrayProto.reverse;
Object.extend(arrayProto, {
_each: _each,
clear: clear,
first: first,
last: last,
compact: compact,
flatten: flatten,
without: without,
reverse: reverse,
reduce: reduce,
uniq: uniq,
intersect: intersect,
clone: clone,
toArray: clone,
size: size,
inspect: inspect,
toJSON: toJSON
});
// fix for opera
var CONCAT_ARGUMENTS_BUGGY = (function() {
return [].concat(arguments)[0][0] !== 1;
})(1,2)
if (CONCAT_ARGUMENTS_BUGGY) arrayProto.concat = concat;
// use native browser JS 1.6 implementation if available
if (!arrayProto.indexOf) arrayProto.indexOf = indexOf;
if (!arrayProto.lastIndexOf) arrayProto.lastIndexOf = lastIndexOf;
})();
function $H(object) {
return new Hash(object);
};
var Hash = Class.create(Enumerable, (function() {
function initialize(object) {
this._object = Object.isHash(object) ? object.toObject() : Object.clone(object);
}
function _each(iterator) {
for (var key in this._object) {
var value = this._object[key], pair = [key, value];
pair.key = key;
pair.value = value;
iterator(pair);
}
}
function set(key, value) {
return this._object[key] = value;
}
function get(key) {
// simulating poorly supported hasOwnProperty
if (this._object[key] !== Object.prototype[key])
return this._object[key];
}
function unset(key) {
var value = this._object[key];
delete this._object[key];
return value;
}
function toObject() {
return Object.clone(this._object);
}
function keys() {
return this.pluck('key');
}
function values() {
return this.pluck('value');
}
function index(value) {
var match = this.detect(function(pair) {
return pair.value === value;
});
return match && match.key;
}
function merge(object) {
return this.clone().update(object);
}
function update(object) {
return new Hash(object).inject(this, function(result, pair) {
result.set(pair.key, pair.value);
return result;
});
}
function toQueryPair(key, value) {
if (Object.isUndefined(value)) return key;
return key + '=' + encodeURIComponent(String.interpret(value));
}
function toQueryString() {
return this.inject([], function(results, pair) {
var key = encodeURIComponent(pair.key), values = pair.value;
if (values && typeof values == 'object') {
if (Object.isArray(values))
return results.concat(values.map(toQueryPair.curry(key)));
} else results.push(toQueryPair(key, values));
return results;
}).join('&');
}
function inspect() {
return '#';
}
function toJSON() {
return Object.toJSON(this.toObject());
}
function clone() {
return new Hash(this);
}
return {
initialize: initialize,
_each: _each,
set: set,
get: get,
unset: unset,
toObject: toObject,
toTemplateReplacements: toObject,
keys: keys,
values: values,
index: index,
merge: merge,
update: update,
toQueryString: toQueryString,
inspect: inspect,
toJSON: toJSON,
clone: clone
};
})());
Hash.from = $H;
Object.extend(Number.prototype, (function() {
function toColorPart() {
return this.toPaddedString(2, 16);
}
function succ() {
return this + 1;
}
function times(iterator, context) {
$R(0, this, true).each(iterator, context);
return this;
}
function toPaddedString(length, radix) {
var string = this.toString(radix || 10);
return '0'.times(length - string.length) + string;
}
function toJSON() {
return isFinite(this) ? this.toString() : 'null';
}
function abs() {
return Math.abs(this);
}
function round() {
return Math.round(this);
}
function ceil() {
return Math.ceil(this);
}
function floor() {
return Math.floor(this);
}
return {
toColorPart: toColorPart,
succ: succ,
times: times,
toPaddedString: toPaddedString,
toJSON: toJSON,
abs: abs,
round: round,
ceil: ceil,
floor: floor
};
})());
function $R(start, end, exclusive) {
return new ObjectRange(start, end, exclusive);
}
var ObjectRange = Class.create(Enumerable, (function() {
function initialize(start, end, exclusive) {
this.start = start;
this.end = end;
this.exclusive = exclusive;
}
function _each(iterator) {
var value = this.start;
while (this.include(value)) {
iterator(value);
value = value.succ();
}
}
function include(value) {
if (value < this.start)
return false;
if (this.exclusive)
return value < this.end;
return value <= this.end;
}
return {
initialize: initialize,
_each: _each,
include: include
};
})());
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(global) {
var element = global.Element;
global.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(global.Element, element || { });
if (element) global.Element.prototype = element.prototype;
})(this);
Element.cache = { };
Element.idCounter = 1;
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 = $(element);
element.style.display = 'none';
return element;
},
show: function(element) {
element = $(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(element, 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');
if (id) return id;
do { id = 'anonymous_element_' + Element.idCounter++ } 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);
if (element.compareDocumentPosition)
return (element.compareDocumentPosition(ancestor) & 8) === 8;
if (ancestor.contains)
return ancestor.contains(element) && ancestor !== element;
while (element = element.parentNode)
if (element == ancestor) 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 || value == 'auto') {
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 (Prototype.Browser.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.toUpperCase() == '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 element;
// 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 element;
// 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);
if(element.tagName.toUpperCase()=='HTML') //for IE6,7
return $(document.body);
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 && (element.tagName.toUpperCase() == '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;
}
};
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);
// IE throws an error if element is not in document
try { element.offsetParent }
catch(e) { return $(document.body) }
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);
try { element.offsetParent }
catch(e) { return Element._returnOffset(0,0) }
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.cumulativeOffset = Element.Methods.cumulativeOffset.wrap(
function(proceed, element) {
try { element.offsetParent }
catch(e) { return Element._returnOffset(0,0) }
return proceed(element);
}
);
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 frameBorder').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.toUpperCase() == '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.toUpperCase(), 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() {
return { width: this.getWidth(), height: this.getHeight() };
},
getScrollOffsets: function() {
return Element._returnOffset(
window.pageXOffset || document.documentElement.scrollLeft || document.body.scrollLeft,
window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop);
}
};
(function(viewport) {
var B = Prototype.Browser, doc = document, element, property = {};
function getRootElement() {
// Older versions of Safari.
if (B.WebKit && !doc.evaluate)
return document;
// Older versions of Opera.
if (B.Opera && window.parseFloat(window.opera.version()) < 9.5)
return document.body;
return document.documentElement;
}
function define(D) {
if (!element) element = getRootElement();
property[D] = 'client' + D;
viewport['get' + D] = function() { return element[property[D]] };
return viewport['get' + D]();
}
viewport.getWidth = define.curry('Width');
viewport.getHeight = define.curry('Height');
})(document.viewport);
Element.Storage = {
UID: 1
};
Element.addMethods({
getStorage: function(element) {
if (!(element = $(element))) return;
var uid;
if (element === window) {
uid = 0;
} else {
if (Object.isUndefined(element._prototypeUID))
element._prototypeUID = [Element.Storage.UID++];
uid = element._prototypeUID[0];
}
if (!Element.Storage[uid])
Element.Storage[uid] = $H();
return Element.Storage[uid];
},
store: function(element, key, value) {
if (!(element = $(element))) return;
if (arguments.length === 2) {
// Assume we've been passed an object full of key/value pairs.
element.getStorage().update(key);
} else {
element.getStorage().set(key, value);
}
return element;
},
retrieve: function(element, key, defaultValue) {
if (!(element = $(element))) return;
var hash = Element.getStorage(element), value = hash.get(key);
if (Object.isUndefined(value)) {
hash.set(key, defaultValue);
value = defaultValue;
}
return value;
}
});
/* 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();
if (this.shouldUseSelectorsAPI()) {
this.mode = 'selectorsAPI';
} else if (this.shouldUseXPath()) {
this.mode = 'xpath';
this.compileXPathMatcher();
} else {
this.mode = "normal";
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(e))
return false;
return true;
},
shouldUseSelectorsAPI: function() {
if (!Prototype.BrowserFeatures.SelectorsAPI) return false;
if (Selector.CASE_INSENSITIVE_CLASS_NAMES) return false;
if (!Selector._div) Selector._div = new Element('div');
// Make sure the browser treats the selector as valid. Test on an
// isolated element to minimize cost of this check.
try {
Selector._div.querySelector(this.expression);
} catch(e) {
return false;
}
return true;
},
compileMatcher: function() {
var e = this.expression, ps = Selector.patterns, h = Selector.handlers,
c = Selector.criteria, le, p, m, len = ps.length, name;
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 = 0; i";
}
});
if (Prototype.BrowserFeatures.SelectorsAPI &&
document.compatMode === 'BackCompat') {
// Versions of Safari 3 before 3.1.2 treat class names case-insensitively in
// quirks mode. If we detect this behavior, we should use a different
// approach.
Selector.CASE_INSENSITIVE_CLASS_NAMES = (function(){
var div = document.createElement('div'),
span = document.createElement('span');
div.id = "prototype_test_id";
span.className = 'Test';
div.appendChild(span);
var isIgnored = (div.querySelector('#prototype_test_id .test') !== null);
div = span = null;
return isIgnored;
})();
}
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)]",
'checked': "[@checked]",
'disabled': "[(@disabled) and (@type!='hidden')]",
'enabled': "[not(@disabled) and (@type!='hidden')]",
'not': function(m) {
var e = m[6], p = Selector.patterns,
x = Selector.xpath, le, v, len = p.length, name;
var exclusion = [];
while (e && le != e && (/\S/).test(e)) {
le = e;
for (var i = 0; i= 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)
{ name: 'laterSibling', re: /^\s*~\s*/ },
{ name: 'child', re: /^\s*>\s*/ },
{ name: 'adjacent', re: /^\s*\+\s*/ },
{ name: 'descendant', re: /^\s/ },
// selectors follow
{ name: 'tagName', re: /^\s*(\*|[\w\-]+)(\b|$)?/ },
{ name: 'id', re: /^#([\w\-\*]+)(\b|$)/ },
{ name: 'className', re: /^\.([\w\-\*]+)(\b|$)/ },
{ name: 'pseudo', re: /^:((first|last|nth|nth-last|only)(-child|-of-type)|empty|checked|(en|dis)abled|not)(\((.*?)\))?(\b|$|(?=\s|[:+~>]))/ },
{ name: 'attrPresence', re: /^\[((?:[\w]+:)?[\w]+)\]/ },
{ name: 'attr', re: /\[((?:[\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) 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 && (!node.type || node.type !== 'hidden'))
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 == v || nv && nv.startsWith(v); },
'$=': function(nv, v) { return nv == v || nv && nv.endsWith(v); },
'*=': function(nv, v) { return nv == v || nv && nv.include(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 != 'file' && (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.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, value) {
if (Object.isUndefined(value))
return this[element.type == 'select-one' ?
'selectOne' : 'selectMany'](element);
else {
var opt, currentValue, single = !Object.isArray(value);
for (var i = 0, length = element.length; i < length; i++) {
opt = element.options[i];
currentValue = this.optionValue(opt);
if (single) {
if (currentValue == value) {
opt.selected = true;
return;
}
}
else opt.selected = value.include(currentValue);
}
}
},
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);
}
});
(function() {
var 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: {}
};
var _isButton;
if (Prototype.Browser.IE) {
// IE doesn't map left/right/middle the same way.
var buttonMap = { 0: 1, 1: 4, 2: 2 };
_isButton = function(event, code) {
return event.button === buttonMap[code];
};
} else if (Prototype.Browser.WebKit) {
// In Safari we have to account for when the user holds down
// the "meta" key.
_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);
};
}
function isLeftClick(event) { return _isButton(event, 0) }
function isMiddleClick(event) { return _isButton(event, 1) }
function isRightClick(event) { return _isButton(event, 2) }
function element(event) {
event = Event.extend(event);
var node = event.target, type = event.type,
currentTarget = event.currentTarget;
if (currentTarget && currentTarget.tagName) {
// Firefox screws up the "click" event when moving between radio buttons
// via arrow keys. It also screws up the "load" and "error" events on images,
// reporting the document as the target instead of the original image.
if (type === 'load' || type === 'error' ||
(type === 'click' && currentTarget.tagName.toLowerCase() === 'input'
&& currentTarget.type === 'radio'))
node = currentTarget;
}
// Fix a Safari bug where a text node gets passed as the target of an
// anchor click rather than the anchor itself.
if (node.nodeType == Node.TEXT_NODE)
node = node.parentNode;
return Element.extend(node);
}
function findElement(event, expression) {
var element = Event.element(event);
if (!expression) return element;
var elements = [element].concat(element.ancestors());
return Selector.findElement(elements, expression, 0);
}
function pointer(event) {
var docElement = document.documentElement,
body = document.body || { scrollLeft: 0, scrollTop: 0 };
return {
x: event.pageX || (event.clientX +
(docElement.scrollLeft || body.scrollLeft) -
(docElement.clientLeft || 0)),
y: event.pageY || (event.clientY +
(docElement.scrollTop || body.scrollTop) -
(docElement.clientTop || 0))
};
}
function pointerX(event) { return Event.pointer(event).x }
function pointerY(event) { return Event.pointer(event).y }
function stop(event) {
Event.extend(event);
event.preventDefault();
event.stopPropagation();
// Set a "stopped" property so that a custom event can be inspected
// after the fact to determine whether or not it was stopped.
event.stopped = true;
}
Event.Methods = {
isLeftClick: isLeftClick,
isMiddleClick: isMiddleClick,
isRightClick: isRightClick,
element: element,
findElement: findElement,
pointer: pointer,
pointerX: pointerX,
pointerY: pointerY,
stop: stop
};
// Compile the list of methods that get extended onto Events.
var methods = Object.keys(Event.Methods).inject({ }, function(m, name) {
m[name] = Event.Methods[name].methodize();
return m;
});
if (Prototype.Browser.IE) {
function _relatedTarget(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);
}
Object.extend(methods, {
stopPropagation: function() { this.cancelBubble = true },
preventDefault: function() { this.returnValue = false },
inspect: function() { return '[object Event]' }
});
// IE's method for extending events.
Event.extend = 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: _relatedTarget(event),
pageX: pointer.x,
pageY: pointer.y
});
return Object.extend(event, methods);
};
} else {
Event.prototype = window.Event.prototype || document.createEvent('HTMLEvents').__proto__;
Object.extend(Event.prototype, methods);
Event.extend = Prototype.K;
}
function _createResponder(element, eventName, handler) {
// We don't set a default on the call to Element#retrieve so that we can
// handle the element's "virgin" state.
var registry = Element.retrieve(element, 'prototype_event_registry');
if (Object.isUndefined(registry)) {
// First time we've handled this element. Put it into the cache.
CACHE.push(element);
registry = Element.retrieve(element, 'prototype_event_registry', $H());
}
var respondersForEvent = registry.get(eventName);
if (Object.isUndefined()) {
respondersForEvent = [];
registry.set(eventName, respondersForEvent);
}
// Work around the issue that permits a handler to be attached more than
// once to the same element & event type.
if (respondersForEvent.pluck('handler').include(handler)) return false;
var responder;
if (eventName.include(":")) {
// Custom event.
responder = function(event) {
// If it's not a custom event, ignore it.
if (Object.isUndefined(event.eventName))
return false;
// If it's a custom event, but not the _correct_ custom event, ignore it.
if (event.eventName !== eventName)
return false;
Event.extend(event);
handler.call(element, event);
};
} else {
// Ordinary event.
responder = function(event) {
Event.extend(event);
handler.call(element, event);
};
}
responder.handler = handler;
respondersForEvent.push(responder);
return responder;
}
function _destroyCache() {
for (var i = 0, length = CACHE.length; i < length; i++)
Event.stopObserving(CACHE[i]);
}
var CACHE = [];
// Internet Explorer needs to remove event handlers on page unload
// in order to avoid memory leaks.
if (Prototype.Browser.IE)
window.attachEvent('onunload', _destroyCache);
// Safari needs a dummy event handler on page unload so that it won't
// use its bfcache. Safari <= 3.1 has an issue with restoring the "document"
// object when page is returned to via the back button using its bfcache.
if (Prototype.Browser.WebKit)
window.addEventListener('unload', Prototype.emptyFunction, false);
function observe(element, eventName, handler) {
element = $(element);
var responder = _createResponder(element, eventName, handler);
if (!responder) return element;
if (eventName.include(':')) {
// Custom event.
if (element.addEventListener)
element.addEventListener("dataavailable", responder, false);
else {
// We observe two IE-proprietarty events: one for custom events that
// bubble and one for custom events that do not bubble.
element.attachEvent("ondataavailable", responder);
element.attachEvent("onfilterchange", responder);
}
} else {
// Ordinary event.
if (element.addEventListener)
element.addEventListener(eventName, responder, false);
else
element.attachEvent("on" + eventName, responder);
}
return element;
}
function stopObserving(element, eventName, handler) {
element = $(element);
var registry = Element.retrieve(element, 'prototype_event_registry');
if (Object.isUndefined(registry)) return element;
if (eventName && !handler) {
// If an event name is passed without a handler, we stop observing all
// handlers of that type.
var responders = registry.get(eventName);
if (Object.isUndefined(responders)) return element;
responders.each( function(r) {
Element.stopObserving(element, eventName, r.handler);
});
return element;
} else if (!eventName) {
// If both the event name and the handler are omitted, we stop observing
// _all_ handlers on the element.
registry.each( function(pair) {
var eventName = pair.key, responders = pair.value;
responders.each( function(r) {
Element.stopObserving(element, eventName, r.handler);
});
});
return element;
}
var responders = registry.get(eventName);
var responder = responders.find( function(r) { return r.handler === handler; });
if (!responder) return element;
if (eventName.include(':')) {
// Custom event.
if (element.removeEventListener)
element.removeEventListener("dataavailable", responder, false);
else {
element.detachEvent("ondataavailable", responder);
element.detachEvent("onfilterchange", responder);
}
} else {
// Ordinary event.
if (element.removeEventListener)
element.removeEventListener(eventName, responder, false);
else
element.detachEvent('on' + eventName, responder);
}
registry.set(eventName, responders.without(responder));
return element;
}
function fire(element, eventName, memo, bubble) {
element = $(element);
if (Object.isUndefined(bubble))
bubble = true;
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 = bubble ? 'ondataavailable' : 'onfilterchange';
}
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);
Object.extend(Event, {
fire: fire,
observe: observe,
stopObserving: stopObserving
});
Element.addMethods({
fire: fire,
observe: observe,
stopObserving: stopObserving
});
Object.extend(document, {
fire: fire.methodize(),
observe: observe.methodize(),
stopObserving: stopObserving.methodize(),
loaded: false
});
// Export to the global scope.
if (window.Event) Object.extend(window.Event, Event);
else window.Event = Event;
})();
(function() {
/* Support for the DOMContentLoaded event is based on work by Dan Webb,
Matthias Miller, Dean Edwards, John Resig, and Diego Perini. */
var timer;
function fireContentLoadedEvent() {
if (document.loaded) return;
if (timer) window.clearTimeout(timer);
document.loaded = true;
document.fire('dom:loaded');
}
function checkReadyState() {
if (document.readyState === 'complete') {
document.stopObserving('readystatechange', checkReadyState);
fireContentLoadedEvent();
}
}
function pollDoScroll() {
try { document.documentElement.doScroll('left'); }
catch(e) {
timer = pollDoScroll.defer();
return;
}
fireContentLoadedEvent();
}
if (document.addEventListener) {
document.addEventListener('DOMContentLoaded', fireContentLoadedEvent, false);
} else {
document.observe('readystatechange', checkReadyState);
if (window === top)
timer = pollDoScroll.defer();
}
// Worst-case fallback
Event.observe(window, 'load', fireContentLoadedEvent);
})();
/*------------------------------- DEPRECATED -------------------------------*/
Hash.toQueryString = Object.toQueryString;
var Toggle = { display: Element.toggle };
Element.Methods.childOf = Element.Methods.descendantOf;
var Insertion = {
Before: function(element, content) {
return Element.insert(element, {before:content});
},
Top: function(element, content) {
return Element.insert(element, {top:content});
},
Bottom: function(element, content) {
return Element.insert(element, {bottom:content});
},
After: function(element, content) {
return Element.insert(element, {after:content});
}
};
var $continue = new Error('"throw $continue" is deprecated, use "return" instead');
// This should be moved to script.aculo.us; notice the deprecated methods
// further below, that map to the newer Element methods.
var Position = {
// set to true if needed, warning: firefox performance problems
// NOT neeeded for page scrolling, only if draggable contained in
// scrollable elements
includeScrollOffsets: false,
// must be called before calling withinIncludingScrolloffset, every time the
// page is scrolled
prepare: function() {
this.deltaX = window.pageXOffset
|| document.documentElement.scrollLeft
|| document.body.scrollLeft
|| 0;
this.deltaY = window.pageYOffset
|| document.documentElement.scrollTop
|| document.body.scrollTop
|| 0;
},
// caches x/y coordinate pair to use with overlap
within: function(element, x, y) {
if (this.includeScrollOffsets)
return this.withinIncludingScrolloffsets(element, x, y);
this.xcomp = x;
this.ycomp = y;
this.offset = Element.cumulativeOffset(element);
return (y >= this.offset[1] &&
y < this.offset[1] + element.offsetHeight &&
x >= this.offset[0] &&
x < this.offset[0] + element.offsetWidth);
},
withinIncludingScrolloffsets: function(element, x, y) {
var offsetcache = Element.cumulativeScrollOffset(element);
this.xcomp = x + offsetcache[0] - this.deltaX;
this.ycomp = y + offsetcache[1] - this.deltaY;
this.offset = Element.cumulativeOffset(element);
return (this.ycomp >= this.offset[1] &&
this.ycomp < this.offset[1] + element.offsetHeight &&
this.xcomp >= this.offset[0] &&
this.xcomp < this.offset[0] + element.offsetWidth);
},
// within must be called directly before
overlap: function(mode, element) {
if (!mode) return 0;
if (mode == 'vertical')
return ((this.offset[1] + element.offsetHeight) - this.ycomp) /
element.offsetHeight;
if (mode == 'horizontal')
return ((this.offset[0] + element.offsetWidth) - this.xcomp) /
element.offsetWidth;
},
// Deprecation layer -- use newer Element methods now (1.5.2).
cumulativeOffset: Element.Methods.cumulativeOffset,
positionedOffset: Element.Methods.positionedOffset,
absolutize: function(element) {
Position.prepare();
return Element.absolutize(element);
},
relativize: function(element) {
Position.prepare();
return Element.relativize(element);
},
realOffset: Element.Methods.cumulativeScrollOffset,
offsetParent: Element.Methods.getOffsetParent,
page: Element.Methods.viewportOffset,
clone: function(source, target, options) {
options = options || { };
return Element.clonePosition(target, source, options);
}
};
/*--------------------------------------------------------------------------*/
if (!document.getElementsByClassName) document.getElementsByClassName = function(instanceMethods){
function iter(name) {
return name.blank() ? null : "[contains(concat(' ', @class, ' '), ' " + name + " ')]";
}
instanceMethods.getElementsByClassName = Prototype.BrowserFeatures.XPath ?
function(element, className) {
className = className.toString().strip();
var cond = /\s/.test(className) ? $w(className).map(iter).join('') : iter(className);
return cond ? document._getElementsByXPath('.//*' + cond, element) : [];
} : function(element, className) {
className = className.toString().strip();
var elements = [], classNames = (/\s/.test(className) ? $w(className) : null);
if (!classNames && !className) return elements;
var nodes = $(element).getElementsByTagName('*');
className = ' ' + className + ' ';
for (var i = 0, child, cn; child = nodes[i]; i++) {
if (child.className && (cn = ' ' + child.className + ' ') && (cn.include(className) ||
(classNames && classNames.all(function(name) {
return !name.toString().blank() && cn.include(' ' + name + ' ');
}))))
elements.push(Element.extend(child));
}
return elements;
};
return function(className, parentElement) {
return $(parentElement || document.body).getElementsByClassName(className);
};
}(Element.Methods);
/*--------------------------------------------------------------------------*/
Element.ClassNames = Class.create();
Element.ClassNames.prototype = {
initialize: function(element) {
this.element = $(element);
},
_each: function(iterator) {
this.element.className.split(/\s+/).select(function(name) {
return name.length > 0;
})._each(iterator);
},
set: function(className) {
this.element.className = className;
},
add: function(classNameToAdd) {
if (this.include(classNameToAdd)) return;
this.set($A(this).concat(classNameToAdd).join(' '));
},
remove: function(classNameToRemove) {
if (!this.include(classNameToRemove)) return;
this.set($A(this).without(classNameToRemove).join(' '));
},
toString: function() {
return $A(this).join(' ');
}
};
Object.extend(Element.ClassNames.prototype, Enumerable);
/*--------------------------------------------------------------------------*/
Element.addMethods();
/*
**
** File 'scriptaculous.js'
**
*/
// script.aculo.us scriptaculous.js v1.8.2, Tue Nov 18 18:30:58 +0100 2008
// Copyright (c) 2005-2008 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
// For details, see the script.aculo.us web site: http://script.aculo.us/
var Scriptaculous = {
Version: '1.8.2',
require: function(libraryName) {
// inserting via DOM fails in Safari 2.0, so brute force approach
document.write(''."\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
});
/************* SYNTAX ***************
AjaxQueue.setBatchSize(size);
AjaxQueue.push(URL , OPTIONS, [ElementID]);
************** USAGE ***************
AjaxQueue.setBatchSize(4);
AjaxQueue.push("blablabla",{onSucess: funcSuccess, onfailure: funcFailure});
*/
// ALT - WAHRSCHEINLICH LÖSCHEN
/*
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');
}
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);
}
function elementNameToArray(element){
if (typeof element == 'string') element = $(element);
if (!element || !element.getElementsByTagName){ return; }
result = '';
var inputs = element.getElementsByTagName('input');
// loop through all input tags
var textAreas = element.getElementsByTagName('textarea');
// loop through all input tags
for (var i=0; i 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']:'';
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);
} */
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;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");
};
*/
/*
**
** 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 'dragdrop.js'
**
*/
// script.aculo.us dragdrop.js v1.8.2, Tue Nov 18 18:30:58 +0100 2008
// Copyright (c) 2005-2008 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
// (c) 2005-2008 Sammi Williams (http://www.oriontransfer.co.nz, sammi@oriontransfer.co.nz)
//
// script.aculo.us is freely distributable under the terms of an MIT-style license.
// For details, see the script.aculo.us web site: http://script.aculo.us/
if(Object.isUndefined(Effect))
throw("dragdrop.js requires including script.aculo.us' effects.js library");
var Droppables = {
drops: [],
remove: function(element) {
this.drops = this.drops.reject(function(d) { return d.element==$(element) });
},
add: function(element) {
element = $(element);
var options = Object.extend({
greedy: true,
hoverclass: null,
tree: false
}, arguments[1] || { });
// cache containers
if(options.containment) {
options._containers = [];
var containment = options.containment;
if(Object.isArray(containment)) {
containment.each( function(c) { options._containers.push($(c)) });
} else {
options._containers.push($(containment));
}
}
if(options.accept) options.accept = [options.accept].flatten();
Element.makePositioned(element); // fix IE
options.element = element;
this.drops.push(options);
},
findDeepestChild: function(drops) {
deepest = drops[0];
for (i = 1; i < drops.length; ++i)
if (Element.isParent(drops[i].element, deepest.element))
deepest = drops[i];
return deepest;
},
isContained: function(element, drop) {
var containmentNode;
if(drop.tree) {
containmentNode = element.treeNode;
} else {
containmentNode = element.parentNode;
}
return drop._containers.detect(function(c) { return containmentNode == c });
},
isAffected: function(point, element, drop) {
return (
(drop.element!=element) &&
((!drop._containers) ||
this.isContained(element, drop)) &&
((!drop.accept) ||
(Element.classNames(element).detect(
function(v) { return drop.accept.include(v) } ) )) &&
Position.within(drop.element, point[0], point[1]) );
},
deactivate: function(drop) {
if(drop.hoverclass)
Element.removeClassName(drop.element, drop.hoverclass);
this.last_active = null;
},
activate: function(drop) {
if(drop.hoverclass)
Element.addClassName(drop.element, drop.hoverclass);
this.last_active = drop;
},
show: function(point, element) {
if(!this.drops.length) return;
var drop, affected = [];
this.drops.each( function(drop) {
if(Droppables.isAffected(point, element, drop))
affected.push(drop);
});
if(affected.length>0)
drop = Droppables.findDeepestChild(affected);
if(this.last_active && this.last_active != drop) this.deactivate(this.last_active);
if (drop) {
Position.within(drop.element, point[0], point[1]);
if(drop.onHover)
drop.onHover(element, drop.element, Position.overlap(drop.overlap, drop.element));
if (drop != this.last_active) Droppables.activate(drop);
}
},
fire: function(event, element) {
if(!this.last_active) return;
Position.prepare();
if (this.isAffected([Event.pointerX(event), Event.pointerY(event)], element, this.last_active))
if (this.last_active.onDrop) {
this.last_active.onDrop(element, this.last_active.element, event);
return true;
}
},
reset: function() {
if(this.last_active)
this.deactivate(this.last_active);
}
};
var Draggables = {
drags: [],
observers: [],
register: function(draggable) {
if(this.drags.length == 0) {
this.eventMouseUp = this.endDrag.bindAsEventListener(this);
this.eventMouseMove = this.updateDrag.bindAsEventListener(this);
this.eventKeypress = this.keyPress.bindAsEventListener(this);
Event.observe(document, "mouseup", this.eventMouseUp);
Event.observe(document, "mousemove", this.eventMouseMove);
Event.observe(document, "keypress", this.eventKeypress);
}
this.drags.push(draggable);
},
unregister: function(draggable) {
this.drags = this.drags.reject(function(d) { return d==draggable });
if(this.drags.length == 0) {
Event.stopObserving(document, "mouseup", this.eventMouseUp);
Event.stopObserving(document, "mousemove", this.eventMouseMove);
Event.stopObserving(document, "keypress", this.eventKeypress);
}
},
activate: function(draggable) {
if(draggable.options.delay) {
this._timeout = setTimeout(function() {
Draggables._timeout = null;
window.focus();
Draggables.activeDraggable = draggable;
}.bind(this), draggable.options.delay);
} else {
window.focus(); // allows keypress events if window isn't currently focused, fails for Safari
this.activeDraggable = draggable;
}
},
deactivate: function() {
this.activeDraggable = null;
},
updateDrag: function(event) {
if(!this.activeDraggable) return;
var pointer = [Event.pointerX(event), Event.pointerY(event)];
// Mozilla-based browsers fire successive mousemove events with
// the same coordinates, prevent needless redrawing (moz bug?)
if(this._lastPointer && (this._lastPointer.inspect() == pointer.inspect())) return;
this._lastPointer = pointer;
this.activeDraggable.updateDrag(event, pointer);
},
endDrag: function(event) {
if(this._timeout) {
clearTimeout(this._timeout);
this._timeout = null;
}
if(!this.activeDraggable) return;
this._lastPointer = null;
this.activeDraggable.endDrag(event);
this.activeDraggable = null;
},
keyPress: function(event) {
if(this.activeDraggable)
this.activeDraggable.keyPress(event);
},
addObserver: function(observer) {
this.observers.push(observer);
this._cacheObserverCallbacks();
},
removeObserver: function(element) { // element instead of observer fixes mem leaks
this.observers = this.observers.reject( function(o) { return o.element==element });
this._cacheObserverCallbacks();
},
notify: function(eventName, draggable, event) { // 'onStart', 'onEnd', 'onDrag'
if(this[eventName+'Count'] > 0)
this.observers.each( function(o) {
if(o[eventName]) o[eventName](eventName, draggable, event);
});
if(draggable.options[eventName]) draggable.options[eventName](draggable, event);
},
_cacheObserverCallbacks: function() {
['onStart','onEnd','onDrag'].each( function(eventName) {
Draggables[eventName+'Count'] = Draggables.observers.select(
function(o) { return o[eventName]; }
).length;
});
}
};
/*--------------------------------------------------------------------------*/
var Draggable = Class.create({
initialize: function(element) {
var defaults = {
handle: false,
reverteffect: function(element, top_offset, left_offset) {
var dur = Math.sqrt(Math.abs(top_offset^2)+Math.abs(left_offset^2))*0.02;
new Effect.Move(element, { x: -left_offset, y: -top_offset, duration: dur,
queue: {scope:'_draggable', position:'end'}
});
},
endeffect: function(element) {
var toOpacity = Object.isNumber(element._opacity) ? element._opacity : 1.0;
new Effect.Opacity(element, {duration:0.2, from:0.7, to:toOpacity,
queue: {scope:'_draggable', position:'end'},
afterFinish: function(){
Draggable._dragging[element] = false
}
});
},
zindex: 1000,
revert: false,
quiet: false,
scroll: false,
scrollSensitivity: 20,
scrollSpeed: 15,
snap: false, // false, or xy or [x,y] or function(x,y){ return [x,y] }
delay: 0
};
if(!arguments[1] || Object.isUndefined(arguments[1].endeffect))
Object.extend(defaults, {
starteffect: function(element) {
element._opacity = Element.getOpacity(element);
Draggable._dragging[element] = true;
new Effect.Opacity(element, {duration:0.2, from:element._opacity, to:0.7});
}
});
var options = Object.extend(defaults, arguments[1] || { });
this.element = $(element);
if(options.handle && Object.isString(options.handle))
this.handle = this.element.down('.'+options.handle, 0);
if(!this.handle) this.handle = $(options.handle);
if(!this.handle) this.handle = this.element;
if(options.scroll && !options.scroll.scrollTo && !options.scroll.outerHTML) {
options.scroll = $(options.scroll);
this._isScrollChild = Element.childOf(this.element, options.scroll);
}
Element.makePositioned(this.element); // fix IE
this.options = options;
this.dragging = false;
this.eventMouseDown = this.initDrag.bindAsEventListener(this);
Event.observe(this.handle, "mousedown", this.eventMouseDown);
Draggables.register(this);
},
destroy: function() {
Event.stopObserving(this.handle, "mousedown", this.eventMouseDown);
Draggables.unregister(this);
},
currentDelta: function() {
return([
parseInt(Element.getStyle(this.element,'left') || '0'),
parseInt(Element.getStyle(this.element,'top') || '0')]);
},
initDrag: function(event) {
if(!Object.isUndefined(Draggable._dragging[this.element]) &&
Draggable._dragging[this.element]) return;
if(Event.isLeftClick(event)) {
// abort on form elements, fixes a Firefox issue
var src = Event.element(event);
if((tag_name = src.tagName.toUpperCase()) && (
tag_name=='INPUT' ||
tag_name=='SELECT' ||
tag_name=='OPTION' ||
tag_name=='BUTTON' ||
tag_name=='TEXTAREA')) return;
var pointer = [Event.pointerX(event), Event.pointerY(event)];
var pos = Position.cumulativeOffset(this.element);
this.offset = [0,1].map( function(i) { return (pointer[i] - pos[i]) });
Draggables.activate(this);
Event.stop(event);
}
},
startDrag: function(event) {
this.dragging = true;
if(!this.delta)
this.delta = this.currentDelta();
if(this.options.zindex) {
this.originalZ = parseInt(Element.getStyle(this.element,'z-index') || 0);
this.element.style.zIndex = this.options.zindex;
}
if(this.options.ghosting) {
this._clone = this.element.cloneNode(true);
this._originallyAbsolute = (this.element.getStyle('position') == 'absolute');
if (!this._originallyAbsolute)
Position.absolutize(this.element);
this.element.parentNode.insertBefore(this._clone, this.element);
}
if(this.options.scroll) {
if (this.options.scroll == window) {
var where = this._getWindowScroll(this.options.scroll);
this.originalScrollLeft = where.left;
this.originalScrollTop = where.top;
} else {
this.originalScrollLeft = this.options.scroll.scrollLeft;
this.originalScrollTop = this.options.scroll.scrollTop;
}
}
Draggables.notify('onStart', this, event);
if(this.options.starteffect) this.options.starteffect(this.element);
},
updateDrag: function(event, pointer) {
if(!this.dragging) this.startDrag(event);
if(!this.options.quiet){
Position.prepare();
Droppables.show(pointer, this.element);
}
Draggables.notify('onDrag', this, event);
this.draw(pointer);
if(this.options.change) this.options.change(this);
if(this.options.scroll) {
this.stopScrolling();
var p;
if (this.options.scroll == window) {
with(this._getWindowScroll(this.options.scroll)) { p = [ left, top, left+width, top+height ]; }
} else {
p = Position.page(this.options.scroll);
p[0] += this.options.scroll.scrollLeft + Position.deltaX;
p[1] += this.options.scroll.scrollTop + Position.deltaY;
p.push(p[0]+this.options.scroll.offsetWidth);
p.push(p[1]+this.options.scroll.offsetHeight);
}
var speed = [0,0];
if(pointer[0] < (p[0]+this.options.scrollSensitivity)) speed[0] = pointer[0]-(p[0]+this.options.scrollSensitivity);
if(pointer[1] < (p[1]+this.options.scrollSensitivity)) speed[1] = pointer[1]-(p[1]+this.options.scrollSensitivity);
if(pointer[0] > (p[2]-this.options.scrollSensitivity)) speed[0] = pointer[0]-(p[2]-this.options.scrollSensitivity);
if(pointer[1] > (p[3]-this.options.scrollSensitivity)) speed[1] = pointer[1]-(p[3]-this.options.scrollSensitivity);
this.startScrolling(speed);
}
// fix AppleWebKit rendering
if(Prototype.Browser.WebKit) window.scrollBy(0,0);
Event.stop(event);
},
finishDrag: function(event, success) {
this.dragging = false;
if(this.options.quiet){
Position.prepare();
var pointer = [Event.pointerX(event), Event.pointerY(event)];
Droppables.show(pointer, this.element);
}
if(this.options.ghosting) {
if (!this._originallyAbsolute)
Position.relativize(this.element);
delete this._originallyAbsolute;
Element.remove(this._clone);
this._clone = null;
}
var dropped = false;
if(success) {
dropped = Droppables.fire(event, this.element);
if (!dropped) dropped = false;
}
if(dropped && this.options.onDropped) this.options.onDropped(this.element);
Draggables.notify('onEnd', this, event);
var revert = this.options.revert;
if(revert && Object.isFunction(revert)) revert = revert(this.element);
var d = this.currentDelta();
if(revert && this.options.reverteffect) {
if (dropped == 0 || revert != 'failure')
this.options.reverteffect(this.element,
d[1]-this.delta[1], d[0]-this.delta[0]);
} else {
this.delta = d;
}
if(this.options.zindex)
this.element.style.zIndex = this.originalZ;
if(this.options.endeffect)
this.options.endeffect(this.element);
Draggables.deactivate(this);
Droppables.reset();
},
keyPress: function(event) {
if(event.keyCode!=Event.KEY_ESC) return;
this.finishDrag(event, false);
Event.stop(event);
},
endDrag: function(event) {
if(!this.dragging) return;
this.stopScrolling();
this.finishDrag(event, true);
Event.stop(event);
},
draw: function(point) {
var pos = Position.cumulativeOffset(this.element);
if(this.options.ghosting) {
var r = Position.realOffset(this.element);
pos[0] += r[0] - Position.deltaX; pos[1] += r[1] - Position.deltaY;
}
var d = this.currentDelta();
pos[0] -= d[0]; pos[1] -= d[1];
if(this.options.scroll && (this.options.scroll != window && this._isScrollChild)) {
pos[0] -= this.options.scroll.scrollLeft-this.originalScrollLeft;
pos[1] -= this.options.scroll.scrollTop-this.originalScrollTop;
}
var p = [0,1].map(function(i){
return (point[i]-pos[i]-this.offset[i])
}.bind(this));
if(this.options.snap) {
if(Object.isFunction(this.options.snap)) {
p = this.options.snap(p[0],p[1],this);
} else {
if(Object.isArray(this.options.snap)) {
p = p.map( function(v, i) {
return (v/this.options.snap[i]).round()*this.options.snap[i] }.bind(this));
} else {
p = p.map( function(v) {
return (v/this.options.snap).round()*this.options.snap }.bind(this));
}
}}
var style = this.element.style;
if((!this.options.constraint) || (this.options.constraint=='horizontal'))
style.left = p[0] + "px";
if((!this.options.constraint) || (this.options.constraint=='vertical'))
style.top = p[1] + "px";
if(style.visibility=="hidden") style.visibility = ""; // fix gecko rendering
},
stopScrolling: function() {
if(this.scrollInterval) {
clearInterval(this.scrollInterval);
this.scrollInterval = null;
Draggables._lastScrollPointer = null;
}
},
startScrolling: function(speed) {
if(!(speed[0] || speed[1])) return;
this.scrollSpeed = [speed[0]*this.options.scrollSpeed,speed[1]*this.options.scrollSpeed];
this.lastScrolled = new Date();
this.scrollInterval = setInterval(this.scroll.bind(this), 10);
},
scroll: function() {
var current = new Date();
var delta = current - this.lastScrolled;
this.lastScrolled = current;
if(this.options.scroll == window) {
with (this._getWindowScroll(this.options.scroll)) {
if (this.scrollSpeed[0] || this.scrollSpeed[1]) {
var d = delta / 1000;
this.options.scroll.scrollTo( left + d*this.scrollSpeed[0], top + d*this.scrollSpeed[1] );
}
}
} else {
this.options.scroll.scrollLeft += this.scrollSpeed[0] * delta / 1000;
this.options.scroll.scrollTop += this.scrollSpeed[1] * delta / 1000;
}
Position.prepare();
Droppables.show(Draggables._lastPointer, this.element);
Draggables.notify('onDrag', this);
if (this._isScrollChild) {
Draggables._lastScrollPointer = Draggables._lastScrollPointer || $A(Draggables._lastPointer);
Draggables._lastScrollPointer[0] += this.scrollSpeed[0] * delta / 1000;
Draggables._lastScrollPointer[1] += this.scrollSpeed[1] * delta / 1000;
if (Draggables._lastScrollPointer[0] < 0)
Draggables._lastScrollPointer[0] = 0;
if (Draggables._lastScrollPointer[1] < 0)
Draggables._lastScrollPointer[1] = 0;
this.draw(Draggables._lastScrollPointer);
}
if(this.options.change) this.options.change(this);
},
_getWindowScroll: function(w) {
var T, L, W, H;
with (w.document) {
if (w.document.documentElement && documentElement.scrollTop) {
T = documentElement.scrollTop;
L = documentElement.scrollLeft;
} else if (w.document.body) {
T = body.scrollTop;
L = body.scrollLeft;
}
if (w.innerWidth) {
W = w.innerWidth;
H = w.innerHeight;
} else if (w.document.documentElement && documentElement.clientWidth) {
W = documentElement.clientWidth;
H = documentElement.clientHeight;
} else {
W = body.offsetWidth;
H = body.offsetHeight;
}
}
return { top: T, left: L, width: W, height: H };
}
});
Draggable._dragging = { };
/*--------------------------------------------------------------------------*/
var SortableObserver = Class.create({
initialize: function(element, observer) {
this.element = $(element);
this.observer = observer;
this.lastValue = Sortable.serialize(this.element);
},
onStart: function() {
this.lastValue = Sortable.serialize(this.element);
},
onEnd: function() {
Sortable.unmark();
if(this.lastValue != Sortable.serialize(this.element))
this.observer(this.element)
}
});
var Sortable = {
SERIALIZE_RULE: /^[^_\-](?:[A-Za-z0-9\-\_]*)[_](.*)$/,
sortables: { },
_findRootElement: function(element) {
while (element.tagName.toUpperCase() != "BODY") {
if(element.id && Sortable.sortables[element.id]) return element;
element = element.parentNode;
}
},
options: function(element) {
element = Sortable._findRootElement($(element));
if(!element) return;
return Sortable.sortables[element.id];
},
destroy: function(element){
element = $(element);
var s = Sortable.sortables[element.id];
if(s) {
Draggables.removeObserver(s.element);
s.droppables.each(function(d){ Droppables.remove(d) });
s.draggables.invoke('destroy');
delete Sortable.sortables[s.element.id];
}
},
create: function(element) {
element = $(element);
var options = Object.extend({
element: element,
tag: 'li', // assumes li children, override with tag: 'tagname'
dropOnEmpty: false,
tree: false,
treeTag: 'ul',
overlap: 'vertical', // one of 'vertical', 'horizontal'
constraint: 'vertical', // one of 'vertical', 'horizontal', false
containment: element, // also takes array of elements (or id's); or false
handle: false, // or a CSS class
only: false,
delay: 0,
hoverclass: null,
ghosting: false,
quiet: false,
scroll: false,
scrollSensitivity: 20,
scrollSpeed: 15,
format: this.SERIALIZE_RULE,
// these take arrays of elements or ids and can be
// used for better initialization performance
elements: false,
handles: false,
onChange: Prototype.emptyFunction,
onUpdate: Prototype.emptyFunction,
onStart: Prototype.emptyFunction, // prepare an onStart function
onEnd: Prototype.emptyFunction // prepare an onEnd function
}, arguments[1] || { });
// clear any old sortable with same element
this.destroy(element);
// build options for the draggables
var options_for_draggable = {
revert: true,
quiet: options.quiet,
scroll: options.scroll,
scrollSpeed: options.scrollSpeed,
scrollSensitivity: options.scrollSensitivity,
delay: options.delay,
ghosting: options.ghosting,
constraint: options.constraint,
handle: options.handle,
onStart: options.onStart, // apply the onStart function to the draggable istance
onEnd: options.onEnd };
if(options.starteffect)
options_for_draggable.starteffect = options.starteffect;
if(options.reverteffect)
options_for_draggable.reverteffect = options.reverteffect;
else
if(options.ghosting) options_for_draggable.reverteffect = function(element) {
element.style.top = 0;
element.style.left = 0;
};
if(options.endeffect)
options_for_draggable.endeffect = options.endeffect;
if(options.zindex)
options_for_draggable.zindex = options.zindex;
// build options for the droppables
var options_for_droppable = {
overlap: options.overlap,
containment: options.containment,
tree: options.tree,
hoverclass: options.hoverclass,
onHover: Sortable.onHover
};
var options_for_tree = {
onHover: Sortable.onEmptyHover,
overlap: options.overlap,
containment: options.containment,
hoverclass: options.hoverclass
};
// fix for gecko engine
Element.cleanWhitespace(element);
options.draggables = [];
options.droppables = [];
// drop on empty handling
if(options.dropOnEmpty || options.tree) {
Droppables.add(element, options_for_tree);
options.droppables.push(element);
}
(options.elements || this.findElements(element, options) || []).each( function(e,i) {
var handle = options.handles ? $(options.handles[i]) :
(options.handle ? $(e).select('.' + options.handle)[0] : e);
options.draggables.push(
new Draggable(e, Object.extend(options_for_draggable, { handle: handle })));
Droppables.add(e, options_for_droppable);
if(options.tree) e.treeNode = element;
options.droppables.push(e);
});
if(options.tree) {
(Sortable.findTreeElements(element, options) || []).each( function(e) {
Droppables.add(e, options_for_tree);
e.treeNode = element;
options.droppables.push(e);
});
}
// keep reference
this.sortables[element.id] = options;
// for onupdate
Draggables.addObserver(new SortableObserver(element, options.onUpdate));
},
// return all suitable-for-sortable elements in a guaranteed order
findElements: function(element, options) {
return Element.findChildren(
element, options.only, options.tree ? true : false, options.tag);
},
findTreeElements: function(element, options) {
return Element.findChildren(
element, options.only, options.tree ? true : false, options.treeTag);
},
onHover: function(element, dropon, overlap) {
if(Element.isParent(dropon, element)) return;
if(overlap > .33 && overlap < .66 && Sortable.options(dropon).tree) {
return;
} else if(overlap>0.5) {
Sortable.mark(dropon, 'before');
if(dropon.previousSibling != element) {
var oldParentNode = element.parentNode;
element.style.visibility = "hidden"; // fix gecko rendering
dropon.parentNode.insertBefore(element, dropon);
if(dropon.parentNode!=oldParentNode)
Sortable.options(oldParentNode).onChange(element);
Sortable.options(dropon.parentNode).onChange(element);
}
} else {
Sortable.mark(dropon, 'after');
var nextElement = dropon.nextSibling || null;
if(nextElement != element) {
var oldParentNode = element.parentNode;
element.style.visibility = "hidden"; // fix gecko rendering
dropon.parentNode.insertBefore(element, nextElement);
if(dropon.parentNode!=oldParentNode)
Sortable.options(oldParentNode).onChange(element);
Sortable.options(dropon.parentNode).onChange(element);
}
}
},
onEmptyHover: function(element, dropon, overlap) {
var oldParentNode = element.parentNode;
var droponOptions = Sortable.options(dropon);
if(!Element.isParent(dropon, element)) {
var index;
var children = Sortable.findElements(dropon, {tag: droponOptions.tag, only: droponOptions.only});
var child = null;
if(children) {
var offset = Element.offsetSize(dropon, droponOptions.overlap) * (1.0 - overlap);
for (index = 0; index < children.length; index += 1) {
if (offset - Element.offsetSize (children[index], droponOptions.overlap) >= 0) {
offset -= Element.offsetSize (children[index], droponOptions.overlap);
} else if (offset - (Element.offsetSize (children[index], droponOptions.overlap) / 2) >= 0) {
child = index + 1 < children.length ? children[index + 1] : null;
break;
} else {
child = children[index];
break;
}
}
}
dropon.insertBefore(element, child);
Sortable.options(oldParentNode).onChange(element);
droponOptions.onChange(element);
}
},
unmark: function() {
if(Sortable._marker) Sortable._marker.hide();
},
mark: function(dropon, position) {
// mark on ghosting only
var sortable = Sortable.options(dropon.parentNode);
if(sortable && !sortable.ghosting) return;
if(!Sortable._marker) {
Sortable._marker =
($('dropmarker') || Element.extend(document.createElement('DIV'))).
hide().addClassName('dropmarker').setStyle({position:'absolute'});
document.getElementsByTagName("body").item(0).appendChild(Sortable._marker);
}
var offsets = Position.cumulativeOffset(dropon);
Sortable._marker.setStyle({left: offsets[0]+'px', top: offsets[1] + 'px'});
if(position=='after')
if(sortable.overlap == 'horizontal')
Sortable._marker.setStyle({left: (offsets[0]+dropon.clientWidth) + 'px'});
else
Sortable._marker.setStyle({top: (offsets[1]+dropon.clientHeight) + 'px'});
Sortable._marker.show();
},
_tree: function(element, options, parent) {
var children = Sortable.findElements(element, options) || [];
for (var i = 0; i < children.length; ++i) {
var match = children[i].id.match(options.format);
if (!match) continue;
var child = {
id: encodeURIComponent(match ? match[1] : null),
element: element,
parent: parent,
children: [],
position: parent.children.length,
container: $(children[i]).down(options.treeTag)
};
/* Get the element containing the children and recurse over it */
if (child.container)
this._tree(child.container, options, child);
parent.children.push (child);
}
return parent;
},
tree: function(element) {
element = $(element);
var sortableOptions = this.options(element);
var options = Object.extend({
tag: sortableOptions.tag,
treeTag: sortableOptions.treeTag,
only: sortableOptions.only,
name: element.id,
format: sortableOptions.format
}, arguments[1] || { });
var root = {
id: null,
parent: null,
children: [],
container: element,
position: 0
};
return Sortable._tree(element, options, root);
},
/* Construct a [i] index for a particular node */
_constructIndex: function(node) {
var index = '';
do {
if (node.id) index = '[' + node.position + ']' + index;
} while ((node = node.parent) != null);
return index;
},
sequence: function(element) {
element = $(element);
var options = Object.extend(this.options(element), arguments[1] || { });
return $(this.findElements(element, options) || []).map( function(item) {
return item.id.match(options.format) ? item.id.match(options.format)[1] : '';
});
},
setSequence: function(element, new_sequence) {
element = $(element);
var options = Object.extend(this.options(element), arguments[2] || { });
var nodeMap = { };
this.findElements(element, options).each( function(n) {
if (n.id.match(options.format))
nodeMap[n.id.match(options.format)[1]] = [n, n.parentNode];
n.parentNode.removeChild(n);
});
new_sequence.each(function(ident) {
var n = nodeMap[ident];
if (n) {
n[1].appendChild(n[0]);
delete nodeMap[ident];
}
});
},
serialize: function(element) {
element = $(element);
var options = Object.extend(Sortable.options(element), arguments[1] || { });
var name = encodeURIComponent(
(arguments[1] && arguments[1].name) ? arguments[1].name : element.id);
if (options.tree) {
return Sortable.tree(element, arguments[1]).children.map( function (item) {
return [name + Sortable._constructIndex(item) + "[id]=" +
encodeURIComponent(item.id)].concat(item.children.map(arguments.callee));
}).flatten().join('&');
} else {
return Sortable.sequence(element, arguments[1]).map( function(item) {
return name + "[]=" + encodeURIComponent(item);
}).join('&');
}
}
};
// Returns true if child is contained within element
Element.isParent = function(child, element) {
if (!child.parentNode || child == element) return false;
if (child.parentNode == element) return true;
return Element.isParent(child.parentNode, element);
};
Element.findChildren = function(element, only, recursive, tagName) {
if(!element.hasChildNodes()) return null;
tagName = tagName.toUpperCase();
if(only) only = [only].flatten();
var elements = [];
$A(element.childNodes).each( function(e) {
if(e.tagName && e.tagName.toUpperCase()==tagName &&
(!only || (Element.classNames(e).detect(function(v) { return only.include(v) }))))
elements.push(e);
if(recursive) {
var grandchildren = Element.findChildren(e, only, recursive, tagName);
if(grandchildren) elements.push(grandchildren);
}
});
return (elements.length>0 ? elements.flatten() : []);
};
Element.offsetSize = function (element, type) {
return element['offset' + ((type=='vertical' || type=='height') ? 'Height' : 'Width')];
};
/*
**
** File 'builder.js'
**
*/
// script.aculo.us builder.js v1.8.2, Tue Nov 18 18:30:58 +0100 2008
// Copyright (c) 2005-2008 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
//
// script.aculo.us is freely distributable under the terms of an MIT-style license.
// For details, see the script.aculo.us web site: http://script.aculo.us/
var Builder = {
NODEMAP: {
AREA: 'map',
CAPTION: 'table',
COL: 'table',
COLGROUP: 'table',
LEGEND: 'fieldset',
OPTGROUP: 'select',
OPTION: 'select',
PARAM: 'object',
TBODY: 'table',
TD: 'table',
TFOOT: 'table',
TH: 'table',
THEAD: 'table',
TR: 'table'
},
// note: For Firefox < 1.5, OPTION and OPTGROUP tags are currently broken,
// due to a Firefox bug
node: function(elementName) {
elementName = elementName.toUpperCase();
// try innerHTML approach
var parentTag = this.NODEMAP[elementName] || 'div';
var parentElement = document.createElement(parentTag);
try { // prevent IE "feature": http://dev.rubyonrails.org/ticket/2707
parentElement.innerHTML = "<" + elementName + ">";
} catch(e) {}
var element = parentElement.firstChild || null;
// see if browser added wrapping tags
if(element && (element.tagName.toUpperCase() != elementName))
element = element.getElementsByTagName(elementName)[0];
// fallback to createElement approach
if(!element) element = document.createElement(elementName);
// abort if nothing could be created
if(!element) return;
// attributes (or text)
if(arguments[1])
if(this._isStringOrNumber(arguments[1]) ||
(arguments[1] instanceof Array) ||
arguments[1].tagName) {
this._children(element, arguments[1]);
} else {
var attrs = this._attributes(arguments[1]);
if(attrs.length) {
try { // prevent IE "feature": http://dev.rubyonrails.org/ticket/2707
parentElement.innerHTML = "<" +elementName + " " +
attrs + ">";
} catch(e) {}
element = parentElement.firstChild || null;
// workaround firefox 1.0.X bug
if(!element) {
element = document.createElement(elementName);
for(attr in arguments[1])
element[attr == 'class' ? 'className' : attr] = arguments[1][attr];
}
if(element.tagName.toUpperCase() != elementName)
element = parentElement.getElementsByTagName(elementName)[0];
}
}
// text, or array of children
if(arguments[2])
this._children(element, arguments[2]);
return $(element);
},
_text: function(text) {
return document.createTextNode(text);
},
ATTR_MAP: {
'className': 'class',
'htmlFor': 'for'
},
_attributes: function(attributes) {
var attrs = [];
for(attribute in attributes)
attrs.push((attribute in this.ATTR_MAP ? this.ATTR_MAP[attribute] : attribute) +
'="' + attributes[attribute].toString().escapeHTML().gsub(/"/,'"') + '"');
return attrs.join(" ");
},
_children: function(element, children) {
if(children.tagName) {
element.appendChild(children);
return;
}
if(typeof children=='object') { // array can hold nodes and text
children.flatten().each( function(e) {
if(typeof e=='object')
element.appendChild(e);
else
if(Builder._isStringOrNumber(e))
element.appendChild(Builder._text(e));
});
} else
if(Builder._isStringOrNumber(children))
element.appendChild(Builder._text(children));
},
_isStringOrNumber: function(param) {
return(typeof param=='string' || typeof param=='number');
},
build: function(html) {
var element = this.node('div');
$(element).update(html.strip());
return element.down();
},
dump: function(scope) {
if(typeof scope != 'object' && typeof scope != 'function') scope = window; //global scope
var tags = ("A ABBR ACRONYM ADDRESS APPLET AREA B BASE BASEFONT BDO BIG BLOCKQUOTE BODY " +
"BR BUTTON CAPTION CENTER CITE CODE COL COLGROUP DD DEL DFN DIR DIV DL DT EM FIELDSET " +
"FONT FORM FRAME FRAMESET H1 H2 H3 H4 H5 H6 HEAD HR HTML I IFRAME IMG INPUT INS ISINDEX "+
"KBD LABEL LEGEND LI LINK MAP MENU META NOFRAMES NOSCRIPT OBJECT OL OPTGROUP OPTION P "+
"PARAM PRE Q S SAMP SCRIPT SELECT SMALL SPAN STRIKE STRONG STYLE SUB SUP TABLE TBODY TD "+
"TEXTAREA TFOOT TH THEAD TITLE TR TT U UL VAR").split(/\s+/);
tags.each( function(tag){
scope[tag] = function() {
return Builder.node.apply(Builder, [tag].concat($A(arguments)));
};
});
}
};
/*
**
** File 'cropper.uncompressed.js'
**
*/
/**
* Image Cropper (v. 1.2.0 - 2006-10-30 )
* Copyright (c) 2006 David Spurr (http://www.defusion.org.uk/)
*
* The image cropper provides a way to draw a crop area on an image and capture
* the coordinates of the drawn crop area.
*
* Features include:
* - Based on Prototype and Scriptaculous
* - Image editing package styling, the crop area functions and looks
* like those found in popular image editing software
* - Dynamic inclusion of required styles
* - Drag to draw areas
* - Shift drag to draw/resize areas as squares
* - Selection area can be moved
* - Seleciton area can be resized using resize handles
* - Allows dimension ratio limited crop areas
* - Allows minimum dimension crop areas
* - Allows maximum dimesion crop areas
* - If both min & max dimension options set to the same value for a single axis,then the cropper will not
* display the resize handles as appropriate (when min & max dimensions are passed for both axes this
* results in a 'fixed size' crop area)
* - Allows dynamic preview of resultant crop ( if minimum width & height are provided ), this is
* implemented as a subclass so can be excluded when not required
* - Movement of selection area by arrow keys ( shift + arrow key will move selection area by
* 10 pixels )
* - All operations stay within bounds of image
* - All functionality & display compatible with most popular browsers supported by Prototype:
* PC: IE 7, 6 & 5.5, Firefox 1.5, Opera 8.5 (see known issues) & 9.0b
* MAC: Camino 1.0, Firefox 1.5, Safari 2.0
*
* Requires:
* - Prototype v. 1.5.0_rc0 > (as packaged with Scriptaculous 1.6.1)
* - Scriptaculous v. 1.6.1 > modules: builder, dragdrop
*
* Known issues:
* - Safari animated gifs, only one of each will animate, this seems to be a known Safari issue
*
* - After drawing an area and then clicking to start a new drag in IE 5.5 the rendered height
* appears as the last height until the user drags, this appears to be the related to the error
* that the forceReRender() method fixes for IE 6, i.e. IE 5.5 is not redrawing the box properly.
*
* - Lack of CSS opacity support in Opera before version 9 mean we disable those style rules, these
* could be fixed by using PNGs with transparency if Opera 8.5 support is high priority for you
*
* - Marching ants keep reloading in IE <6 (not tested in IE7), it is a known issue in IE and I have
* found no viable workarounds that can be included in the release. If this really is an issue for you
* either try this post: http://mir.aculo.us/articles/2005/08/28/internet-explorer-and-ajax-image-caching-woes
* or uncomment the 'FIX MARCHING ANTS IN IE' rules in the CSS file
*
* - Styling & borders on image, any CSS styling applied directly to the image itself (floats, borders, padding, margin, etc.) will
* cause problems with the cropper. The use of a wrapper element to apply these styles to is recommended.
*
* - overflow: auto or overflow: scroll on parent will cause cropper to burst out of parent in IE and Opera (maybe Mac browsers too)
* I'm not sure why yet.
*
* Usage:
* See Cropper.Img & Cropper.ImgWithPreview for usage details
*
* Changelog:
* v1.2.0 - 2006-10-30
* + Added id to the preview image element using 'imgCrop_[originalImageID]'
* * #00001 - Fixed bug: Doesn't account for scroll offsets
* * #00009 - Fixed bug: Placing the cropper inside differently positioned elements causes incorrect co-ordinates and display
* * #00013 - Fixed bug: I-bar cursor appears on drag plane
* * #00014 - Fixed bug: If ID for image tag is not found in document script throws error
* * Fixed bug with drag start co-ordinates if wrapper element has moved in browser (e.g. dragged to a new position)
* * Fixed bug with drag start co-ordinates if image contained in a wrapper with scrolling - this may be buggy if image
* has other ancestors with scrolling applied (except the body)
* * #00015 - Fixed bug: When cropper removed and then reapplied onEndCrop callback gets called multiple times, solution suggestion from Bill Smith
* * Various speed increases & code cleanup which meant improved performance in Mac - which allowed removal of different overlay methods for
* IE and all other browsers, which led to a fix for:
* * #00010 - Fixed bug: Select area doesn't adhere to image size when image resized using img attributes
* - #00006 - Removed default behaviour of automatically setting a ratio when both min width & height passed, the ratioDimensions must be passed in
* + #00005 - Added ability to set maximum crop dimensions, if both min & max set as the same value then we'll get a fixed cropper size on the axes as appropriate
* and the resize handles will not be displayed as appropriate
* * Switched keydown for keypress for moving select area with cursor keys (makes for nicer action) - doesn't appear to work in Safari
*
* v1.1.3 - 2006-08-21
* * Fixed wrong cursor on western handle in CSS
* + #00008 & #00003 - Added feature: Allow to set dimensions & position for cropper on load
* * #00002 - Fixed bug: Pressing 'remove cropper' twice removes image in IE
*
* v1.1.2 - 2006-06-09
* * Fixed bugs with ratios when GCD is low (patch submitted by Andy Skelton)
*
* v1.1.1 - 2006-06-03
* * Fixed bug with rendering issues fix in IE 5.5
* * Fixed bug with endCrop callback issues once cropper had been removed & reset in IE
*
* v1.1.0 - 2006-06-02
* * Fixed bug with IE constantly trying to reload select area background image
* * Applied more robust fix to Safari & IE rendering issues
* + Added method to reset parameters - useful for when dynamically changing img cropper attached to
* + Added method to remove cropper from image
*
* v1.0.0 - 2006-05-18
* + Initial verison
*
*
* Copyright (c) 2006, David Spurr (http://www.defusion.org.uk/)
* All rights reserved.
*
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* * 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.
* * Neither the name of the David Spurr nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS 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 THE COPYRIGHT OWNER OR 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.
*
* http://www.opensource.org/licenses/bsd-license.php
*
* See scriptaculous.js for full scriptaculous licence
*/
/**
* Extend the Draggable class to allow us to pass the rendering
* down to the Cropper object.
*/
var CropDraggable = Class.create();
Object.extend( Object.extend( CropDraggable.prototype, Draggable.prototype), {
initialize: function(element) {
this.options = Object.extend(
{
/**
* The draw method to defer drawing to
*/
drawMethod: function() {}
},
arguments[1] || {}
);
this.element = $(element);
this.handle = this.element;
this.delta = this.currentDelta();
this.dragging = false;
this.eventMouseDown = this.initDrag.bindAsEventListener(this);
Event.observe(this.handle, "mousedown", this.eventMouseDown);
Draggables.register(this);
},
/**
* Defers the drawing of the draggable to the supplied method
*/
draw: function(point) {
var pos = Position.cumulativeOffset(this.element);
var d = this.currentDelta();
pos[0] -= d[0];
pos[1] -= d[1];
var p = [0,1].map(function(i) {
return (point[i]-pos[i]-this.offset[i])
}.bind(this));
this.options.drawMethod( p );
}
});
/**
* The Cropper object, this will attach itself to the provided image by wrapping it with
* the generated xHTML structure required by the cropper.
*
* Usage:
* @param obj Image element to attach to
* @param obj Optional options:
* - ratioDim obj
* The pixel dimensions to apply as a restrictive ratio, with properties x & y
*
* - minWidth int
* The minimum width for the select area in pixels
*
* - minHeight int
* The mimimum height for the select area in pixels
*
* - maxWidth int
* The maximum width for the select areas in pixels (if both minWidth & maxWidth set to same the width of the cropper will be fixed)
*
* - maxHeight int
* The maximum height for the select areas in pixels (if both minHeight & maxHeight set to same the height of the cropper will be fixed)
*
* - displayOnInit int
* Whether to display the select area on initialisation, only used when providing minimum width & height or ratio
*
* - onEndCrop func
* The callback function to provide the crop details to on end of a crop (see below)
*
* - captureKeys boolean
* Whether to capture the keys for moving the select area, as these can cause some problems at the moment
*
* - onloadCoords obj
* A coordinates object with properties x1, y1, x2 & y2; for the coordinates of the select area to display onload
*
*----------------------------------------------
*
* The callback function provided via the onEndCrop option should accept the following parameters:
* - coords obj
* The coordinates object with properties x1, y1, x2 & y2; for the coordinates of the select area
*
* - dimensions obj
* The dimensions object with properites width & height; for the dimensions of the select area
*
*
* Example:
* function onEndCrop( coords, dimensions ) {
* $( 'x1' ).value = coords.x1;
* $( 'y1' ).value = coords.y1;
* $( 'x2' ).value = coords.x2;
* $( 'y2' ).value = coords.y2;
* $( 'width' ).value = dimensions.width;
* $( 'height' ).value = dimensions.height;
* }
*
*/
var Cropper = {};
Cropper.Img = Class.create();
Cropper.Img.prototype = {
/**
* Initialises the class
*
* @access public
* @param obj Image element to attach to
* @param obj Options
* @return void
*/
initialize: function(element, options) {
this.options = Object.extend(
{
/**
* @var obj
* The pixel dimensions to apply as a restrictive ratio
*/
ratioDim: { x: 0, y: 0 },
/**
* @var int
* The minimum pixel width, also used as restrictive ratio if min height passed too
*/
minWidth: 0,
/**
* @var int
* The minimum pixel height, also used as restrictive ratio if min width passed too
*/
minHeight: 0,
/**
* @var boolean
* Whether to display the select area on initialisation, only used when providing minimum width & height or ratio
*/
displayOnInit: false,
/**
* @var function
* The call back function to pass the final values to
*/
onEndCrop: Prototype.emptyFunction,
/**
* @var boolean
* Whether to capture key presses or not
*/
captureKeys: true,
/**
* @var obj Coordinate object x1, y1, x2, y2
* The coordinates to optionally display the select area at onload
*/
onloadCoords: null,
/**
* @var int
* The maximum width for the select areas in pixels (if both minWidth & maxWidth set to same the width of the cropper will be fixed)
*/
maxWidth: 0,
/**
* @var int
* The maximum height for the select areas in pixels (if both minHeight & maxHeight set to same the height of the cropper will be fixed)
*/
maxHeight: 0
},
options || {}
);
/**
* @var obj
* The img node to attach to
*/
this.img = $( element );
/**
* @var obj
* The x & y coordinates of the click point
*/
this.clickCoords = { x: 0, y: 0 };
/**
* @var boolean
* Whether the user is dragging
*/
this.dragging = false;
/**
* @var boolean
* Whether the user is resizing
*/
this.resizing = false;
/**
* @var boolean
* Whether the user is on a webKit browser
*/
this.isWebKit = /Konqueror|Safari|KHTML/.test( navigator.userAgent );
/**
* @var boolean
* Whether the user is on IE
*/
this.isIE = /MSIE/.test( navigator.userAgent );
/**
* @var boolean
* Whether the user is on Opera below version 9
*/
this.isOpera8 = /Opera\s[1-8]/.test( navigator.userAgent );
/**
* @var int
* The x ratio
*/
this.ratioX = 0;
/**
* @var int
* The y ratio
*/
this.ratioY = 0;
/**
* @var boolean
* Whether we've attached sucessfully
*/
this.attached = false;
/**
* @var boolean
* Whether we've got a fixed width (if minWidth EQ or GT maxWidth then we have a fixed width
* in the case of minWidth > maxWidth maxWidth wins as the fixed width)
*/
this.fixedWidth = ( this.options.maxWidth > 0 && ( this.options.minWidth >= this.options.maxWidth ) );
/**
* @var boolean
* Whether we've got a fixed height (if minHeight EQ or GT maxHeight then we have a fixed height
* in the case of minHeight > maxHeight maxHeight wins as the fixed height)
*/
this.fixedHeight = ( this.options.maxHeight > 0 && ( this.options.minHeight >= this.options.maxHeight ) );
// quit if the image element doesn't exist
if( typeof this.img == 'undefined' ) return;
// include the stylesheet
$A( document.getElementsByTagName( 'script' ) ).each(
function(s) {
if( s.src.match( /cropper\.js/ ) ) {
var path = s.src.replace( /cropper\.js(.*)?/, '' );
// '';
var style = document.createElement( 'link' );
style.rel = 'stylesheet';
style.type = 'text/css';
style.href = path + 'cropper.css';
style.media = 'screen';
document.getElementsByTagName( 'head' )[0].appendChild( style );
}
}
);
// calculate the ratio when neccessary
if( this.options.ratioDim.x > 0 && this.options.ratioDim.y > 0 ) {
var gcd = this.getGCD( this.options.ratioDim.x, this.options.ratioDim.y );
this.ratioX = this.options.ratioDim.x / gcd;
this.ratioY = this.options.ratioDim.y / gcd;
// dump( 'RATIO : ' + this.ratioX + ':' + this.ratioY + '\n' );
}
// initialise sub classes
this.subInitialize();
// only load the event observers etc. once the image is loaded
// this is done after the subInitialize() call just in case the sub class does anything
// that will affect the result of the call to onLoad()
if( this.img.complete || this.isWebKit ) this.onLoad(); // for some reason Safari seems to support img.complete but returns 'undefined' on the this.img object
else Event.observe( this.img, 'load', this.onLoad.bindAsEventListener( this) );
},
/**
* The Euclidean algorithm used to find the greatest common divisor
*
* @acces private
* @param int Value 1
* @param int Value 2
* @return int
*/
getGCD : function( a , b ) {
if( b == 0 ) return a;
return this.getGCD(b, a % b );
},
/**
* Attaches the cropper to the image once it has loaded
*
* @access private
* @return void
*/
onLoad: function( ) {
/*
* Build the container and all related elements, will result in the following
*
*
*
![]()
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
");
},
/**
* Wandelt bBRs in Newlines um
*/
br2nl: function(){
return this.replace(//gi, "\n");
}
});
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////// HASH FUNKTIONEN //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Object.extend(Hash.prototype,{
without:function(){
var values = $A(arguments);
return this.each(function(obj){
eval ('var object = {'+obj.key+':obj.value}');
if (values.include(obj.value) || values.include(object)) this.unset(obj.key);
}.bind(this));
}
});
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////// WRAPPER FUNKTIONEN //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Element.update() WRAPPER das event "content:changed" wird abgefeuert sobald der Inhalt geändert wird...
*/
Element.update = Element.update.wrap(
function(proceed, element, contents) {
var scripts = contents.extractScripts().partition(function(script){return (script.search(/(KuborghEvents\.require)|(\_form\_element\.init)/) >= 0)});
var contents = contents.stripScripts();
scripts[0].findAll(function(script){
return !KB.Browser.IE || !/^\<\!\-\-/.test(script);
}).map(function(script) { return eval(script) });
element = proceed(element, contents);
scripts[1].findAll(function(script){
return !KB.Browser.IE || !/^\<\!\-\-/.test(script);
}).map(function(script) { return eval(script) });
if ($(element)) $(element).fire("content:changed");
if ($(element) && scripts[0].size() || scripts[1].size()) $(element).fire("content:loaded");
return $(element);
}
);
Element.remove = Element.remove.wrap(
function(proceed, element) {
var options = Object.extend({
}, KB.parseArgument(arguments[1] || {}));
if (!element || !element.parentNode) return null;
if (element && $(element.id+'_overlay')) $(element.id+'_overlay').remove();
return proceed(element);
}
);
Element.select = Element.select.wrap(
function(proceed, element, contents) {
if (KB.Browser.WebKit || KB.Browser.MobileSafari) {
return (element.id)? $$('[id="' + element.id + '"] '+contents) : $$(element.tagName.toLowerCase() + '.' + $A(element.classNames()).first() + ' ' + contents);
} else {
return proceed(element, contents);
}
}
);
Template.prototype.evaluate = Template.prototype.evaluate.wrap(
function(proceed, object) {
if (Object.isFunction(object.toTemplateReplacements))
object = object.toTemplateReplacements();
if (object.button_cancel && !object.button_cancel.match(/js_cancel/)) object.button_cancel = '' + object.button_cancel + '';
if (object.button_ok && !object.button_ok.match(/js_ok/)) object.button_ok = '' + object.button_ok + '';
return proceed(object);
}
);
/*
**
** File 'kb.js'
**
*/
/**
* Kuborgh Klasse...
*/
var KB = { };
Object.extend(KB, {
Version: '1.0.0.0',
Browser: Object.extend(Prototype.Browser,{
IE6: ((parseInt(navigator.appVersion) == 4) && (navigator.userAgent.toLowerCase().indexOf("msie 6.") != -1)),
IE7: ((parseInt(navigator.appVersion) == 4) && (navigator.userAgent.toLowerCase().indexOf("msie 7.") != -1))
}),
Layout: null,
CornerSettings: {
tl: { radius: 10 },
tr: { radius: 10 },
bl: { radius: 10 },
br: { radius: 10 },
antiAlias: true,
autoPad: true,
validTags: ["div"]
},
CornerBoxes : [],
Timeranges : [],
Lightbox: null,
Validate: new Validate()
});
KB.Methods = (function(){
var currentLayer = null
function parseResponse(response){
var result = {
type: arguments[1] || 'Error',
message: '',
content: ''
}
if (response && Object.isString(response) && response.isJSON()){
Object.extend(result, response.evalJSON() || {});
} else if (response && Object.isString(response) && unescape(response).isJSON()){
Object.extend(result, unescape(response).evalJSON() || {});
} else if (response && Object.isString(response) && !unescape(response).isJSON()){
var type = (unescape(response).search(/^([a-zA-Z]*);/) == 0)? unescape(response).match(/^([a-zA-Z]*);/)[1] : 'Success';
var message = (unescape(response).search(/^[a-zA-Z]*;[a-zA-Z]*;/) == 0)? unescape(response).match(/^[a-zA-Z]*;([a-zA-Z]*);/)[1] : '';
var content = (unescape(response).search(/^[a-zA-Z]*;[a-zA-Z]*;/) == 0)? unescape(response).replace(/^^[a-zA-Z]*;[a-zA-Z]*;/g,''): unescape(response);
Object.extend(result, {
type: type,
message: message,
content: content
});
} else {
Object.extend(result, response || {});
}
result.type = result.type.camelize();
result.content = (result.content.search(/\*#\*#\*#\*#\*#\*#\*/) > -1)? result.content.replace(/\*#\*#\*#\*#\*#\*#\*/g, '\\') : result.content;
result = $H(result).inject($H({}),function (obj, item){
obj.set(item.key,(Object.isString(item.value))?unescape(item.value):((Object.isNumber(item.value))?new String(item.value).toString():item.value));
return obj;
}).toObject();
return result;
}
return {
/**
* Liefert das Object f�r das �bergebene Argument zur�ck (Kann JSON, Object oder undefined sein)
* @param {Object} argument
*/
parseArgument: function (argument){
return ((argument && Object.isString(argument) && unescape(argument).isJSON()) ? unescape(argument).evalJSON() : (argument || {}));
},
/**
* Elemente Ein- bzw. Ausblenden
* @param {Array || Element} elements Array von elementen oder einzelnes Element
* @param {Object} options new Effect.SlideLeftIn('demo-effect', {duration: 2, queue: 'end'});
*/
toggle: function(elements){
if (!(Object.isArray(elements) || $(elements)))
return false;
if (!Object.isArray(elements) && $(elements))
elements = [$(elements)];
// Extend Default Options
var options = Object.extend({
duration: 0.7, // duration of the effect in seconds, given as a float.
delay: 0.0, // Sets the number of seconds to wait before the effect actually starts.
effect: 'Fade', // Welcher Effect: (Fade, Blind, Slide)
force:'', // einblenden bzw. ausblenden erzwingen... (hide | show | appear | fade)
maxOpacity:0.9,
remove:false,
queue:{scope:'global'}, // um auf die queue zuzugreifen...
beforeStart: Prototype.emptyFunction, // Wid aufgerufen, bevor der Effekt gestartet wird.
beforeUpdate: Prototype.emptyFunction, // Wird bei jedem Durchlauf des Effekts vor Neuzeichnen des Elements aufgerufen.
afterUpdate: Prototype.emptyFunction, // Wird bei jedem Durchlauf des Effekts nach Neuzeichnen des Elements aufgerufen.
afterFinish: Prototype.emptyFunction // Wird am Ende des Effektes, nach dem letzten Mal Neuzeichnen aufgerufen.
}, KB.parseArgument(arguments[1]));
if (Effect.Queue.effects.size() > 0 && options.force.empty()) return;
var effectMapping = $H({
Fade: ['Fade', 'Appear'],
Opacity: ['Opacity', 'Opacity'],
Blind: ['BlindUp', 'BlindDown'],
Slide: ['SlideUp', 'SlideDown'],
SlideL: ['SlideLeftOut', 'SlideRightIn'],
SlideR: ['SlideRightOut', 'SlideLeftIn']
});
var usedEffect = (effectMapping.get(options.effect)) ? effectMapping.get(options.effect) : effectMapping.get('Fade');
var effects = [];
elements.each(function(e){
e = $(e);
if (!e) return;
var useOpacity = (e.getStyle('opacity') != null && options.effect == 'Fade' && !/((fade)|(appear))/i.test(options.force));
var effect = (useOpacity)?'Opacity':options.effect;
var maxOpacity = (useOpacity && e.getStyle('opacity') > 0.1)?e.getStyle('opacity'):options.maxOpacity;
var effectObj = (useOpacity)?effectMapping.get('Opacity'):usedEffect;
var id = e.readAttribute('id');
var overlay = (id && !id.include('overlay'))?$(id+'_overlay'):null;
// F�r Effect.Opacity zus�tzlich zu visible den test ob die opacity des Elements > 0.05 ist
var visible = e.visible() && (e.getStyle('opacity') == null || e.getStyle('opacity') > 0.09)
if ((visible && options.force == 'show') || (!visible && options.force == 'hide')) return;
if (effect == 'Opacity' && e.getStyle('display') == 'none') {
e.setStyle({
opacity: 0.0,
display:"block"
});
}
if ((visible && !/((show)|(appear))/i.test(options.force) )|| /((fade)|(hide))/i.test(options.force)) {
// effects.push(new Effect.Fade(e, { sync: true, duration: 0.001 }));
eval('effects.push(new Effect.' + effectObj[0] + '(e, { sync: true, options: options.duration ' + ((effect == 'Opacity')?',transition: Effect.Transitions.linear,from: ' + maxOpacity + ', to: 0.001 ':'') + ', queue: options.queue, object:e, afterFinish: function(){this.object.fire(\'toggle:hide\');} }));');
if (overlay) eval('effects.push(new Effect.' + effectObj[0] + '(overlay, { sync: true, options: options.duration ' + ((effect == 'Opacity')?',transition: Effect.Transitions.linear,from: ' + maxOpacity + ', to: 0.001 ':'') + ', queue: options.queue, object:e, afterFinish: function(){this.object.fire(\'toggle:hide\');}}));');
if (options.remove) {
window.setTimeout(function(){
this.remove();
if (arguments[0]) arguments[0].remove();
}.bind(e,overlay), (options.duration + 0.05 + options.delay)*1000);
}
} else if ((!visible && !/((fade)|(hide))/i.test(options.force) ) || /((show)|(appear))/i.test(options.force)){
// effects.push(new Effect.Appear(e, { sync: true, duration: 0.001 }));
eval('effects.push(new Effect.' + effectObj[1] + '(e, { sync: true, duration: options.duration ' + ((effect == 'Opacity')?',transition: Effect.Transitions.linear,from: 0.01, to: ' + maxOpacity : '') + ', queue: options.queue, object:e, afterFinish: function(){this.object.fire(\'toggle:show\');} }));');
if (overlay) eval('effects.push(new Effect.' + effectObj[1] + '(overlay, { sync: true, duration: options.duration ' + ((effect == 'Opacity')?',transition: Effect.Transitions.linear,from: 0.01, to: ' + maxOpacity : '') + ', queue: options.queue, object:e, afterFinish: function(){this.object.fire(\'toggle:show\');} }));');
}
});
new Effect.Parallel(effects, options);
document.fire('content:changed');
},
/**
* Request Wrapper...
* @param {Object} options
*/
request: function(){
var options = Object.extend({
url: '/index.php', // Url for the Request
action: '', // Action for the Request
id: '', // Id of the Element which will be replaced
element: '', // Id of the Element which will be replaced
params: {}, // Params Object
collectAll: null, // Collect all Values
collectIds: [], // Collect Values in given Id's
append: false, // Don't replace Ccontent... append it
update: true, // if set to false nothing will be updated
clean: false, // clean up the form...
success_extra: '',
successFunc: Prototype.emptyFunction,
onSuccess: Prototype.emptyFunction,
failureFunc: Prototype.emptyFunction,
onFailure: Prototype.emptyFunction,
onLoad: Prototype.emptyFunction,
beforeStart: Prototype.emptyFunction,
functionParams: {},
template: '#{content}',
infoElement: '',
effectElement: '',
errorElement: 'global_error_stack_output',
infoElementContainer: '',
errorElementContainer: 'global_error_stack_output_container',
// Effect Zeug
effect: false,
effectOptions:{},
overlay: true,
overlayOptions: {},
keepOverlay: false,
indicator: null,
duration: 0.7,
// Deprecated
doRedirect: false,
// redirectOnSuccess (True, false)
redirectOnSuccess: false,
redirectURL: window.location.href,
redirectOverlay: false
}, KB.parseArgument(arguments[0]) || {});
if (options.onSuccess != Prototype.emptyFunction) options.successFunc = options.onSuccess;
if (options.onFailure != Prototype.emptyFunction) options.failureFunc = options.onFailure;
if (options.onLoad != Prototype.emptyFunction) options.beforeStart = options.onLoad;
options.template = new Template(options.template);
options.infoElement = ($(options.errorElement))? $(options.errorElement) : $(options.infoElement);
options.infoElementContainer = ($(options.errorElementContainer))? $(options.errorElementContainer) : $(options.infoElementContainer);
if (!options.infoElementContainer && options.infoElement) options.infoElementContainer = options.infoElement;
//if (options.infoElementContainer) options.infoElementContainer.hide();
var element = ($(options.id))?$(options.id):$(options.element);
if (!element) options.update = false;
effectElement = $(options.effectElement);
if (!effectElement) effectElement = element;
options.overlayOptions = Object.extend({
bgColor : (effectElement) && effectElement.getBgColor() ? '#'+effectElement.getBgColor().cleanHex : '',
indicator: options.indicator
},options.overlayOptions);
var overlay = (options.overlay)?((effectElement && options.overlay)? KB.overlay(effectElement,options.overlayOptions) : null):null;
// Post Parameter zusammensetzen...
// Alle inputs innerhalb der Elemente die �ber collectIds angegeben sind
if (!Object.isArray(options.collectIds)) options.collectIds = [options.collectIds];
if (Object.isArray(options.collectIds)) {
options.collectIds.each(function(el){
collectElement = $(el);
if (collectElement) {
options.params = Object.extend(collectElement.collectValues(),options.params);
if (options.clean) collectElement.clearValues();
}
});
}
// alles holen (jeder Input im Document)
if (options.collectAll) {
options.params = Object.extend($(document.getElementsByTagName("body").item(0)).collectValues(), options.params);
if (options.clean) $(document.getElementsByTagName("body").item(0)).clearValues();
}
// action setzen
if (!options.action.empty()) {
Object.extend(options.params, {
action: unescape(options.action).match(/^[^&]*/).first()
});
// fals an action weitere parameter angeh�ngt wurden...
if (unescape(options.action).search(/&/) != -1){
Object.extend(options.params, unescape(options.action).match(/&.*/).first().parseQuery());
}
}
options.params = $H(options.params);
if (!element && options.params.get('destId') && $(options.params.get('destId'))) {
element = $(options.params.get('destId'));
options.id = $(options.params.get('destId'));
}
var opt = {
// Use POST
method: 'post',
contentType: 'application/x-www-form-urlencoded',
encoding: 'utf-8',
// Send this lovely data
postBody: options.params.toQueryString(),
// Handle successful response
onSuccess: function(t){
var options = this;
var element = ($(options.id))?$(options.id):$(options.element);
var response = parseResponse(t.responseText);
options.functionParams = Object.extend(options.functionParams,{
response:response
});
// Redirect im Erfogsfall
if (response.type == "Success" && options.redirectOnSuccess && !options.redirectURL.empty()){
if (options.redirectOverlay){
var windowOverlay = KB.overlay('document');
KB.toggle(windowOverlay,{
duration: options.duration,
effect: 'Fade',
force: 'show'
});
}
setTimeout(function(){
self.location=options.redirectURL;
}, options.duration * 1100);
return;
}
// Error Handling...
if (options.infoElement && !response.message.empty()) {
var queue = Effect.Queues.get('info');
queue.each(function(effect) {
effect.cancel();
});
options.infoElement.classNames().each(function(e){
if (e.include('errorStack')) options.infoElement.removeClassName(e);
});
Element.update(options.infoElement, response.message);
options.infoElement.addClassName('errorStack'+response.type);
KB.toggle(options.infoElementContainer,Object.extend({
effect: options.effect,
force: 'show',
delay: 0.5,
queue:{scope:'info'}
},options.effectOptions));
KB.toggle(options.infoElementContainer,Object.extend({
effect: options.effect,
force: 'hide',
delay: 10.0,
queue:{scope:'info'}
},options.effectOptions));
}
if (options.update) {
if (response.type != 'Error'){
if (response.content && element) {
response.content = (options.append)
? element.innerHTML + options.template.evaluate(response)
: options.template.evaluate(response);
response.content = response.content.getInnerHtml(element.readAttribute('id'));
Element.update(element, response.content);
}
}
}
if (effectElement) {
if (options.effect && !KB.Browser.IE6) KB.toggle(effectElement,Object.extend({
duration: options.duration,
effect: options.effect,
force: 'show'
},options.effectOptions));
if (options.overlay && !options.keepOverlay) {
KB.toggle(overlay,Object.extend({
duration: options.duration,
effect: 'Fade',
force: 'hide'
},options.effectOptions));
window.setTimeout(function(){
if (overlay) overlay.remove();
}, options.duration * 1100);
}
}
if (Object.isString(options.success_extra) && options.success_extra.length > 0 && response.type != 'Error') {
eval(options.success_extra);
}
// Own functions for success/failure
options.functionParams = Object.extend(options.functionParams,{
response:Object.extend({
template:options.template
},response),
overlay : overlay,
request : options.params.toObject()
});
if (Object.isFunction(options.successFunc) && response.type == 'Success'){
options.successFunc(element,options.functionParams);
}
if (Object.isFunction(options.failureFunc) && response.type != 'Success'){
options.failureFunc(element,options.functionParams);
}
}.bind(options),
// Handle 404
on404: function(t){
var options = this;
var response = parseResponse(t.statusText,'Error');
// Own functions for success/failure
options.functionParams = Object.extend(options.functionParams,{
response:Object.extend({
template:options.template
},response)
});
if (Object.isFunction(options.failureFunc) && response.type != 'Success'){
options.failureFunc(element,functionParams);
}
}.bind(options),
// Handle other errors
onFailure: function(t){
var options = this;
var response = parseResponse(t.statusText,'Error');
// Own functions for success/failure
options.functionParams = Object.extend(options.functionParams,{
response:Object.extend({
template:options.template
},response)
});
if (Object.isFunction(options.failureFunc) && response.type != 'Success'){
options.failureFunc(element,functionParams);
}
}.bind(options)
}
if (effectElement) {
if (options.effect && !KB.Browser.IE6) KB.toggle(effectElement,Object.extend({
duration: options.duration,
effect: options.effect,
force: 'hide'
},options.effectOptions));
if (options.overlay) KB.toggle(overlay,Object.extend({
duration: options.duration,
effect: 'Fade',
force: 'show'
},options.effectOptions));
}
options.beforeStart(element,options);
setTimeout(function(){
// Anfrage nicht per Ajax senden, sondern per self.location
//
if (options.doRedirect) {
self.location=options.url+'?'+opt['postBody'];
} else {
new Ajax.Request(options.url, opt);
}
}, options.duration * 1100);
},
/**
* Erstellt ein Overlay f�r das angegebene Element im DOM z.B. verwendet f�r
* @param {Object} element
* @param {Object} options
*/
overlay:function(element){
var bodyOverlay = (element == 'document' || element == 'body');
var elem = (!bodyOverlay)? $(element) : $(document.getElementsByTagName("body").item(0));
if (!elem) return null;
var options = Object.extend({
bgColor: null,
close: false,
dimensions: null,
indicatorDimensions: {width:16,height:16},
indicator: null,
className:'overlay',
opacity:0.8,
id:(bodyOverlay)?'window':elem.id
}, KB.parseArgument(arguments[1]) || {});
var overlayid = options.id + '_overlay';
// IE Bugfix Overlay jedesmal neu erstellen und das alte l�schen
if (elem && $(overlayid) && (KB.Browser.IE || KB.Browser.IE6) && !bodyOverlay) {
$(overlayid).remove();
}
if (elem && !$(overlayid)) {
var objOverlay = new Element("div",{id:overlayid,style:'position:absolute;display:none;z-index:999'});
var indicator = (options.indicator && Object.isString(options.indicator) && !options.indicator.empty())
? new Element('img',{src:options.indicator,id: elem.id+'_overlay_loader'})
: null;
if (indicator) objOverlay.insert({top:indicator});
else objOverlay.insert({top: new Element("div")});
$(document.getElementsByTagName("body").item(0)).insert({bottom: objOverlay});
objOverlay.clonePosition(elem);
if (bodyOverlay){
var dim = KB.getPageSize();
//var dim = $(document.getElementsByTagName("body").item(0)).getDimensions();
var height1 = $(document.getElementsByTagName("body").item(0)).getHeight();
var height2 = $(document.getElementsByTagName("body").item(0)).firstDescendant().getHeight();
var height = (height1 > height2)?height1 :height2;
height = (dim[1] > height)?dim[1] :height;
objOverlay.setStyle({
width: '100%',
height:height+'px'
});
//var dim = $(document.getElementsByTagName("body").item(0)).getDimensions();
//var height1 = $(document.getElementsByTagName("body").item(0)).getHeight();
//var height2 = $(document.getElementsByTagName("body").item(0)).firstDescendant().getHeight();
//objOverlay.setStyle({
// width:dim.width+'px',
// height:((height1 > height2)?height1 :height2)+'px'
//});
}
var cDimensions = objOverlay.getDimensions();
if (!cDimensions.width && !cDimensions.height) cDimensions = elem.getDimensions();
var lDimensions = (options.indicator)?indicator.getDimensions():{width:0,height:0};
if (lDimensions.width == 0) lDimensions = options.indicatorDimensions;
if (options.indicator) {
var indicatorTop = 0;
if (bodyOverlay){
var dim = KB.getPageSize();
var arrayPageScroll = document.viewport.getScrollOffsets();
indicatorTop = arrayPageScroll[1] + ((document.viewport.getHeight()- lDimensions.height) / 2);
indicatorTop = dim.windowHeight/2 - lDimensions.height / 2;
if (parseInt (navigator.appVersion) >3 ) {
if (navigator.appName.indexOf ('Microsoft')!= -1) {
indicatorTop = arrayPageScroll[1] + ((document.body.offsetHeight- lDimensions.height) / 2);
}
}
} else {
indicatorTop = (cDimensions.height - lDimensions.height)/2;
}
indicator.absolutize();
indicator.setStyle({
left: (cDimensions.width - lDimensions.width)/2+'px',
top: indicatorTop +'px',
width: lDimensions.width+'px',
height: lDimensions.height+'px'
});
}
var changeContent = function(event){
// Overlayposition anpassen
if (bodyOverlay){
var dim = KB.getPageSize();
var height1 = $(document.getElementsByTagName("body").item(0)).getHeight();
var height2 = $(document.getElementsByTagName("body").item(0)).firstDescendant().getHeight();
var height = (height1 > height2)?height1 :height2;
height = (dim[1] > height)?dim[1] :height;
//var dim = $(document.getElementsByTagName("body").item(0)).getDimensions();
//var height1 = $(document.getElementsByTagName("body").item(0)).getHeight();
//var height2 = $(document.getElementsByTagName("body").item(0)).firstDescendant().getHeight();
this.setStyle({
width: '100%',
height:height+'px'
});
} else {
this.clonePosition(event.element());
}
// indicatorposition in mitte setzen...
if ($(arguments[1])){
var cDimensions = this.getDimensions();
var lDimensions = arguments[1].getDimensions();
var indicatorTop = 0;
if (bodyOverlay){
var arrayPageScroll = document.viewport.getScrollOffsets();
indicatorTop = arrayPageScroll[1] + ((document.viewport.getHeight()- lDimensions.height) / 2);
indicatorTop = dim.windowHeight/2 - lDimensions.height / 2 - dim.windowHeight/10;
/*if (parseInt (navigator.appVersion) >3 ) {
if (navigator.appName.indexOf ('Microsoft')!= -1) {
indicatorTop = arrayPageScroll[1] + ((document.body.offsetHeight- lDimensions.height) / 2);
}
}*/
} else {
indicatorTop = (cDimensions.height - lDimensions.height)/2;
}
arguments[1].absolutize();
arguments[1].setStyle({
left: (cDimensions.width - lDimensions.width)/2+'px',
top: indicatorTop +'px',
//position: (KB.Browser.IE)?'absolute':'fixed'
position: 'absolute'
});
}
}
if (bodyOverlay){
// Start Observer to content:changed to resize the overlay if content changes
document.stopObserving('content:changed');
document.observe('content:changed', changeContent.bindAsEventListener(objOverlay,indicator));
} else {
// Start Observer to content:changed to resize the overlay if content changes
$(elem).stopObserving('content:changed');
$(elem).observe('content:changed', changeContent.bindAsEventListener(objOverlay,indicator));
objOverlay.observe('overlay:changed', changeContent.bindAsEventListener(objOverlay,indicator));
}
if (indicator && !indicator.visible()) new Effect.Appear(indicator,{duration:0.5});
if (options.bgColor && /\#[a-fA-F0-9]{3,6}|(transparent)/.test(options.bgColor)) objOverlay.setStyle({backgroundColor: options.bgColor.match(/\#[a-fA-F0-9]{3,6}|(transparent)/).first()});
if (options.opacity) objOverlay.setStyle({opacity: options.opacity });
if (options.className) objOverlay.addClassName(options.className);
this.currentLayer = objOverlay;
} else if ($(overlayid)){
this.currentLayer = $(overlayid);
var indicator = this.currentLayer.select('img').first();
if (bodyOverlay){
document.fire("content:changed");
var dim = KB.getPageSize();
//var dim = $(document.getElementsByTagName("body").item(0)).getDimensions();
//var height1 = $(document.getElementsByTagName("body").item(0)).getHeight();
//var height2 = $(document.getElementsByTagName("body").item(0)).firstDescendant().getHeight();
this.currentLayer.setStyle({
width:dim[0]+'px',
height:dim[1]+'px'
});
}
if (indicator && !indicator.visible()) new Effect.Appear(indicator,{duration:0.5});
}
this.currentLayer.indicator = function(){
return this.select('img').first();
}.bind(this.currentLayer );
return this.currentLayer;
},
getLayout: function(){
return (KB.Layout)?KB.Layout:KB.setLayout();
},
setLayout: function(){
KB.Layout = {};
var options = Object.extend({
header: 'header',
content: 'content',
footer: 'footer'
}, KB.parseArgument(arguments[0]) || {});
var ps = KB.getPageSize();
Object.extend(KB.Layout,{
header: KB.Layout.header ? KB.Layout.header : (($(options.header))? $(options.header).getDimensions() : {width:0,height:0}),
footer: KB.Layout.footer ? KB.Layout.footer : (($(options.footer))? $(options.footer).getDimensions() : {width:0,height:0}),
content: (($(options.content))? $(options.content).getDimensions() : {width:0,height:0}),
viewport: {width: ps.windowWidth, height: ps.windowHeight}
});
$H(options).findAll(function(object){return ($(object.value) != null)}).each(function(object){
var relevantStyles = $H($(object.value).getStyles()).findAll(function(style){return style.key.match(/((margin)|(border))/i);});
var w = relevantStyles.findAll(function(style){return style.key.match(/(left)|(right)/i) && !style.key.match(/(color)/i);}).collect(function(s){return s.value.replace(/[^\d]*/g,'');}).inject(0, function(acc, n) { return Number(acc) + Number(n); });
var h = relevantStyles.findAll(function(style){return style.key.match(/(top)|(bottom)/i) && !style.key.match(/(color)/i) ;}).collect(function(s){return s.value.replace(/[^\d]*/g,'');}).inject(0, function(acc, n) { return Number(acc) + Number(n); });
eval('KB.Layout.'+object.key+'.width = KB.Layout.'+object.key+'.width + '+w+';');
eval('KB.Layout.'+object.key+'.height = KB.Layout.'+object.key+'.height + '+h+';');
});
return KB.Layout;
},
addCorners: function(el) {
var element = $(el);
if (!element || KB.CornerSettings.validTags.indexOf(element.tagName.toLowerCase()) < 0 || !element.id) return;
KB.CornerBoxes.push(new curvyCorners(KB.CornerSettings, element.id));
},
roundCorners: function(){
KB.CornerBoxes.each(function(el){
el.applyCornersToAll();
});
},
getPageSize: function() {
var xScroll, yScroll;
if (window.innerHeight && window.scrollMaxY) {
xScroll = window.innerWidth + window.scrollMaxX;
yScroll = window.innerHeight + window.scrollMaxY;
} else if (document.body.scrollHeight > document.body.offsetHeight){ // all but Explorer Mac
xScroll = document.body.scrollWidth;
yScroll = document.body.scrollHeight;
} else { // Explorer Mac...would also work in Explorer 6 Strict, Mozilla and Safari
xScroll = document.body.offsetWidth;
yScroll = document.body.offsetHeight;
}
var windowWidth, windowHeight;
if (self.innerHeight) { // all except Explorer
if(document.documentElement.clientWidth){
windowWidth = document.documentElement.clientWidth;
} else {
windowWidth = self.innerWidth;
}
windowHeight = self.innerHeight;
} else if (document.documentElement && document.documentElement.clientHeight) { // Explorer 6 Strict Mode
windowWidth = document.documentElement.clientWidth;
windowHeight = document.documentElement.clientHeight;
} else if (document.body) { // other Explorers
windowWidth = document.body.clientWidth;
windowHeight = document.body.clientHeight;
}
// for small pages with total height less then height of the viewport
if(yScroll < windowHeight){
pageHeight = windowHeight;
} else {
pageHeight = yScroll;
}
// for small pages with total width less then width of the viewport
if(xScroll < windowWidth){
pageWidth = xScroll;
} else {
pageWidth = windowWidth;
}
var res = $H({
windowWidth: windowWidth,
windowHeight: windowHeight,
pageWidth: pageWidth,
pageHeight: pageHeight
});
res.set('0',pageWidth);
res.set('1',pageHeight);
return res.toObject();
},
confirm: function(element){
var options = Object.extend({
onOk:Prototype.emptyFunction,
onCancel:Prototype.emptyFunction,
onLoad:Prototype.emptyFunction,
cancelObj:[],
okObj:[]
}, KB.parseArgument(arguments[1]) || {});
if (!$(element) && Object.isString(element)) {
options.onLoad(element,options);
if (confirm(element)){
options.onOk(element,options);
} else {
options.cancelObj(element,options);
}
}
if (!$(element)) return null;
var element = $(element);
var dim = element.getDimensions();
var overlay = KB.overlay('document',{
indicator:null,
bgColor:null
});
element.setStyle({
left:((KB.getLayout().viewport.width - dim.width)/2)+'px',
top:((KB.getLayout().viewport.height - dim.height)/2)+'px',
zIndex:1001,
position:((KB.Browser.IE || KB.Browser.IE6)?'absolute':'fixed')
});
overlay.insert({after:$(element)});
overlay.show();
element.show();
options.onLoad(element,options);
options.cancelObj.push(overlay);
options.cancelObj.each(function(el){
if ($(el)) {
Event.observe(el,'click',function(){
overlay.hide();
element.hide();
options.onCancel(element,options);
options.cancelObj.concat(options.okObj).findAll(function(el){return $(el);}).each(function(el){Event.stopObserving(el,'click');});
});
}
});
options.okObj.each(function(el){
if ($(el)) {
Event.observe(el,'click',function(){
if ((options.onOk == Prototype.emptyFunction)?true:options.onOk(element,options)){
overlay.hide();
element.hide();
}
});
}
});
}
}
})();
KB.Confirm = {
/**
* Ruft modal Dialog auf
*/
modal: function(element){
var options = Object.extend({
onOk:Prototype.emptyFunction,
onCancel:Prototype.emptyFunction,
onLoad:Prototype.emptyFunction,
cancelObj:[],
okObj:[],
params:{},
handle:null,
draggable:null,
duration: 1.0
}, KB.parseArgument(arguments[1] || {}));
var overlay = KB.overlay('document',{
indicator:'/img/lightbox/loading.gif',
indicatorDimensions: {width:32,height:32},
bgColor:null
}).show();
if (!$(element) && KB.Validate.isURL(element)) {
// Get Ajax return before inserting page (options.urlobject kommt aus
var url = element;
var element = new Element('div').hide();
$(document.getElementsByTagName("body").item(0)).insert({bottom:element});
KB.request({
element:element,
url:url,
effect:null,
params: Object.extend({
popup:1,
modal:1
},options.params),
successFunc: KB.Confirm.modal,
functionParams:Object.extend({
deleteElement: true
},options)
});
return false;
} else {
overlay.select('img').first().hide();
}
var element = $(element);
var dim = element.getDimensions();
if (!$(element) && Object.isString(element)) {
options.onLoad(element,options);
if (confirm(element)){
options.onOk(element,options);
} else {
options.cancelObj(element,options);
}
}
if (!$(element)) {
overlay.hide();
return null;
}
if (options.draggable) {
options.draggable = new Draggable($(element),Object.extend(options,{ scroll: window }));
}
element.setStyle({
left:((KB.Layout.viewport.width - dim.width)/2)+'px',
top:((KB.Layout.viewport.height - dim.height)/2)+'px',
zIndex:1001,
xposition:((KB.Browser.IE || KB.Browser.IE6)?'absolute':'fixed')
});
overlay.insert({after:$(element)});
overlay.show();
element.show();
options.onLoad(element,options);
options.cancelObj.push(overlay);
options.cancelObj.each(function(el){
if ($(el)) {
Event.observe(el,'click',function(){
overlay.hide();
options.onCancel(element,options);
options.cancelObj.concat(options.okObj).findAll(function(el){return $(el);}).each(function(el){Event.stopObserving(el,'click');});
if (options.deleteElement) element.remove()
else element.hide();
});
}
});
options.okObj.each(function(el){
if ($(el)) {
Event.observe(el,'click',function(){
if ((options.onOk == Prototype.emptyFunction)?true:options.onOk(element,options)){
overlay.hide();
if (options.deleteElement) element.remove()
else element.hide();
}
});
}
});
}
};
Object.extend(KB, KB.Methods)
document.observe("dom:loaded",KB.roundCorners);
document.observe("dom:loaded", function(){
document.fire('content:changed');
if (!KB.Browser.IE) {
Event.observe(window,'load',function(){
document.fire('content:changed');
document.fire('content:resize');
});
Event.observe(window,'resize',function(){
document.fire('content:resize');
});
Event.observe(window, 'change', function(){
document.fire('content:resize');
});
} else {
// security check for undefinded functions
if ((typeof window.onresize).toUpperCase() != "FUNCTION")window.onresize = Prototype.emptyFunction;
if ((typeof window.onchange).toUpperCase() != "FUNCTION")window.onchange = Prototype.emptyFunction;
if ((typeof window.onload).toUpperCase() != "FUNCTION")window.onload = Prototype.emptyFunction;
// wraporiginal functions and dispatch events
window.onresize = window.onresize.wrap(function(proceed){
proceed();
document.fire('content:resize');
});
window.onchange = window.onchange.wrap(function(proceed){
proceed();
document.fire('content:resize');
});
window.onload = window.onload.wrap(function(proceed){
proceed();
document.fire('content:changed');
document.fire('content:resize');
});
}
});
document.observe("content:changed", function(){
document.fire('content:resize');
});
/*
*/
/*
**
** 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(''+"\n" });
this.options.response.content+= tmpElement.innerHTML;
this.options.response.content+= scripts[1].inject('', function(script, n) { return script + ''+"\n" });
$A(DialogOptions.forbiddenCssClasses).each(function(css){
this.select('.'+css).invoke('removeClassName',css);
}.bind(tmpElement));
this.replacement = this.options.response;
this.html = this.template.evaluate(this.options.response);
}
// DialogManager aktualisieren
if (this.options.id) {
this.options.status.loading = false;
this.options.status.ready = true;
KB.DialogManager.set(this.options.id,this);
}
if (this.options.status.waiting) {
this.options.status.waiting = false;
this.show();
}
},
overlay:function(){
if (!this._overlay && !this.initOverlay()) return null;
this._overlay.clonePosition(this._element).setStyle({zIndex: (parseInt(this._element.getStyle('zIndex')) + 1)});
if (!KB.Browser.IE) this._overlay.setStyle({position:'fixed'});
return this._overlay;
},
initOverlay:function(){
// Dialog - interne variablen initialisieren
if (!this._element) return false;
this._overlay = (this._overlay)? this._overlay : KB.overlay(this._element,{
bgColor:(this.options.modal)?null:'transparent',
indicator: this.options.indicator,
opacity:0.5,
indicatorDimensions: this.options.indicatorDimensions
}).hide();
this._overlay.id = this.options.id+'_overlay';
this._overlay.clonePosition(this._element);
return this._overlay;
},
initEvents:function(element){
// onCancel Event
if (this.options.cancelOnOverlay) this.options.cancelObj.push(KB.DialogManager.overlay());
this.options.cancelObj.concat($$('.js_cancel')).each(function(el){
if ($(el)) {
$(el).observe('click',function(event){
this.hide();
this.result = false;
this.options.onCancel(event,this);
this.options.onCancelIntern(event,this);
this.options.cancelObj.concat(this.options.okObj).findAll(function(el){return $(el);}).each(function(el){Event.stopObserving(el,'click');});
}.bindAsEventListener(this));
$(el).observe('mouseover',function(event){
event.element().style.cursor='pointer';
}.bindAsEventListener(this));
}
}.bind(this));
// onOk Event
this.options.okObj.concat($$('.js_ok')).each(function(el){
if ($(el)) {
$(el).observe('click',function(event){
if (this.options.require && KB.DialogManager.get(this.options.require)){
if (this.overlay()) KB.toggle(this.overlay(),{ force: 'show' });
KB.DialogManager.get(this.options.require).show({
onOkIntern: function(){
if ((this.options.onOk == Prototype.emptyFunction) || this.options.onOk(event,this)){
this.hide();
this.result = true;
this.options.cancelObj.concat(this.options.okObj).findAll(function(el){return $(el);}).each(function(el){Event.stopObserving(el,'click');});
}
}.bind(this)
});
} else {
if ((this.options.onOk == Prototype.emptyFunction) || this.options.onOk(event,this)){
this.hide();
this.result = true;
this.options.onOkIntern(event,this);
this.options.cancelObj.concat(this.options.okObj).findAll(function(el){return $(el);}).each(function(el){Event.stopObserving(el,'click');});
}
}
}.bindAsEventListener(this));
$(el).observe('mouseover',function(event){
event.element().style.cursor='pointer';
}.bindAsEventListener(this));
}
}.bind(this));
},
clearEvents:function(element){
// onCancel Event
if (this.options.cancelOnOverlay) this.options.cancelObj.push(KB.DialogManager.overlay());
this.options.cancelObj.concat($$('.js_cancel')).each(function(el){
if ($(el)) {
Event.stopObserving($(el));
}
});
// onOk Event
this.options.okObj.concat($$('.js_ok')).each(function(el){
if ($(el)) {
if ($(el)) {
Event.stopObserving($(el));
}
}
});
// Alle events innerhalb des dialogs
if ($(this._element)) {
this._element.descendants().reject(function(el){
return Object.isUndefined(el._prototypeEventID);
}).each(function(el){
Event.stopObserving(el);
});
}
document.stopObserving('dialog:ready');
},
setZ: function(zIndex){
if ($('Dialog:'+this.options.id+'_dialog')) $('Dialog:'+this.options.id+'_dialog').setStyle({zIndex:((this.options.modal)?this.baseZIndex:this.baseZIndex-200) + (zIndex * 2)});
},
element: function(){
return this._element;
},
infoElement: function(){
return (this._element) ? Element.select(this._element,this.options.infoClass).first() : null;
},
infoContainer: function(){
return (this._element) ? Element.select(this._element,this.options.infoContainerClass).first() : null;
},
form: function(){
return (this._element) ? Element.select(this._element,'form').first() : null;
}
});
/* DIALOG */
KB.Dialog = Class.create(KB.Dialog.Base, {
initialize: function(element,options) {
this.baseInitialize(element, options);
},
show: function(){
this.options = Object.extend(this.options, KB.parseArgument(arguments[0]) || {});
this.replacement = Object.extend(this.replacement, this.options.response);
if (this.options.require) KB.DialogManager.setResult(this.options.require,false);
if ($('Dialog:'+this.options.id+'_dialog')) return;
if (this.options.modal && !KB.DialogManager.overlayActive()) {
KB.toggle(KB.DialogManager.overlay(),{force:'show',duration:window.DialogOptions.fadeDuration});//this.overlay.show()
if (this.options.status.waiting && KB.DialogManager.overlay().indicator()) KB.DialogManager.overlay().indicator().show();
}
if (!this.options.status.ready || this.options.status.loading ) {
if (KB.DialogManager.overlay() && KB.DialogManager.overlay().indicator()) KB.toggle(KB.DialogManager.overlay().indicator(),{force:'show',duration:window.DialogOptions.fadeDuration});
this.options.status.waiting = true;
if (!this.options.init) {
this.options.init = true;
this.baseInitialize(this.source,this.options);
}
return false;
} else {
if (KB.DialogManager.overlay() && KB.DialogManager.overlay().indicator()) KB.toggle(KB.DialogManager.overlay().indicator(),{force:'hide',duration:window.DialogOptions.fadeDuration});
//var template = new Template(this.html);
if (this.template) this.html = this.template.evaluate(this.replacement);
this.html = this.html.replace(/\{\*[^\}]*\*\}/gi,'');
}
var element = new Element('div',{id:'Dialog:'+this.options.id+'_dialog', style:'display:none'},this.html);
$(document.getElementsByTagName("body").item(0)).insert({bottom:element});
Element.update(element,this.html);
var dimensions = element.getDimensions();
var pageDimensions = KB.getPageSize();
dimensions.top = (pageDimensions.windowHeight - dimensions.height)/4;
dimensions.left = (pageDimensions.windowWidth - dimensions.width)/2;
if ( dimensions.top < 0 ) dimensions.top = 0;
this.style = (KB.Browser.IE || KB.Browser.IE6)
? {
position:'absolute',
left:dimensions.left+'px',
top:dimensions.top+'px'
}:{
left:dimensions.left+'px',
top:dimensions.top+'px',
position:'fixed'
};
element.setStyle(this.style);
element.addClassName('dialog');
this.setZ(this.options.index);
this._element = element;
this.options.onLoad(this._element,this.options);
if (KB.DialogManager.overlay() && !KB.DialogManager.overlayActive()) {
window.setTimeout(function(){
//this.show();
KB.toggle(this.element(),{
force:'show',
duration:window.DialogOptions.fadeDuration,
beforeStart:function(){ element.fire("dialog:loading"); },
afterUpdate:function(){ element.fire("dialog:fading"); },
afterFinish:function(){
element.fire("dialog:loaded");
element.fire("dialog:ready");
this.initEvents(element);
}.bind(this)
});
}.bind(this), 550);
} else {
KB.toggle(this.element(),{
force:'show',
duration:window.DialogOptions.fadeDuration,
beforeStart:function(){ element.fire("ajax:loaded");element.fire("dialog:loading");},
afterUpdate:function(){ element.fire("dialog:fading"); },
afterFinish:function(){
element.fire("dialog:loaded");
element.fire("dialog:ready");
this.initEvents(element);
}.bind(this)
});
}
var handle = [$(this.options.handle)].concat($(element).select(this.options.handle)).detect(function(e){return $(e);});
if (handle) {
handle.observe('mouseover',function(event){
var pointer = this.options.cancelObj.concat(element.select('.js_cancel')).concat(this.options.okObj.concat(element.select('.js_ok')))
if (pointer.indexOf(event.element()) < 0) {
event.element().style.cursor='move';
}
this.bringToFront();
}.bindAsEventListener(this));
this.draggable = new Draggable($(element),Object.extend({
scroll: window,
handle:handle,
onDrag : function(){
this.bringToFront();
this.options.onDrag.bind(this)
}.bind(this)
}));
}
this.bringToFront();
this.initOverlay()
},
hide: function(){
var element = $('Dialog:'+this.options.id+'_dialog');
var overlay = KB.DialogManager.overlay();
this.clearEvents(element);
if (this.draggable) this.draggable.destroy();
if (overlay && KB.DialogManager.countActive().modal <= 1) new Effect.Fade(KB.DialogManager.overlay(),{duration:window.DialogOptions.fadeDuration});//overlay.hide();
if (element) {
KB.toggle(this.element(),{
force:'hide',
duration:window.DialogOptions.fadeDuration,
afterFinish:function(){
if (this._element) {
this._element.fire('dialog:closed');
this.element().remove();
this._element = null;
}
}.bind(this)
});
}
},
visible: function(){
return $('Dialog:'+this.options.id+'_dialog') != null;
},
bringToFront: function(){
KB.DialogManager.bringToFront(this);
}
});
KB.DialogManager = (function(){
return {
dialogs: $H({}),
register: function(id,source) {
var options = Object.extend({
index:this.dialogs.values().size(),
id:id
}, KB.parseArgument(arguments[2]) || {});
this.dialogs.set(id,'pending...');
var dialog = new KB.Dialog(source,options);
this.dialogs.set(id,dialog);
return this.dialogs;
},
unregister: function(id){
this.dialogs.unset(id);
return this.dialogs;
},
get: function(id){
return this.dialogs.get(id);
},
getActive: function(){
return this.dialogs.values().find(function(dialog){
return (dialog.visible());
});
},
set: function(id,dialog){
this.dialogs.set(id,dialog);
},
count: function(){
return this.dialogs.values().size();
},
countActive: function(){
var index = 0;
var indexModal = 0;
var active = this.getActive();
this.dialogs.values().each(function(dialog,i){
if (dialog.visible()){
++index;
if (dialog.options.modal) ++indexModal;
}
});
return {all:index,modal:indexModal};
},
bringToFront: function(dialog){
var index = 0;
var dIndex = dialog.options.index;
this.dialogs.values().each(function(dialog,i){
if (dialog.visible() && dialog.options.index != dIndex) {
dialog.setZ(++index);
}
}.bind(dialog))
dialog.setZ(++index);
},
overlay: function() {
return (this._overlay) ? this._overlay : this.initOverlay();
},
initOverlay:function(){
// Dialog - interne variablen initialisieren
this._overlay = (this._overlay)? this._overlay : KB.overlay('document',{
bgColor:null,
indicator: window.DialogOptions.fileIndicator,
transparentIndicator: (window.DialogOptions.fileIndicatorTransparent)?window.DialogOptions.fileIndicatorTransparent:null,
indicatorDimensions: window.DialogOptions.indicatorDimensions,
id: 'dialog'
}).hide();
if (this._overlay.indicator()) this._overlay.indicator().hide();
return this._overlay;
},
overlayActive: function(){
//return !Object.isUndefined(this.dialogs.values().find(function(dialog){
// return dialog.overlay && dialog.overlay.visible();
//}));
return this._overlay && this._overlay.visible();
},
getResult: function(id){
return (this.dialogs.get(id))? this.dialogs.get(id).result: true;
},
setResult: function(id,result){
if (this.dialogs.get(id)) this.dialogs.get(id).result = result;
},
parseLinks: function(event) {
$$('a').findAll(function(link){
var rel = link.readAttribute('rel');
return rel && rel.include('dialog');
}).each(function(dialog,index){
var source = dialog.readAttribute('href');
if (!source) return;
dialog.writeAttribute({href:'javascript:void(0);'});
var id = (dialog.readAttribute('id'))? dialog.readAttribute('id') : index;
var snippet = 'default';
if (dialog.readAttribute('rel').search(/\[([^\]]*)\]/) >= 0 && !dialog.readAttribute('rel').match(/\[([^\]]*)\]/).last().empty()) {
snippet = dialog.readAttribute('rel').match(/\[([^\]]*)\]/).last();
}
var options = {
submit: dialog.readAttribute('submit') || 'normal',
title: dialog.readAttribute('title'),
onSuccess: (dialog.readAttribute('onsuccess'))? '' : '',
onFailure: (dialog.readAttribute('onfailure'))? '' : '',
modal: dialog.hasClassName('modal'),
init: (dialog.readAttribute('init') && parseInt(dialog.readAttribute('init')))? true : false,
require: dialog.readAttribute('require'),
indicator: (dialog.hasClassName('modal'))?window.DialogOptions.fileIndicator:window.DialogOptions.fileIndicatorTransparent,
indicatorDimensions: window.DialogOptions.indicatorDimensions,
params: { dialogTheme: snippet },
onOk: function(event,dialog){
if (dialog.form()) {
var form = dialog.form();
if (dialog.options.submit == 'normal') {
if (dialog.initOverlay()) KB.toggle(dialog.overlay(),{ force: 'show' });
if (document.getElementsByName('dmode') && $A(document.getElementsByName('dmode')).first()) $A(document.getElementsByName('dmode')).first().value = 'normal';
if (document.getElementsByName('popup') && $A(document.getElementsByName('popup')).first()) $A(document.getElementsByName('popup')).first().value = '0';
form.submit();
} else {
var url = (Object.isString(form.action) ? form.action : '/index.php?').replace(/popup/,'');
if (dialog.initOverlay()) KB.toggle(dialog.overlay(),{ force: 'show' });
KB.request({
url: url,
redirectOnSuccess: (dialog.options.submit == 'ajax_reload'),
collectIds: dialog.element(),
params: Object.extend((dialog.form())? dialog.form().serialize(true) : {},{
dmode:'json',
subaction: 'save',
popup:1
}),
onSuccess: function(element,options){
if (this.overlay()) KB.toggle(this.overlay(),{ force: 'fade' });
this.options.onSuccess.evalScripts();
this.hide();
location.reload();
}.bind(dialog),
onFailure: function(element,options){
var type = "warning";
/* Field specific error handling */
this.element().descendants().invoke('removeClassName', 'form_warning');
this.element().descendants().invoke('removeClassName', 'form_error');
this.element().cleanWhitespace();
if (options.response.error) options.response.error.each(function(el){
var el = Object.extend({
label:'',
type:'error',
form_element:''
},el);
type = (el.type == 'error')?'error':'warning';
var errorEl = $A(document.getElementsByName(el.form_element)).first() || $A(document.getElementsByName(el.form_element+'[]')).first();
var errorLabel = this.descendants().find(function(el){
return !this.empty() && el.innerHTML && this.toLowerCase() == el.innerHTML.strip().toLowerCase();
}.bind(el.label.strip()));
if (errorLabel) errorLabel.addClassName('form_' + el.type);
if (errorEl) errorEl.addClassName('form_' + el.type);
}.bind(this.element()));
// Show e
if (this.infoContainer()) {
this.infoContainer().show();
this.infoContainer().setStyle({display:'block'});
}
if (!options.response.message.replace(/\ \;/,'').strip().empty() && this.infoElement()){
this.infoContainer().addClassName('form_' + type);
this.infoElement().update(options.response.message.replace(/\ \;/,'').nl2br() );
}
document.fire('dialog:changed');
this.options.onFailure.evalScripts();
if (this.overlay()) KB.toggle(this.overlay(),{ force: 'fade' });
}.bind(dialog)
});
}
return false;
} else {
return true;
this.hide();
}
}
}
if (!KB.DialogManager.get(id)) {
KB.DialogManager.register(id,source,options)
dialog.observe('click',function(e){
KB.DialogManager.get(this).show();
}.bindAsEventListener(id));
}
});
}
}})();
document.observe("dom:loaded",KB.DialogManager.parseLinks);
document.observe("content:loaded",KB.DialogManager.parseLinks);
/*
**
** File 'ajax_clone_form_element.js'
**
*/
var Ajax_clone_form_element = Object.extend({
containers:$H({}),
domloaded: function(e){
var options = Object.extend({
elements: [],
clear_value: true
}, KB.parseArgument(arguments[1] || {}));
var i = 1;
options.elements.flatten().findAll(function(e){ return $(e);}).each(function(el){
var c = new Element('div', { className: 'js_clone_blockwrapper' });
Element.wrap(el, c);
$(el).addClassName('js_clone_block');
Ajax_clone_form_element.containers.set(el,{
container:c,
elements: $(el).descendants().concat([el]).findAll(function(e){return (e._eventID || e._prototypeEventID) && e.id}).collect(function(e){
return {element:e,options:FormElementEvent.options.get(e.id)};
})
});
});
},
click: function(e){
var options = Object.extend({
elements: [],
clear_value: true
}, KB.parseArgument(arguments[1] || {}));
var offset = e.element().readAttribute('rel');
var insertAfter = $(options.elements.last());
options.elements.flatten().reverse(false).each(function(el){
var object = Ajax_clone_form_element.containers.get(el);
var container = object.container;
var element = $(el)?$(el):container.childElements().last();
var offset = (container.descendants().find(function(x){ return x.readAttribute('name')}).readAttribute('name').match(/(\d+)[^\d]*$/) || [0]).last() ;
if (!element || !container) return;
var temp = element.descendants().find(function(e){return (e.id && FormElementEvent.options.get(e.id) && FormElementEvent.options.get(e.id).libraryName.search(/flash/i) >= 0);});
if (temp ) return;
var cloneNode = element.clone();
var referenceNodes = element.descendants().concat([element]);
cloneNode.descendants().concat([cloneNode]).each(function(e){
var tmp = referenceNodes.find(function(t){return t.id == e.id});
if ((tmp._eventID || tmp._prototypeEventID) && tmp.id){
e = Object.extend(e,{
_eventID:'event',
options:FormElementEvent.options.get(tmp.id)
});
}
});
Element.insert(container,{bottom:cloneNode});
container.reOrder({className:'js_clone_block',attributes:['name','id'],offset:offset});
var evalIds = [];
var cloneNodeId = cloneNode.id;
evalIds = cloneNode.descendants().concat([cloneNode]).findAll(function(e){return ((e._eventID || e._prototypeEventID) && e.id)}).collect(function(e){
var options = {};
Object.extend(options,e.options || {});
return {id:e.id,options:options};
});
element.descendants().concat([element]).concat(cloneNode.descendants().concat([cloneNode])).findAll(function(e){
return e.readAttribute('kbEvent');
}).each(function(e){
e.writeAttribute({kbEvent:null});
});
if (options.clear_value) cloneNode.clearValues();
evalIds.each(function(obj){
Object.extend(obj.options,{id:cloneNodeId});
Object.extend($(obj.id),{options:obj.options});
eval('if ('+obj.options.libraryName+'.init) '+obj.options.libraryName+'.init(obj.options);');
eval(obj.options.libraryName+'.loadObservers(\''+obj.id+'\',obj.options);');
});
document.fire("content:changed");
document.fire("dialog:changed");
});
},
mouseover: function(e){
e.element().style.cursor = 'pointer';
},
mouseout: function(e){
e.element().style.cursor = 'default';
}
},FormElementEvent);
/*
**
** File 'button_form_element.js'
**
*/
var Button_form_element = Object.extend({
click: function(e){
// Extend default options
var options = Object.extend({
submit_type: '',
form_id: null,
ajax: null
}, KB.parseArgument(arguments[1] || {}));
var forms = $$('form');
// wenn form_id nicht gesetzt oder element mit form_id nicht vorhanden dann nehme erstes formular aus seite
if (!(options.form_id && $(options.form_id)) && forms.length > 0){
options.form_id = forms.first().id;
}
// Find hidden "submit_type" input
var hidden = (options.form_id && $(options.form_id))
? $(options.form_id).select('input[name="submit_type"]').first()
: $$('input[name="submit_type"]').first();
// wenn hidden nichtvorhanden -> erstelle hidden element für 'submit_type'
if (!$(hidden) && (options.form_id && $(options.form_id))) {
hidden = new Element('input',{type:'hidden', name:'submit_type'});
$(options.form_id).insert({bottom: hidden});
} else if (!$(hidden)) {
hidden = new Element('input',{type:'hidden', name:'submit_type'});
$(document.getElementsByTagName("body").item(0)).insert({bottom:hidden});
}
// Set "submit_type" if found
if (hidden) hidden.value = options.submit_type;
// unregister other submit Observers if cancel button is pressed
if (options.submit_type == 'cancel' && $(options.form_id)) {
$(options.form_id).stopObserving('submit');
}
// Ajax Request
if (options.ajax) {
KB.request(options.ajax);
if (options.ajax.clean) clearFormParams()
e.stop();
}
},
mouseover: function(e){
var element = ($(e.element().parentNode).select('img, input') || ['']).first();
var options = Object.extend({
}, KB.parseArgument(arguments[1] || {}));
if (!element || Object.isUndefined(options.image_source_highlight) || Object.isUndefined(options.image_source)) return;
if (element.readAttribute('src') && !options.image_source_highlight.empty()){
element.writeAttribute('src',options.image_source_highlight);
}
element.style.cursor = 'pointer';
},
mouseout: function(e){
var element = ($(e.element().parentNode).select('img, input') || ['']).first();
var options = Object.extend({
}, KB.parseArgument(arguments[1] || {}));
if (!element || Object.isUndefined(options.image_source_highlight) || Object.isUndefined(options.image_source)) return;
if (element.readAttribute('src') && !options.image_source.empty() && !options.image_source_highlight.empty()){
element.writeAttribute('src',options.image_source);
}
}
},FormElementEvent);
/*
**
** File 'checkbox_form_element.js'
**
*/
var Checkbox_form_element = Object.extend({
mouseover: function(e){
e.element().style.cursor = 'pointer';
},
change: function(e){
var options = Object.extend({
notify_change: false
}, KB.parseArgument(arguments[1] || {}));
if (options.notify_change) document.fire('form:changed');
}
},FormElementEvent);
/*
**
** File 'flash_file_form_element.js'
**
*/
var Flash_file_form_element = Object.extend({
// Private
form: null,
lcId: $H({}),
flashProxy: $H({}),
init: function(){
var options = Object.extend({
id: null
}, KB.parseArgument(arguments[0] || {}));
this.lcId.set(options.id,new Date().getTime() + Math.round(1000 * Math.random())) + this.lcId.size();
},
blur: function(e){
},
domloaded: function(e){
if(!$('_flash_proxy_' + this.lcId)) {
element = new Element('div',{id:'_flash_proxy_' + this.lcId});
var objBody = document.getElementsByTagName("body").item(0);
objBody.appendChild(element);
document.body.appendChild(element);
}
options = KB.parseArgument(arguments[1]);
if (options.flash_type!='swfobject') {
this.flashProxy.set(options.id,new FlashProxy(this.lcId.get(options.id), "/java/JavaScriptFlashGateway.swf"));
this.flashProxy.get(options.id).setWmode(0);
}
},
formsubmit: function(e){
var options = Object.extend({
id: null
}, KB.parseArgument(arguments[1] || {}));
this.form = e.element();
if ($(options.id)){
if (options.flash_type=='swfobject') {
var name = 'flash_upload_'+options.id+'_content';
if (navigator.appName.indexOf("Microsoft") != -1) {
var movie = window[name];
} else {
var movie = document[name]
}
if (movie) {
movie.uploadFiles();
} else {
alert('Flash not locateable');
}
} else {
this.flashProxy.get(options.id).call('uploadFiles');
this.flashProxy.get(options.id).setWmode(0);
}
KuborghEvents.pushStops();
}
},
submit:function(){
//Flash_file_single_new_form_element.uploaded = true;
var submit = KuborghEvents.popStops();
if (submit) this.form.submit();
},
change: function(e){
var options = Object.extend({
notify_change: false
}, KB.parseArgument(arguments[1] || {}));
if (options.notify_change) document.fire('form:changed');
}
},FormElementEvent);
/*
**
** File 'headline_form_element.js'
**
*/
var Headline_form_element = Object.extend({
change: function(e){
var options = Object.extend({
notify_change: false
}, KB.parseArgument(arguments[1] || {}));
if (options.notify_change) document.fire('form:changed');
}
},FormElementEvent);
/*
**
** File 'info_form_element.js'
**
*/
var Info_form_element = Object.extend({
change: function(e){
var options = Object.extend({
notify_change: false
}, KB.parseArgument(arguments[1] || {}));
if (options.notify_change) document.fire('form:changed');
}
},FormElementEvent);
/*
**
** File 'input_form_element.js'
**
*/
var Input_form_element = Object.extend((function(){
return {
elements:$H({}),
domloaded: function(e){
var options = Object.extend({
validate: '',
validate_text: 'error'
}, KB.parseArgument(arguments[1] || {}));
if ($(options.id+'_input') && $(options.id+'_input').select('input').first() && $(options.id+'_input').select('input').first().type == 'password'){
$(options.id+'_input').select('input').first().update('');
}
if ($(options.id+'_input') && $(options.id+'_input').select('input').first() && $(options.id+'_input').select('input').first().readAttribute('disabled')){
$(options.id+'_input').select('input').first().setStyle({color:'#aaa'});
}
// turn on validation errors beside the field globally
if (options.validate && typeof Ext != 'undefined'){
Ext.QuickTips.init();
$(options.id+'_input').update('');
this.elements.set(options.id,{
el: Ext.get(String(options.id+'_content')),
tf: new Ext.form.TextField({
fieldLabel:options.label,
renderTo:options.id+'_input',
name:options.name,
allowBlank:!options.mandatory,
blankText:"please enter value",
vtype:'validFunc'+options.id,
vtypeText:options.validate_text
}),
validation:function(val,field){
var reg = new RegExp(options.validate);
return (field.getValue().match(reg) == field.getValue());
}
});
// Add the additional 'advanced' VTypes
eval('Ext.apply(Ext.form.VTypes, { validFunc'+options.id+':this.elements.get(options.id).validation});');
}
},
keyup: function(e){
var options = Object.extend({
validate: ''
}, KB.parseArgument(arguments[1] || {}));
/*if (!options.validate.empty()) {
var re = new RegExp(options.validate);
if ($(options.id) && $(options.id+'_error') && re && e.element().value.match(re) && e.element().value.match(re).first() == e.element().value) $(options.id+'_error').hide();
if ($(options.id) && $(options.id+'_error') && re && !e.element().value.match(re)){
$(options.id+'_error').show();
var tmp = Ext.get(String(options.id));
tmp.highlight();
}
} */
},
change: function(e){
var options = Object.extend({
notify_change: false
}, KB.parseArgument(arguments[1] || {}));
if (options.notify_change) document.fire('form:changed');
}
}
})(),FormElementEvent);
/*
**
** File 'radio_form_element.js'
**
*/
var Radio_form_element = Object.extend({
change: function(e){
var options = Object.extend({
notify_change: false
}, KB.parseArgument(arguments[1] || {}));
if (options.notify_change) document.fire('form:changed');
}
},FormElementEvent);
/*
**
** File 'select_form_element.js'
**
*/
var Select_form_element = Object.extend({
change: function(e){
var options = Object.extend({
notify_change: false
}, KB.parseArgument(arguments[1] || {}));
if (options.notify_change) document.fire('form:changed');
}
},FormElementEvent);
/*
**
** File 'text_form_element.js'
**
*/
var Text_form_element = Object.extend({
change: function(e){
var options = Object.extend({
notify_change: false
}, KB.parseArgument(arguments[1] || {}));
if (options.notify_change) document.fire('form:changed');
}
},FormElementEvent);
/*
**
** File 'textarea_form_element.js'
**
*/
var Textarea_form_element = Object.extend((function(){
return {
domloaded: function(e){
var options = Object.extend({
addon: ''
}, KB.parseArgument(arguments[1] || {}));
if ($(options.id+'_input') && $(options.id+'_input').select('textarea').first() && $(options.id+'_input').select('textarea').first().readAttribute('disabled')){
$(options.id+'_input').select('textarea').first().setStyle({color:'#aaa'});
}
},
change: function(e){
var options = Object.extend({
notify_change: false
}, KB.parseArgument(arguments[1] || {}));
if (options.notify_change) document.fire('form:changed');
}
}})(),FormElementEvent);
/*
**
** File 'two_select_form_element.js'
**
*/
var Two_select_form_element = Object.extend((function(){
var NONE = 1;
var ALL = 2;
/**
* Sortierfunktion für Two Selects
*/
function sortId(a,b) {
if ((a.value+"") < (b.value+"")) { return -1; }
if ((a.value+"") > (b.value+"")) { return 1; }
return 0;
}
/**
* Sortierfunktion für Two Selects
*/
function sortName(a,b) {
if (String(a.text).toLowerCase() < String(b.text).toLowerCase()) { return -1; }
if (String(a.text).toLowerCase() > String(b.text).toLowerCase()) { return 1; }
return 0;
}
function move(name){
var name = (Object.isString(name))? name : '';
var insert = true;
var locked = false;
// Parse Options
var options = Object.extend({
clone: false, // Clones the element and moves the clone leaving the original in place.
sort: false, // Select Options werden sortiert
max_length: 0, // Maximale Anzahl der Elemente im Ziel Select
extended: false, // Für Proove Select (select beinhaltet die optionen ALLE bzw. KEINE
multiple: false // mehrere options gleichen Types kopieren
},KB.parseArgument(arguments[1] || {}));
options.max_length = (options.max_length)?options.max_length:-1;
var elements = {}
// Get Source && Dest Select
if (name.search(/unselected/) >= 0){
elements.selected = Element.select($(name.replace(/unselected/,'selected')),'select').first();
elements.unselected = Element.select($(name),'select').first();
elements.dest = Element.select($(name.replace(/unselected/,'selected')),'select').first();
elements.src = Element.select($(name),'select').first();
} else {
elements.selected = Element.select($(name),'select').first();
elements.unselected = Element.select($(name.replace(/selected/,'unselected')),'select').first();
elements.src = Element.select($(name),'select').first();
elements.dest = Element.select($(name.replace(/selected/,'unselected')),'select').first();
insert = false;
}
/* Alle rueber schieben bei proove_select */
if (options.extended && (elements.dest == elements.selected)){
var option = elements.unselected.select('option').findAll(function(o){ return o.selected && (o.value == ALL || o.value == NONE);}).collect(function(s){return s.value;}).inject(0,function(acc,n){return (Number(acc) >= Number(n))? Number(acc): Number(n);});
locked = (!option && !Object.isUndefined(elements.selected.select('option').find(function(o){ return o.value == ALL || o.value == NONE; })));
if (option != 0){
elements.selected.select('option').each(function(o){
var opt = o;
if (Object.isUndefined(elements.unselected.select('option').find(function(s){ return s.value == opt.value }))) elements.unselected.insert(opt.clone());
opt.remove();
});
elements.unselected.select('option').each(function(o){
o.selected = (o.value == option);
});
}
}
// Wenn kein Elemente ungültig
if (!elements.src || !elements.dest) return;
elements.src.select('option').each(function(o){
var opt = o;
oInsert = insert || Object.isUndefined(elements.unselected.select('option').find(function(s){ return s.value == opt.value }));
/* Maximale anzahl ueberschritten ? */
oLocked = locked || (elements.dest.select('option').length - options.max_length == 0);
/* Element schon vorhanden oder mehrfach erlaubt */
oLocked |= (!Object.isUndefined(elements.selected.select('option').find(function(s){ return s.value == opt.value })) && !options.multiple);
oLocked &= (elements.dest == elements.selected);
if (!opt.selected) return;
if ((!options.clone || (options.clone && oInsert)) && !oLocked) elements.dest.insert(opt.clone());
if ((!options.clone || (options.clone && !insert)) && !oLocked) opt.remove();
});
/* Nicht sortieren, wenn manuell eingeschaltet */
if (!options.sort) {
//var temp = elements.selected.select('option').sort(selectSort);
var temp = (options.extended)?elements.selected.select('option').sort(sortId):elements.selected.select('option').sort(sortName);
elements.selected.select('option').each(function(o){ o.remove(sortName); });
temp.each(function(o){ elements.selected.insert(o);});
}
/* Sortierung */
//var temp = elements.unselected.select('option').sort(selectSort);
var temp = (options.extended)?elements.unselected.select('option').sort(sortId):elements.unselected.select('option').sort(sortName);
elements.unselected.select('option').each(function(o){ o.remove(); });
temp.each(function(o){ elements.unselected.insert(o);});
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
function moveUp(obj) {
obj = $(obj);
if (!obj || !obj.previous()) return;
obj.previous().insert({before:obj});
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
function moveDown(obj) {
obj = $(obj);
if (!obj || !obj.next()) return;
obj.next().insert({after:obj});
}
return {
domloaded: function(e){
var options = Object.extend({
name_unselected: ''
}, KB.parseArgument(arguments[1] || {}));
if ($(options.name_unselected)) {
var unselected = $(options.name_unselected).select('select').first();
if (unselected){
var temp = (options.extended)?unselected.select('option').sort(sortId):unselected.select('option').sort(sortName);
unselected.select('option').each(function(o){ o.remove(); });
temp.each(function(o){ unselected.insert(o);});
}
}
},
click: function(e){
/* Sucht einen umschliessenden Link */
var element = e.findElement('a');
/* Soll eigentlich das div um den link finden. ist aber nicht zwangsläufig vorhanden (dd dl styling) */
var elementUpDown = e.findElement('div');
var name = (element)?element.getAttribute('rel'):null;
var options = Object.extend({
form_id: null,
libraryName: '',
name_selected: '',
name_unselected: ''
}, KB.parseArgument(arguments[1] || {}));
/* Klick in Liste macht nichts */
if (e.element().tagName.toUpperCase()=='OPTION') {
//noop
/* Hinzufuegen/Entfernen Link geklickt */
} else if ((element && name)) {
move(name,options);
/* Hoch Link geklickt neu */
} else if (element.hasClassName('js_moveup')) {
var selected = $(options.name_selected).select('option').findAll(function(o){ return o.selected });
selected.each(function(o){
moveUp(o);
});
/* Runter Link geklickt neu */
} else if (element.hasClassName('js_movedown')) {
var selected = $(options.name_selected).select('option').findAll(function(o){ return o.selected });
selected.each(function(o){
moveDown(o);
});
/* Hoch-Runter Link geklickt */
} else if (elementUpDown) {
var element = e.findElement('div');
var selected = $(options.name_selected).select('option').findAll(function(o){ return o.selected });
/* matcht auch gerne mal auf "group" */
if (element.id.search(/up/i) > -1) {
selected.each(function(o){
moveUp(o);
});
}
if (element.id.search(/down/i) > -1) {
selected.each(function(o){
moveDown(o);
});
}
}
},
dblclick: function(e){
var options = KB.parseArgument(arguments[1] || {});
var element = e.findElement('div');
var name = (element)?element.id:null;
// Name kann am besten ueber umschliessendes select ermittelt werden
if (e.findElement('select').hasClassName('js_unselected')) {
name = options.id+'_unselected';
} else if (e.findElement('select').hasClassName('js_selected')) {
name = options.id+'_selected';
}
/* Doppelklick auf einen Eintrag */
if (e.element().tagName.toUpperCase()=='OPTION') {
move(name,options);
}
},
formsubmit: function(e){
var options = Object.extend({
form_id: null,
libraryName: '',
name_selected: '',
name_unselected: ''
}, arguments[1] || {});
$$('.'+options.name_selected+', .'+options.name_unselected).each(function(el){
if ($(el)) {
Element.select(Element.select($(el),'select').first(),'option').each(function(o){o.selected = true});
}
});
},
change: function(e){
var options = Object.extend({
notify_change: false
}, KB.parseArgument(arguments[1] || {}));
if (options.notify_change) document.fire('form:change');
}
}})(),FormElementEvent);
/*
**
** File 'variants_select_form_element.js'
**
*/
var Variants_select_form_element = Object.extend({
change: function(e){
var options = Object.extend({
image:'',
path:'',
imgType:'jpg',
notify_change: false,
template:'memorial'
}, KB.parseArgument(arguments[1]));
var image = $(options.image);
var src = options.path + options.template + '__' + $F(e.target)+'.'+options.imgType;
if (image && image.src) image.src = src;
if (options.notify_change) document.fire('form:changed');
}
},FormElementEvent);
/*
**
** File 'wysiwyg_form_element.js'
**
*/
var Wysiwyg_form_element = Object.extend({
formsubmit: function(e) {
//Flash_file_single_new_form_element.uploaded = true;
//e.element().onsubmit();
},
change: function(e){
var options = Object.extend({
notify_change: false
}, KB.parseArgument(arguments[1] || {}));
if (options.notify_change) document.fire('form:changed');
}
},FormElementEvent);
/*
**
** File 'image_resize_form_element.js'
**
*/
var Image_resize_form_element = Object.extend({
// Private
images: $H({}),
domloaded: function(e){
options = KB.parseArgument(arguments[1] || {});
options.sourceDimensions = $('image_resize_'+options.id).getDimensions();
if (!options.sourceDimensions.width) options.sourceDimensions.width = $('image_resize_'+options.id).readAttribute('width');
if (!options.sourceDimensions.height) options.sourceDimensions.height = $('image_resize_'+options.id).readAttribute('height');
options.sourceDimensions.ratio = options.sourceDimensions.width / options.sourceDimensions.height;
options.destDimensions = ($$('.aform_input_content').first())
?{width: $$('.aform_input_content').first().getStyle('width').replace(/px/,''),height: $$('.aform_input_content').first().getStyle('height').replace(/px/,'')}
:$('image_resize_content_'+options.id).getDimensions();
if ( options.destDimensions.width > options.sourceDimensions.width ) {
options.destDimensions.width = options.sourceDimensions.width;
}
options.destDimensions.height = options.destDimensions.width / options.sourceDimensions.ratio;
// if ( options.destDimensions.height > options.sourceDimensions.height ) options.destDimensions.height = options.sourceDimensions.height ;
options.zoom = options.destDimensions.width / options.sourceDimensions.width;
var minWidth = Math.ceil(options.crop_x * options.zoom);
var minHeight = Math.ceil(options.crop_y * options.zoom);
var ratio = {
x: options.destDimensions.width / minWidth,
y: options.destDimensions.height / minHeight
}
// if ()
ratio = Math.min(ratio.x,ratio.y);
options.ratio_multiplier = (ratio >= 1)? 1 : ratio;
$('image_resize_'+options.id).writeAttribute({
width: options.destDimensions.width,
height: options.destDimensions.height
});
if ($(options.form_id)){
$(options.form_id).insert(new Element('input',{type:'hidden', id:'scale_'+options.id, name:'scale'+options.nameAddon}));
$(options.form_id).insert(new Element('input',{type:'hidden', id:'width_'+options.id, name:'width'+options.nameAddon}));
$(options.form_id).insert(new Element('input',{type:'hidden', id:'height_'+options.id, name:'height'+options.nameAddon}));
$(options.form_id).insert(new Element('input',{type:'hidden', id:'x_'+options.id, name:'x'+options.nameAddon}));
$(options.form_id).insert(new Element('input',{type:'hidden', id:'y_'+options.id, name:'y'+options.nameAddon}));
$(options.form_id).insert(new Element('input',{type:'hidden', id:'custom_width_'+options.id, name:'custom_width'+options.nameAddon}));
$(options.form_id).insert(new Element('input',{type:'hidden', id:'custom_height_'+options.id, name:'custom_height'+options.nameAddon}));
$(options.form_id).insert(new Element('input',{type:'hidden', id:'temp_file_'+options.id, name:'temp_file'+options.nameAddon, value:options.imageUrl}));
$(options.form_id).insert(new Element('input',{type:'hidden', id:'Bild des Nutzers', name:options.name+'_crop', value:options.nameAddon.replace(/_/,'')}));
}
this.images.set(options.id, new Cropper.KbImage(
'image_resize_'+options.id, {
previewWrap: 'image_resize_'+options.id+'_preview',
minWidth: minWidth * options.ratio_multiplier,
minHeight: minHeight * options.ratio_multiplier,
ratioDim: { x: options.crop_x* options.ratio_multiplier , y: options.crop_y* options.ratio_multiplier },
kbOptions:options,
displayOnInit: 1,
onEndCrop: this.writeParams
}
));
},
writeParams: function(coords, dimensions,options){
var id = this.kbOptions.id;
var srcDimensions = this.kbOptions.sourceDimensions;
var zoomFaktor = Math.round(((dimensions.width / srcDimensions.width) *10000))/100;
$( 'scale_' + id ).setValues(zoomFaktor);
$( 'custom_width_' + id ).setValues(dimensions.width);
$( 'custom_height_' + id ).setValues(dimensions.height);
$( 'x_' + id ).setValues(coords.x1);
$( 'y_' + id ).setValues(coords.y1);
$( 'width_' + id ).setValues(Math.floor((coords.x2 - coords.x1) * this.kbOptions.ratio_multiplier));
$( 'height_' + id ).setValues(Math.floor((coords.y2 - coords.y1) * this.kbOptions.ratio_multiplier));
},
change: function(e){
var options = Object.extend({
notify_change: false
}, KB.parseArgument(arguments[1] || {}));
if (options.notify_change) document.fire('form:changed');
}
},FormElementEvent);
/*
**
** File 'dhtml_list_form_element.js'
**
*/
var Dhtml_list_form_element = Object.extend((function(){
function addNode(){
return $(element);
}
return {
expression: '(-?[\\d]+)([\\[\\]]*)$',
removeRow : function(e){
var element = e.findElement('.js_list_row');
if (!element) return null;
var parent = e.findElement('.js_list_container').select('.js_list_content').first();
if (!parent) return null;
var container = e.findElement('.js_list_container');
var options = Object.extend({
addon: ''
}, KB.parseArgument(arguments[1] || {}));
// Element löschen
element.remove();
// Attribute der Zeilen neu Sortieren
parent.reOrder({className:'asset_list_row',attributes:['id','name'],expression: Dhtml_list_form_element.expression});
// Anzahl der Elemente zählen
var count = parent.select('.js_list_row').length;
// Attribute der Input Felder anpassen
if (container)
container.reOrder({className:'js_list_input',attributes:['name'],offset:count,expression: Dhtml_list_form_element.expression});
},
cancelRow : function(e,s){
var edit = (e.findElement)?e.findElement('.js_list_row'):$(e);
var show = s;
if (!edit || !show) return null;
edit.remove();
show.show();
},
submitRow : function(e,s){
var edit = (e.findElement)?e.findElement('.js_list_row'):$(e);
if (!edit) return null;
var params = $H(edit.collectValues()).values().flatten().toArray();
var texts = $H(edit.collectValues({type:'text'})).values().flatten().toArray();
var container = e.findElement('.js_list_container').select('.js_list_content').first();
var show = s;
var newElement = false;
if (!show) {
// Neues Element Erzeugen
newElement = true;
show = e.findElement('.js_list_container').select('.js_clone_show').first().clone();
if (!show) return null;
// Neues Element einfügen
container.insert({bottom: show});
// Anzahl der Elemente zählen
var count = container.select('.js_list_row').length;
// Attribute des erzeugten Elements anpassen
show.reOrder({className:'asset_list_row',attributes:['id','name'],offset:count-1,expression: Dhtml_list_form_element.expression});
// Attribute der Input Felder anpassen
if (e.findElement('.js_list_container'))
e.findElement('.js_list_container').reOrder({className:'js_list_input',attributes:['name'],offset:count,expression: Dhtml_list_form_element.expression});
// Bind Event Listener
show.select('.js_list_delete').each(function(el) {
Event.observe(el,'click',Dhtml_list_form_element.removeRow.bindAsEventListener());
});
show.select('.js_list_edit').each(function(el) {
Event.observe(el,'click',Dhtml_list_form_element.editRow.bindAsEventListener());
});
show.select('.js_list_up').each(function(el) {
Event.observe(el,'click',Dhtml_list_form_element.moveUp.bindAsEventListener());
});
show.select('.js_list_down').each(function(el) {
Event.observe(el,'click',Dhtml_list_form_element.moveDown.bindAsEventListener());
});
}
if (!show) return null;
show.setValues(params);
show.select('.js_list_show').each(function(e,index){
var value = ((!Object.isUndefined(texts[index]))?texts[index]:texts.first()).strip();
e.update((value.empty())?' ':value);
});
if (!newElement) edit.remove();
else edit.clearValues();
show.show();
},
editRow : function(e){
var element = (e.findElement)?e.findElement('.js_list_row'):$(e);
if (!element) return null;
var container = e.findElement('.js_list_container').cleanWhitespace();
if (!container) return null;
var options = Object.extend({
}, KB.parseArgument(arguments[1] || {}));
var params = $H(element.collectValues()).values().flatten().toArray()
var edit = container.select('.js_clone_edit').first();
var editListRow = edit.clone().setValues(params).show();
element.insert({before:editListRow});
editListRow.select('.js_list_cancel').first().observe('click',Dhtml_list_form_element.cancelRow.bindAsEventListener(null,element));
editListRow.select('.js_list_submit').first().observe('click',Dhtml_list_form_element.submitRow.bindAsEventListener(null,element));
element.hide();
return $(element);
},
moveDown: function(e){
var element = (e.findElement)?e.findElement('.js_list_row'):$(e);
if (!element) return null;
var next = element.next('.js_list_row');
if (!next) return element;
next.insert({after:element});
parent = e.findElement('.js_list_container').select('.js_list_content').first();
parent = parent.reOrder({className:'asset_list_row',attributes:['id','name'],expression: Dhtml_list_form_element.expression});
},
moveUp: function(e){
var element = (e.findElement)?e.findElement('.js_list_row'):$(e);
if (!element) return null;
var previous = element.previous('.js_list_row');
if (!previous) return element;
previous.insert({before:element});
parent = e.findElement('.js_list_container').select('.js_list_content').first();
parent = parent.reOrder({className:'asset_list_row',attributes:['id','name'],expression: Dhtml_list_form_element.expression});
},
change: function(e){
var options = Object.extend({
notify_change: false
}, KB.parseArgument(arguments[1] || {}));
if (options.notify_change) document.fire('form:changed');
}
}})(),FormElementEvent);
/*
**
** File 'kbLightbox.js'
**
*/
// -----------------------------------------------------------------------------------
//
// Lightbox v2.04
// by Lokesh Dhakar - http://www.lokeshdhakar.com
// Last Modification: 2/9/08
//
// For more information, visit:
// http://lokeshdhakar.com/projects/lightbox2/
//
// Licensed under the Creative Commons Attribution 2.5 License - http://creativecommons.org/licenses/by/2.5/
// - Free for use in both personal and commercial projects
// - Attribution requires leaving author name, author link, and the license info intact.
//
// Thanks: Scott Upton(uptonic.com), Peter-Paul Koch(quirksmode.com), and Thomas Fuchs(mir.aculo.us) for ideas, libs, and snippets.
// Artemy Tregubenko (arty.name) for cleanup and help in updating to latest ver of proto-aculous.
//
// -----------------------------------------------------------------------------------
/*
Table of Contents
-----------------
Configuration
Lightbox Class Declaration
- initialize()
- updateImageList()
- start()
- changeImage()
- resizeImageContainer()
- showImage()
- updateDetails()
- updateNav()
- enableKeyboardNav()
- disableKeyboardNav()
- keyboardAction()
- preloadNeighborImages()
- end()
Function Calls
- document.observe()
*/
// -----------------------------------------------------------------------------------
//
// Configurationl
//
var INIT_LIGHTBOX = false;
LightboxOptions = Object.extend(Object.extend({
emptyImage: "/img/blank.gif",
fileIndicator: "/img/lightbox/loading.gif",
fileTopNavCloseImage: "/img/lightbox/close_small_bg.png",
fileTopNavDLImage: "/img/blank.gif",
fileTopNavCloseImageSize: {width:'25px',height:'22px'},
fileTopNavDLImageSize: {width:'79px',height:'31px'},
fileBottomNavCloseImage: "/img/lightbox/close_large.png",
fileBottomNavDLImage: "/img/lightbox/downloadlabel.png",
fileBottomNavPrevImage: "/img/lightbox/inner_prev.png",
fileBottomNavNextImage: "/img/lightbox/inner_next.png",
fileBottomNavPlayImage: "/img/lightbox/inner_slideshow_play.png",
fileBottomNavPauseImage: "/img/lightbox/inner_slideshow_stop.png",
fileBottomNavCloseImageSize: {width:'77px',height:'22px'},
fileBottomNavDLImageSize: {width:'95px',height:'22px'},
fileBottomNavPrevImageSize: {width:'14px',height:'14px'},
fileBottomNavNextImageSize: {width:'14px',height:'14px'},
fileBottomNavPlayImageSize: {width:'44px',height:'14px'},
fileBottomNavPauseImageSize: {width:'44px',height:'14px'},
overlayOpacity: 0.8, // controls transparency of shadow overlay
animate: true, // toggles resizing animations
resizeSpeed: 7, // controls the speed of the image resizing animations (1=slowest and 10=fastest)
borderSize: 5, //if you adjust the padding in the CSS, you will need to update this variable
// When grouping images this is used to write: Image # of #.
// Change it for non-english localization
labelImage: "Foto",
labelOf: "von",
endlessLoop: true,
autoplaytiming: 10,
autoplay: false,
autoSize:true
},window.LightboxOptions || {}),Enumerable);
// -----------------------------------------------------------------------------------
var Lightbox = Class.create();
var kbLightbox = null;
Lightbox.prototype = {
imageArray: [],
activeImage: undefined,
pe:null, // Periodical Executer for Slideshow
autoplaytiming: 10,
autoplay: false,
// initialize()
// Constructor runs on completion of the DOM loading. Calls updateImageList and then
// the function inserts html at the bottom of the page which is used to display the shadow
// overlay and the image container.
//
initialize: function() {
var LB = this;
$H(LightboxOptions).each(function(option){
if (Object.isString(option.value) && option.value.strip().empty())
eval("LightboxOptions." + option.key + " = '" + LightboxOptions.emptyImage + "';");
});
this.updateImageList();
this.keyboardAction = this.keyboardAction.bindAsEventListener(this);
if (LightboxOptions.resizeSpeed > 10) LightboxOptions.resizeSpeed = 10;
if (LightboxOptions.resizeSpeed < 1) LightboxOptions.resizeSpeed = 1;
this.resizeDuration = LightboxOptions.animate ? ((11 - LightboxOptions.resizeSpeed) * 0.15) : 0;
this.overlayDuration = LightboxOptions.animate ? 0.2 : 0; // shadow fade in/out duration
// When Lightbox starts it will resize itself from 250 by 250 to the current image dimension.
// If animations are turned off, it will be hidden as to prevent a flicker of a
// white 250 by 250 box.
var size = (LightboxOptions.animate ? 250 : 1) + 'px';
// Code inserts html at the bottom of the page that looks similar to this:
//
//
//
//
//
//
![]()
//
//
//
//
//
//
// 
//