getElementById method for W3C DOM-incapable browsers.
* For these browsers it returns always null. You do not have
* to detect the getElementById elsewhere in a script anymore.
*
* You should always check, if the returned value is not null to
* prevent script errors; getElementById returns null in
* W3C DOM-capable browsers as well, if there is no match for the given id in
* the document tree.
*
* Usage:
*
* var elem = document.getElementById(id);
* if (elem) {
* // process elem
* }
*
* @author klaus.hartl (30.03.2005)
*/
if (!document.getElementById) {
document.getElementById = function() {
return null;
};
}
/**
* Implement Array.push for browsers which don't support it natively.
*
* @author klaus.hartl (30.03.2005)
*/
if (!Array.prototype.push) {
Array.prototype.push = function() {
for(var i = 0; i < arguments.length; i++) {
this[this.length] = arguments[i];
}
return this.length;
}
}
/**
* Binds an event handler function to a given node, so that the function executes
* when an event of the particular, given type arrives at the node either as event
* target or during event propagation. Existing events, either defined as a tag
* attribute or binded dynamically, are not affected.
*
* Note: If this has to work in IE/Mac with existing events as tag attributes
* the call to bind a new event has to follow the target node in the source
* code.
*
* @param target the node to which the event will be binded
* @param eventType a string of one event type (without the "on" prefix)
* known to the browser's object model
* @param listenerFunction a reference to the function to execute, when the node
* hears the event type
* @param useCapture a Boolean value. If true, the node listens
* for the event type only while the event propagates
* toward the target node. If false, the
* node listens only when the event bubbles outward from
* the event target. The typical setting of this parameter
* is false and if omitted, it falls back to
* that value.
* @author klaus.hartl (24.03.2005)
*/
function addEventHandler(target, eventType, listenerFunction, useCapture) {
var result;
if (target.addEventListener) {
// W3C DOM approach
useCapture = (typeof useCapture == 'boolean') ? useCapture : false;
target.addEventListener(eventType, listenerFunction, useCapture);
result = true;
} else if (target.attachEvent) {
// IE/Win DOM approach
var r = target.attachEvent('on' + eventType, listenerFunction);
result = r;
} else {
// fallback approach (IE/Mac and anything else that gets this far)
var onEv = 'on' + eventType;
// if there's an existing event handler function
if(typeof target[onEv] == 'function') {
// store it
var existing = target[onEv];
// attach new onload handler
target[onEv] = function() {
// call existing function
existing();
// call given function
listenerFunction();
};
} else {
target[onEv] = listenerFunction;
}
return true; // do not use EventCash
}
EventCache.add(target, eventType, listenerFunction, useCapture);
return result;
}
/**
*
*/
function toggleValue(evt, defaultValue) {
evt = (evt) ? evt : ((event) ? event : null);
if (evt) {
var elem = (evt.target) ? evt.target : ((evt.srcElement) ? evt.srcElement : null);
if (elem) {
if (elem.value == defaultValue) {
elem.value = '';
} else if (elem.value == '') {
elem.value = defaultValue;
}
}
}
}
/**
*
*/
function attachToField(id) {
var searchInputEl = document.getElementById(id);
if (searchInputEl) {
// searchInputEl.setAttribute('autocomplete', 'off'); // prevents exception occuring with mozilla's autocomplete feature
// this exception though does not break/impact the script but maybe we want to avoid an error at the console...
var s = searchInputEl.value;
var listener = function(evt) {
toggleValue(evt, s);
}
addEventHandler(searchInputEl, 'focus', listener);
addEventHandler(searchInputEl, 'blur', listener);
}
return searchInputEl
}