/*==========================================================================*\
|| ######################################################################## ||
|| # ILance 3.0.0 Release Candidate 1 - Enterprise Edition			  	  #	||
|| # -------------------------------------------------------------------- #	||
|| # Copyright ©2000–2006 ILance Inc. All Rights Reserved.	              #	||
|| # This file may not be redistributed in whole or significant part. 	  #	||
|| # ----------------- ILANCE IS NOT FREE SOFTWARE ---------------------- #	||
|| #	 http://www.ilance.ca | http://www.ilance.ca/license.html	  	  #	||
|| # -------------------------------------------------------------------- #	||
|| # Title........: Core JavaScript AJAX Functions
|| # -------------------------------------------------------------------- # ||
|| ######################################################################## ||
|| # CVS History and Technical Application Information
|| # -------------------------------------------------------------------- # ||
|| # CVS:	$RCSfile: ajax.js,v $
|| # CVS:	$Version: 3.0.0 $
|| # CVS:  $Revision: 1.6 $
|| # CVS:	   $Date: 2006/01/10 21:09:02 $
|| # CVS:    $Author: Peter Salzmann $
|| # -------------------------------------------------------------------- # ||
|| ######################################################################## ||
\*==========================================================================*/
var Prototype =
{
    Version: '1.3.1',
    emptyFunction: function() {}
}

var Class =
{
    create: function()
    {
        return function()
        {
            this.initialize.apply(this, arguments);
        }
    }
}

var Abstract = new Object();

Object.extend = function(destination, source)
{
    for (property in source)
    {
        destination[property] = source[property];
    }
    return destination;
}

Object.prototype.extend = function(object)
{
    return Object.extend.apply(this, [this, object]);
}

Function.prototype.bind = function(object)
{
    var __method = this;
    return function()
    {
        __method.apply(object, arguments);
    }
}

Function.prototype.bindAsEventListener = function(object)
{
    var __method = this;
    return function(event)
    {
        __method.call(object, event || window.event);
    }
}

Number.prototype.toColorPart = function()
{
    var digits = this.toString(16);
    if (this < 16) return '0' + digits;
    return digits;
}

var Try =
{
    these: function()
    {
        var returnValue;

        for (var i = 0; i < arguments.length; i++)
        {
            var lambda = arguments[i];
            try
            {
                returnValue = lambda();
                break;
            }
            catch (e) {}
        }
        return returnValue;
    }
}

var PeriodicalExecuter = Class.create();

PeriodicalExecuter.prototype =
{
    initialize: function(callback, frequency)
    {
        this.callback = callback;
        this.frequency = frequency;
        this.currentlyExecuting = false;
        this.registerCallback();
    },

    registerCallback: function()
    {
        setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
    },
    
    onTimerEvent: function()
    {
        if (!this.currentlyExecuting)
        {
            try
            {
                this.currentlyExecuting = true;
                this.callback();
            }
            finally
            {
                this.currentlyExecuting = false;
            }
        }
    }
}

function $()
{
    var elements = new Array();

    for (var i = 0; i < arguments.length; i++)
    {
        var element = arguments[i];
        if (typeof element == 'string')
            element = document.getElementById(element);
        if (arguments.length == 1)
            return element;
        elements.push(element);
    }
    return elements;
}

if (!Array.prototype.push)
{
    Array.prototype.push = function()
    {
        var startLength = this.length;
        for (var i = 0; i < arguments.length; i++)
        this[startLength + i] = arguments[i];
        return this.length;
    }
}

if (!Function.prototype.apply)
{
    // Based on code from http://www.youngpup.net/
    Function.prototype.apply = function(object, parameters)
    {
        var parameterStrings = new Array();
        if (!object)     object = window;
        if (!parameters) parameters = new Array();

        for (var i = 0; i < parameters.length; i++)
            parameterStrings[i] = 'parameters[' + i + ']';
    
            object.__apply__ = this;
            var result = eval('object.__apply__(' +
            parameterStrings.join(', ') + ')');
            object.__apply__ = null;
            return result;
    }
}

String.prototype.extend(
{
    stripTags: function()
    {
        return this.replace(/<\/?[^>]+>/gi, '');
    },

    escapeHTML: function()
    {
        var div = document.createElement('div');
        var text = document.createTextNode(this);
        div.appendChild(text);
        return div.innerHTML;
    },

    unescapeHTML: function()
    {
        var div = document.createElement('div');
        div.innerHTML = this.stripTags();
        return div.childNodes[0].nodeValue;
    }
});

var Ajax =
{
    getTransport: function()
    {
        return Try.these(
        function() {return new ActiveXObject('Msxml2.XMLHTTP')},
        function() {return new ActiveXObject('Microsoft.XMLHTTP')},
        function() {return new XMLHttpRequest()}
    ) || false;
    }
}

Ajax.Base = function() {};

Ajax.Base.prototype =
{
    setOptions: function(options)
    {
        this.options =
        {
            method:       'post',
            asynchronous: true,
            parameters:   ''
        }.extend(options || {});
    },

    responseIsSuccess: function()
    {
        return this.transport.status == undefined
        || this.transport.status == 0 
        || (this.transport.status >= 200 && this.transport.status < 300);
    },

    responseIsFailure: function()
    {
        return !this.responseIsSuccess();
    }
}

Ajax.Request = Class.create();

Ajax.Request.Events = 
  ['Uninitialized', 'Loading', 'Loaded', 'Interactive', 'Complete'];

Ajax.Request.prototype = (new Ajax.Base()).extend({
    initialize: function(url, options)
    {
        this.transport = Ajax.getTransport();
        this.setOptions(options);
        this.request(url);
    },

    request: function(url)
    {
        var parameters = this.options.parameters || '';
        if (parameters.length > 0) parameters += '&_=';

        try
        {
            if (this.options.method == 'get')
            url += '?' + parameters;
            this.transport.open(this.options.method, url,
            this.options.asynchronous);

            if (this.options.asynchronous)
            {
                this.transport.onreadystatechange = this.onStateChange.bind(this);
                setTimeout((function() {this.respondToReadyState(1)}).bind(this), 10);
            }
            this.setRequestHeaders();

            var body = this.options.postBody ? this.options.postBody : parameters;
            this.transport.send(this.options.method == 'post' ? body : null);
        } catch (e) {}
    },

    setRequestHeaders: function()
    {
        var requestHeaders =
        ['X-Requested-With', 'XMLHttpRequest',
         'X-Prototype-Version', Prototype.Version];

        if (this.options.method == 'post')
        {
            requestHeaders.push('Content-type',
            'application/x-www-form-urlencoded');

            /* Force "Connection: close" for Mozilla browsers to work around
            * a bug where XMLHttpReqeuest sends an incorrect Content-length
            * header. See Mozilla Bugzilla #246651.
            */
            if (this.transport.overrideMimeType)
                requestHeaders.push('Connection', 'close');
        }

        if (this.options.requestHeaders)
            requestHeaders.push.apply(requestHeaders, this.options.requestHeaders);

        for (var i = 0; i < requestHeaders.length; i += 2)
            this.transport.setRequestHeader(requestHeaders[i], requestHeaders[i+1]);
    },

    onStateChange: function()
    {
        var readyState = this.transport.readyState;
        if (readyState != 1)
            this.respondToReadyState(this.transport.readyState);
    },

    respondToReadyState: function(readyState)
    {
        var event = Ajax.Request.Events[readyState];

        if (event == 'Complete')
        (this.options['on' + this.transport.status]
           || this.options['on' + (this.responseIsSuccess() ? 'Success' : 'Failure')]
           || Prototype.emptyFunction)(this.transport);

        (this.options['on' + event] || Prototype.emptyFunction)(this.transport);

        /* Avoid memory leak in MSIE: clean up the oncomplete event handler */
        if (event == 'Complete')
            this.transport.onreadystatechange = Prototype.emptyFunction;
    }
});

Ajax.Updater = Class.create();
Ajax.Updater.ScriptFragment = '(?:<script.*?>)((\n|.)*?)(?:<\/script>)';

Ajax.Updater.prototype.extend(Ajax.Request.prototype).extend(
{
    initialize: function(container, url, options) {
    this.containers =
    {
        success: container.success ? $(container.success) : $(container),
        failure: container.failure ? $(container.failure) :
            (container.success ? null : $(container))
    }

    this.transport = Ajax.getTransport();
    this.setOptions(options);

    var onComplete = this.options.onComplete || Prototype.emptyFunction;
    this.options.onComplete = (function()
    {
        this.updateContent();
        onComplete(this.transport);
    }).bind(this);

    this.request(url);
  },

  updateContent: function()
  {
        var receiver = this.responseIsSuccess() ?
        this.containers.success : this.containers.failure;

        var match    = new RegExp(Ajax.Updater.ScriptFragment, 'img');
        var response = this.transport.responseText.replace(match, '');
        var scripts  = this.transport.responseText.match(match);

        if (receiver)
        {
            if (this.options.insertion)
            {
                new this.options.insertion(receiver, response);
            }
            else
            {
                receiver.innerHTML = response;
            }
        }

        if (this.responseIsSuccess())
        {
          if (this.onComplete)
            setTimeout((function() {this.onComplete(
              this.transport)}).bind(this), 10);
        }

        if (this.options.evalScripts && scripts)
        {
          match = new RegExp(Ajax.Updater.ScriptFragment, 'im');
          setTimeout((function()
          {
            for (var i = 0; i < scripts.length; i++)
              eval(scripts[i].match(match)[1]);
          }).bind(this), 10);
        }
    }
});

Ajax.PeriodicalUpdater = Class.create();
Ajax.PeriodicalUpdater.prototype = (new Ajax.Base()).extend(
{
    initialize: function(container, url, options) {
    this.setOptions(options);
    this.onComplete = this.options.onComplete;

    this.frequency = (this.options.frequency || 2);
    this.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.onComplete = undefined;
    clearTimeout(this.timer);
    (this.onComplete || Ajax.emptyFunction).apply(this, arguments);
  },

  updateComplete: function(request)
  {
    if (this.options.decay)
    {
      this.decay = (request.responseText == this.lastText ? 
        this.decay * this.options.decay : 1);

      this.lastText = request.responseText;
    }
    this.timer = setTimeout(this.onTimerEvent.bind(this), 
      this.decay * this.frequency * 1000);
  },

  onTimerEvent: function()
  {
    this.updater = new Ajax.Updater(this.container, this.url, this.options);
  }
});

document.getElementsByClassName = function(className)
{
    var children = document.getElementsByTagName('*') || document.all;
    var elements = new Array();
  
    for (var i = 0; i < children.length; i++)
    {
        var child = children[i];
        var classNames = child.className.split(' ');
        for (var j = 0; j < classNames.length; j++)
        {
            if (classNames[j] == className)
            {
                elements.push(child);
                break;
            }
        }
  }
  return elements;
}

if (!window.Element)
{
    var Element = new Object();
}

Object.extend(Element,
{
  toggle: function()
  {
    for (var i = 0; i < arguments.length; i++)
    {
      var element = $(arguments[i]);
      element.style.display = 
        (element.style.display == 'none' ? '' : 'none');
    }
  },

  hide: function()
  {
    for (var i = 0; i < arguments.length; i++)
    {
      var element = $(arguments[i]);
      element.style.display = 'none';
    }
  },

  show: function()
  {
    for (var i = 0; i < arguments.length; i++)
    {
      var element = $(arguments[i]);
      element.style.display = '';
    }
  },

  remove: function(element)
  {
    element = $(element);
    element.parentNode.removeChild(element);
  },
   
  getHeight: function(element)
  {
    element = $(element);
    return element.offsetHeight; 
  },

  hasClassName: function(element, className)
  {
    element = $(element);
    if (!element)
      return;
    var a = element.className.split(' ');
    for (var i = 0; i < a.length; i++)
    {
      if (a[i] == className)
        return true;
    }
    return false;
  },

  addClassName: function(element, className)
  {
    element = $(element);
    Element.removeClassName(element, className);
    element.className += ' ' + className;
  },

  removeClassName: function(element, className)
  {
    element = $(element);
    if (!element)
      return;
    var newClassName = '';
    var a = element.className.split(' ');
    for (var i = 0; i < a.length; i++)
    {
      if (a[i] != className)
      {
        if (i > 0)
          newClassName += ' ';
        newClassName += a[i];
      }
    }
    element.className = newClassName;
  },
  
  // removes whitespace-only text node children
  cleanWhitespace: function(element)
  {
    var element = $(element);
    for (var i = 0; i < element.childNodes.length; i++)
    {
      var node = element.childNodes[i];
      if (node.nodeType == 3 && !/\S/.test(node.nodeValue)) 
        Element.remove(node);
    }
  }
});

var Toggle = new Object();
Toggle.display = Element.toggle;

/*--------------------------------------------------------------------------*/

Abstract.Insertion = function(adjacency)
{
  this.adjacency = adjacency;
}

Abstract.Insertion.prototype =
{
  initialize: function(element, content)
  {
    this.element = $(element);
    this.content = content;
    
    if (this.adjacency && this.element.insertAdjacentHTML)
    {
      this.element.insertAdjacentHTML(this.adjacency, this.content);
    }
    else
    {
      this.range = this.element.ownerDocument.createRange();
      if (this.initializeRange) this.initializeRange();
      this.fragment = this.range.createContextualFragment(this.content);
      this.insertContent();
    }
  }
}

var Insertion = new Object();

Insertion.Before = Class.create();
Insertion.Before.prototype = (new Abstract.Insertion('beforeBegin')).extend({
  initializeRange: function() {
    this.range.setStartBefore(this.element);
  },
  
  insertContent: function() {
    this.element.parentNode.insertBefore(this.fragment, this.element);
  }
});

Insertion.Top = Class.create();
Insertion.Top.prototype = (new Abstract.Insertion('afterBegin')).extend({
  initializeRange: function() {
    this.range.selectNodeContents(this.element);
    this.range.collapse(true);
  },
  
  insertContent: function() {  
    this.element.insertBefore(this.fragment, this.element.firstChild);
  }
});

Insertion.Bottom = Class.create();
Insertion.Bottom.prototype = (new Abstract.Insertion('beforeEnd')).extend({
  initializeRange: function() {
    this.range.selectNodeContents(this.element);
    this.range.collapse(this.element);
  },
  
  insertContent: function() {
    this.element.appendChild(this.fragment);
  }
});

Insertion.After = Class.create();
Insertion.After.prototype = (new Abstract.Insertion('afterEnd')).extend({
  initializeRange: function() {
    this.range.setStartAfter(this.element);
  },
  
  insertContent: function() {
    this.element.parentNode.insertBefore(this.fragment, 
      this.element.nextSibling);
  }
});

var Field = {
  clear: function() {
    for (var i = 0; i < arguments.length; i++)
      $(arguments[i]).value = '';
  },

  focus: function(element) {
    $(element).focus();
  },
  
  present: function() {
    for (var i = 0; i < arguments.length; i++)
      if ($(arguments[i]).value == '') return false;
    return true;
  },
  
  select: function(element) {
    $(element).select();
  },
   
  activate: function(element) {
    $(element).focus();
    $(element).select();
  }
}

/*--------------------------------------------------------------------------*/

var Form = {
  serialize: function(form) {
    var elements = Form.getElements($(form));

    var queryComponents = new Array();
    
    for (var i = 0; i < elements.length; i++) {
      var queryComponent = Form.Element.serialize(elements[i]);
      if (queryComponent)
        queryComponents.push(queryComponent);
    }
    
    return queryComponents.join('&');
  },
  
  getElements: function(form) {
    var form = $(form);
    var elements = new Array();

    for (tagName in Form.Element.Serializers) {
      var tagElements = form.getElementsByTagName(tagName);
      for (var j = 0; j < tagElements.length; j++)
        elements.push(tagElements[j]);
    }
    return elements;
  },
  
  getInputs: function(form, typeName, name) {
    var form = $(form);
    var inputs = form.getElementsByTagName('input');
    
    if (!typeName && !name)
      return inputs;
      
    var matchingInputs = new Array();
    for (var i = 0; i < inputs.length; i++) {
      var input = inputs[i];
      if ((typeName && input.type != typeName) ||
          (name && input.name != name)) 
        continue;
      matchingInputs.push(input);
    }

    return matchingInputs;
  },

  disable: function(form) {
    var elements = Form.getElements(form);
    for (var i = 0; i < elements.length; i++) {
      var element = elements[i];
      element.blur();
      element.disabled = 'true';
    }
  },

  enable: function(form) {
    var elements = Form.getElements(form);
    for (var i = 0; i < elements.length; i++) {
      var element = elements[i];
      element.disabled = '';
    }
  },

  focusFirstElement: function(form) {
    var form = $(form);
    var elements = Form.getElements(form);
    for (var i = 0; i < elements.length; i++) {
      var element = elements[i];
      if (element.type != 'hidden' && !element.disabled) {
        Field.activate(element);
        break;
      }
    }
  },

  reset: function(form) {
    $(form).reset();
  }
}

Form.Element = {
  serialize: function(element) {
    var element = $(element);
    var method = element.tagName.toLowerCase();
    var parameter = Form.Element.Serializers[method](element);
    
    if (parameter)
      return encodeURIComponent(parameter[0]) + '=' + 
        encodeURIComponent(parameter[1]);                   
  },
  
  getValue: function(element) {
    var element = $(element);
    var method = element.tagName.toLowerCase();
    var parameter = Form.Element.Serializers[method](element);
    
    if (parameter) 
      return parameter[1];
  }
}

Form.Element.Serializers = {
  input: function(element) {
    switch (element.type.toLowerCase()) {
      case 'submit':
      case 'hidden':
      case 'password':
      case 'text':
        return Form.Element.Serializers.textarea(element);
      case 'checkbox':  
      case 'radio':
        return Form.Element.Serializers.inputSelector(element);
    }
    return false;
  },

  inputSelector: function(element) {
    if (element.checked)
      return [element.name, element.value];
  },

  textarea: function(element) {
    return [element.name, element.value];
  },

  select: function(element) {
    var value = '';
    if (element.type == 'select-one') {
      var index = element.selectedIndex;
      if (index >= 0)
        value = element.options[index].value || element.options[index].text;
    } else {
      value = new Array();
      for (var i = 0; i < element.length; i++) {
        var opt = element.options[i];
        if (opt.selected)
          value.push(opt.value || opt.text);
      }
    }
    return [element.name, value];
  }
}

/*--------------------------------------------------------------------------*/

var $F = Form.Element.getValue;

/*--------------------------------------------------------------------------*/

Abstract.TimedObserver = function() {}
Abstract.TimedObserver.prototype = {
  initialize: function(element, frequency, callback) {
    this.frequency = frequency;
    this.element   = $(element);
    this.callback  = callback;
    
    this.lastValue = this.getValue();
    this.registerCallback();
  },
  
  registerCallback: function() {
    setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
  },
  
  onTimerEvent: function() {
    var value = this.getValue();
    if (this.lastValue != value) {
      this.callback(this.element, value);
      this.lastValue = value;
    }
  }
}

Form.Element.Observer = Class.create();
Form.Element.Observer.prototype = (new Abstract.TimedObserver()).extend({
  getValue: function() {
    return Form.Element.getValue(this.element);
  }
});

Form.Observer = Class.create();
Form.Observer.prototype = (new Abstract.TimedObserver()).extend({
  getValue: function() {
    return Form.serialize(this.element);
  }
});

/*--------------------------------------------------------------------------*/

Abstract.EventObserver = function() {}
Abstract.EventObserver.prototype = {
  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() {
    var elements = Form.getElements(this.element);
    for (var i = 0; i < elements.length; i++)
      this.registerCallback(elements[i]);
  },
  
  registerCallback: function(element) {
    if (element.type) {
      switch (element.type.toLowerCase()) {
        case 'checkbox':  
        case 'radio':
          element.target = this;
          element.prev_onclick = element.onclick || Prototype.emptyFunction;
          element.onclick = function() {
            this.prev_onclick(); 
            this.target.onElementEvent();
          }
          break;
        case 'password':
        case 'text':
        case 'textarea':
        case 'select-one':
        case 'select-multiple':
          element.target = this;
          element.prev_onchange = element.onchange || Prototype.emptyFunction;
          element.onchange = function() {
            this.prev_onchange(); 
            this.target.onElementEvent();
          }
          break;
      }
    }    
  }
}

Form.Element.EventObserver = Class.create();
Form.Element.EventObserver.prototype = (new Abstract.EventObserver()).extend({
  getValue: function() {
    return Form.Element.getValue(this.element);
  }
});

Form.EventObserver = Class.create();
Form.EventObserver.prototype = (new Abstract.EventObserver()).extend({
  getValue: function() {
    return Form.serialize(this.element);
  }
});


if (!window.Event) {
  var Event = new Object();
}

Object.extend(Event, {
  KEY_BACKSPACE: 8,
  KEY_TAB:       9,
  KEY_RETURN:   13,
  KEY_ESC:      27,
  KEY_LEFT:     37,
  KEY_UP:       38,
  KEY_RIGHT:    39,
  KEY_DOWN:     40,
  KEY_DELETE:   46,

  element: function(event) {
    return event.target || event.srcElement;
  },

  isLeftClick: function(event) {
    return (((event.which) && (event.which == 1)) ||
            ((event.button) && (event.button == 1)));
  },

  pointerX: function(event) {
    return event.pageX || (event.clientX + 
      (document.documentElement.scrollLeft || document.body.scrollLeft));
  },

  pointerY: function(event) {
    return event.pageY || (event.clientY + 
      (document.documentElement.scrollTop || document.body.scrollTop));
  },

  stop: function(event) {
    if (event.preventDefault) { 
      event.preventDefault(); 
      event.stopPropagation(); 
    } else {
      event.returnValue = false;
    }
  },

  // find the first node with the given tagName, starting from the
  // node the event was triggered on; traverses the DOM upwards
  findElement: function(event, tagName) {
    var element = Event.element(event);
    while (element.parentNode && (!element.tagName ||
        (element.tagName.toUpperCase() != tagName.toUpperCase())))
      element = element.parentNode;
    return element;
  },

  observers: false,
  
  _observeAndCache: function(element, name, observer, useCapture) {
    if (!this.observers) this.observers = [];
    if (element.addEventListener) {
      this.observers.push([element, name, observer, useCapture]);
      element.addEventListener(name, observer, useCapture);
    } else if (element.attachEvent) {
      this.observers.push([element, name, observer, useCapture]);
      element.attachEvent('on' + name, observer);
    }
  },
  
  unloadCache: function() {
    if (!Event.observers) return;
    for (var i = 0; i < Event.observers.length; i++) {
      Event.stopObserving.apply(this, Event.observers[i]);
      Event.observers[i][0] = null;
    }
    Event.observers = false;
  },

  observe: function(element, name, observer, useCapture) {
    var element = $(element);
    useCapture = useCapture || false;
    
    if (name == 'keypress' &&
        ((navigator.appVersion.indexOf('AppleWebKit') > 0) 
        || element.attachEvent))
      name = 'keydown';
    
    this._observeAndCache(element, name, observer, useCapture);
  },

  stopObserving: function(element, name, observer, useCapture) {
    var element = $(element);
    useCapture = useCapture || false;
    
    if (name == 'keypress' &&
        ((navigator.appVersion.indexOf('AppleWebKit') > 0) 
        || element.detachEvent))
      name = 'keydown';
    
    if (element.removeEventListener) {
      element.removeEventListener(name, observer, useCapture);
    } else if (element.detachEvent) {
      element.detachEvent('on' + name, observer);
    }
  }
});

/* prevent memory leaks in IE */
Event.observe(window, 'unload', Event.unloadCache, false);

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;
  },

  realOffset: function(element) {
    var valueT = 0, valueL = 0;
    do {
      valueT += element.scrollTop  || 0;
      valueL += element.scrollLeft || 0; 
      element = element.parentNode;
    } while (element);
    return [valueL, valueT];
  },

  cumulativeOffset: function(element) {
    var valueT = 0, valueL = 0;
    do {
      valueT += element.offsetTop  || 0;
      valueL += element.offsetLeft || 0;
      element = element.offsetParent;
    } while (element);
    return [valueL, valueT];
  },

  // 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 = this.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 = this.realOffset(element);

    this.xcomp = x + offsetcache[0] - this.deltaX;
    this.ycomp = y + offsetcache[1] - this.deltaY;
    this.offset = this.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;
  },

  clone: function(source, target) {
    source = $(source);
    target = $(target);
    target.style.position = 'absolute';
    var offsets = this.cumulativeOffset(source);
    target.style.top    = offsets[1] + 'px';
    target.style.left   = offsets[0] + 'px';
    target.style.width  = source.offsetWidth + 'px';
    target.style.height = source.offsetHeight + 'px';
  }
}


/* AJAX Clientside functions
/*--------------------------------------------------------------------------*/
function findChild(parent, name)
{
	if (!parent.hasChildNodes())
		return null;

	for (i=0; i<parent.childNodes.length; i++)
		if (parent.childNodes.item(i).getAttribute && parent.childNodes.item(i).getAttribute("name") == name)
			return parent.childNodes.item(i);
}

function ajax_reportok(elementID, resp)
{
	// unlock this field for processing by ajax editor
	document.getElementById(elementID).setAttribute("processing", 0);
		
	if (resp.responseText != '')
	{
		// report error in AJAX PHP handler
		alert("Request error:\n" + resp.responseText);
		
		// apply "state mark" effect
		if (document.getElementById(elementID).getAttribute('ajax_effect') == '1')
		{
			document.getElementById(elementID).style.border = "2px solid red";
		}
		else if (document.getElementById(elementID).getAttribute('ajax_effect') == '-1')
		{
			document.getElementById(elementID).style.border = "0px";
		}
		else
		{
			document.getElementById(elementID).style.color = "red";
		}
	}
	else
	{
		if (document.getElementById(elementID).getAttribute('ajax_effect') == '1')
		{
			document.getElementById(elementID).style.border = "2px solid green";
		}
		else if (document.getElementById(elementID).getAttribute('ajax_effect') == '-1')
		{
			document.getElementById(elementID).style.border = "0px";
		}
		else
		{
			document.getElementById(elementID).style.color = "green";
		}
	}
}

function ajax_reporterror(elementID)
{
	// unlock this field for processing by ajax editor	
	document.getElementById(elementID).setAttribute("processing", 0);	
	alert("couldn't process ajax request, the field that wasn't updated will be marked red");
	
	if (document.getElementById(elementID).getAttribute('ajax_effect') == '1')
	{
		document.getElementById(elementID).style.border = "2px solid green";
	}
	else
	{
		document.getElementById(elementID).style.color = "green";
	}
}


function AjaxWidgetlessBase()
{
	this.databaseID = -1;
	this.ajaxHandlerURL = "ajax.php";
	this.arr_ajax_queries = new Array();

	this.init = function init(_ajaxHandlerURL, _databaseID)
	{
		this.ajaxHandlerURL = _ajaxHandlerURL;
		this.databaseID = _databaseID;
	}

	this.ajax_edit_do = function ajax_edit_do(editor)
	{
		// we must check if we have editing locked for that item
		// lock is done to prevent race condition (HTTP requests are not guaranteed to be received in same order as sent so database could get updated with old content without locking)
		editedObject = editor;
		if (editedObject.getAttribute("processing") == 1)
		{
			alert('There is an update request currently pending ..\nPlease wait');
			return;
		}

		newWidget = this.AjaxWidgetlessEdit(editedObject);
		if (newWidget)
		{
			// set "processing" attrib
			newWidget[0].setAttribute('processing', 1);

			// preserve events and ID
			newWidget[0].onclick = editedObject.onclick;
			newWidget[0].ondblclick = editedObject.ondblclick;
			newWidget[0].id = editedObject.id;

			// replace old widget
			editedObject.parentNode.replaceChild(newWidget[0], editedObject);
			if (this.afterShowEditorWidget)
				this.afterShowNewWidget(newWidget[0]);
			
			// do ajax query
			var id = editedObject.getAttribute("id");
			var url = this.ajaxHandlerURL;
			var pars = 'id=' + escape(id) + '&val=' + escape(newWidget[1]) + '&dbid=' + escape(this.databaseID);
			
			var code = "this.arr_ajax_queries[this.arr_ajax_queries.length] = new Ajax.Request(url, {method: 'get', parameters: pars, onFailure:  function() {ajax_reporterror(\""+id+"\")}, onSuccess:  function(resp) {ajax_reportok(\""+id+"\", resp)} });";
			eval(code);
		}
	}
}

function AjaxWidgetlessCheckbox(checkedImg_, uncheckedImg_, imagesPath_)
{
	subw_ = new AjaxWidgetlessBase();
	subw_.checkedImg = checkedImg_;
	subw_.uncheckedImg = uncheckedImg_;
	subw_.imagesPath = imagesPath_;

	subw_.AjaxWidgetlessEdit = function AjaxWidgetlessEdit(element)
	{
		val = 0;
		imgsrc = this.imagesPath;
		if (element.getAttribute("src").indexOf(this.uncheckedImg) > -1)
		{
			imgsrc += this.checkedImg;
			val = 1;
		}
		else
			imgsrc += this.uncheckedImg;

		_w = document.createElement('img');
		_w.src = imgsrc;
		_w.setAttribute('src', imgsrc);
		_w.setAttribute('ajax_effect', '-1');
        //_w.style.border = "2px solid blue";

		return Array(_w, val);
	}

	return subw_;
}

function AjaxBase()
{
	EditorState = new Object();
		
	this.databaseID = -1;
	this.ajaxHandlerURL = "ajax.php";

	this.editingMode = false;
	this.editedObject = -1;
	this.editorSite = -1;
	this.editorWidget = -1;

	this.init = function init(_ajaxHandlerURL, _databaseID)
	{
		this.ajaxHandlerURL = _ajaxHandlerURL;
		this.databaseID = _databaseID;
	}

	this.ajax_edit_do = function ajax_edit_do(editor)
	{
		// allow only one ajax editor run at a time...
		if (EditorState && EditorState.editingMode === true)
		{
			alert("Only one editor can be active at a time. Please save or cancel previous edit before making next");
			return;
		}

		this.editedObject = findChild(editor, 't')
		
		// we must check if we have editing locked for that item
		// lock is done to prevent race condition (HTTP requests are not guaranteed to be received in same order as sent so database could get updated with old content without locking)
		if (this.editedObject.getAttribute("processing") == 1)
		{
			alert('There is an update request currently pending ..\nPlease wait');
			return;
		}

		this.editingMode = true;
		this.editorSite = editor;
		this.editorWidget = this.createEditorWidget();
		EditorState = this;

		this.editorSite.replaceChild(this.editorWidget, this.editedObject);
		this.afterShowEditorWidget(this.editorWidget);
	}

	// in standard CALLBACK-FUNCTIONS below we get access to the EditorState object refered as "this" variable.

	this.ajax_edit_blur = function ajax_edit_blur()
	{
		// check if user made some changes (edit) to object
		changed = false;
		if (this.getEditedValue && this.getEditedValue())
		{
			changed = true;
		}

		if (this.beforeAjaxBlur)
			this.beforeAjaxBlur();

		this.editorSite.replaceChild(this.editedObject, this.editorWidget);
		
		// change back to non-editing mode check if we need to update
		this.editingMode = false;
		if (!changed)
			return;
		
		// lock this field for edit again until ajax request is processed
		this.editedObject.setAttribute("processing", 1);
		
		id = this.editedObject.getAttribute("id");
		var url = this.ajaxHandlerURL;
		
		var pars = 'id=' + escape(id) + '&val=' + escape(this.getEditedValue(true)) + '&dbid=' + escape(this.databaseID);
		var myAjax = new Ajax.Request(url, {method: 'get', parameters: pars, onFailure:  function() {ajax_reporterror(id)}, onSuccess:  function(resp) {ajax_reportok(id, resp)} });	
	}

	this.ajax_edit_keypress = function ajax_edit_keypress()
	{
		if (window.event && window.event.keyCode == 13)
		{
			this.ajax_edit_blur();
		}
	}

}

function AjaxEditbox(_minEditWidth, _maxEditWidth)
{
	sub_ = new AjaxBase();

	if (!_minEditWidth) _minEditWidth = 200;
	if (!_maxEditWidth) _maxEditWidth = 300;
	sub_.minEditWidth = _minEditWidth;
	sub_.maxEditWidth = _maxEditWidth;
	
	// here we create widget that enables user to edit in-place.
	sub_.createEditorWidget = function createEditorWidget()
	{
		_w = document.createElement('input');
		_w.setAttribute('type', 'text');
		_w.setAttribute('value', this.editedObject.innerHTML);
		_w.style.width = Math.min(this.maxEditWidth, Math.max(this.minEditWidth, this.editedObject.offsetWidth+5))+"px";

		return _w;
	}

	// here you should apply event-chandlers to widget we just have created
	sub_.afterShowEditorWidget = function afterShowEditorWidget(widgetElement)
	{
		widgetElement.focus();
		widgetElement.onblur = function() {EditorState.ajax_edit_blur();};
		widgetElement.onkeypress =  function() {EditorState.ajax_edit_keypress();};
	}

	// this function should update HTML element value, before we'll be hiding editor in ajax_edit_blur(...)
	sub_.beforeAjaxBlur = function beforeAjaxBlur()
	{
		this.editedObject.innerHTML = this.editorWidget.value;
	}

	// returns current (edited by user) value of item. Of value doesnt changed - return undefined.
	sub_.getEditedValue = function getEditedValue(returnValAlways)
	{
		if (this.editedObject.innerHTML == this.editorWidget.value && !returnValAlways)
			return;
		else
			return this.editorWidget.value;
	}

	return sub_;
}