Help to activate info in Iframe using MySQL data in listbox

**Antonio878** · 07-10-2010, 09:47 PM

Re: Help to activate info in Iframe using MySQL data in listbox

Originally posted by Rob (SA) View Post

Hi Folks,

I have a page that needs some help.

This page has three listboxes which populate using information form MySQL.

Each list box has a GO button which I would like to eliminate (if possible).

I would like the names that populate the listbox to be when picked display information in the Iframe on the same page.

I would also like the names to appear in Capital letters.
I would also like only the Intial of the person to appear after the surname (i.e. Doe, J)

I look forward to any replies in support of this request

I believe the best idea is to use a form which once a button is pressed it activates a javascript will automatically display the information where you would want it, and you can keep changing the combo boxes and press a button and then it will keep showing different information.

**Rob (SA)** · 07-11-2010, 07:53 AM

Re: Help to activate info in Iframe using MySQL data in listbox

Hi,

Thanks for your prompt reply.

I have attached this link in order to reflect exactly what result I would like to achieve.

I hope this helps give more perspective.

**Antonio878** · 07-11-2010, 05:37 PM

Re: Help to activate info in Iframe using MySQL data in listbox

Originally posted by Rob (SA) View Post

Hi,

Thanks for your prompt reply.

I have attached this link in order to reflect exactly what result I would like to achieve.

I hope this helps give more perspective.

I believe I do understand what you are getting at, ok well all you need to do is create a combo box for each category, and then right click them and go to properties, after that go to events and then once you go to events you will have to click when clicked on it has something like that, once then you need to type a javascript call like tablecall() then you need to type on another page the javascript coding which will collect the information from the combo box to the javascript then what you want in the iframe create the iframe on a separate php page, and just type the information you want transferred from your combo box like $ranking and every time you click on the combo box you will always have the page refreshed and showing different information.

**navaldesign** · 07-12-2010, 07:36 PM

Re: Help to activate info in Iframe using MySQL data in listbox

Got lost......

Antonio, if you can provide actual help (code) do so, if not, posting generic procedures doesn't help members that have no specific knowledge.

**Antonio878** · 07-14-2010, 01:17 AM

Re: Help to activate info in Iframe using MySQL data in listbox

ok first create each of your combo boxes on the page in a form,
then place a button at the bottom
after right click the button go to html and then type this inside the code onClick="sendRequest()".
Once then exit out of it and then open up an HTML and type this in:

PHP Code:


<head>        

        <script type="text/javascript" src="prototype.js"></script>

        <script>



            function Request() {

                new Ajax.Request("result.php?range=$range [COLOR="Red"](this is an example please edit this to your liking. This will be where your result will be, which would be a page with the Iframe.)[/COLOR]", 

                    { 

                    method: 'post', 

                    postBody: 'comment='+ $F('comment'),

                    onComplete: showResponse 

                    });

                }



            function showResponse(req){

                $('show').innerHTML= req.responseText;

            }

        </script>

    </head>

This above is a javascript which is what you are calling when you click the button.

You will need the prototype.js in the same directory so this is the code:

PHP Code:


var Prototype = {

  Version: '1.5.1.1',



  Browser: {

    IE:     !!(window.attachEvent && !window.opera),

    Opera:  !!window.opera,

    WebKit: navigator.userAgent.indexOf('*****WebKit/') > -1,

    Gecko:  navigator.userAgent.indexOf('Gecko') > -1 && navigator.userAgent.indexOf('KHTML') == -1

  },



  BrowserFeatures: {

    XPath: !!document.evaluate,

    ElementExtensions: !!window.HTMLElement,

    SpecificElementExtensions:

      (document.createElement('div').__proto__ !==

       document.createElement('form').__proto__)

  },



  ScriptFragment: '<script[^>]*>([\\S\\s]*?)<\/script>',

  JSONFilter: /^\/\*-secure-([\s\S]*)\*\/\s*$/,



  emptyFunction: function() { },

  K: function(x) { return x }

}



var Class = {

  create: function() {

    return function() {

      this.initialize.apply(this, arguments);

    }

  }

}



var Abstract = new Object();



Object.extend = function(destination, source) {

  for (var property in source) {

    destination[property] = source[property];

  }

  return destination;

}



Object.extend(Object, {

  inspect: function(object) {

    try {

      if (object === undefined) return 'undefined';

      if (object === null) return 'null';

      return object.inspect ? object.inspect() : object.toString();

    } catch (e) {

      if (e instanceof RangeError) return '...';

      throw e;

    }

  },



  toJSON: function(object) {

    var type = typeof object;

    switch(type) {

      case 'undefined':

      case 'function':

      case 'unknown': return;

      case 'boolean': return object.toString();

    }

    if (object === null) return 'null';

    if (object.toJSON) return object.toJSON();

    if (object.ownerDocument === document) return;

    var results = [];

    for (var property in object) {

      var value = Object.toJSON(object[property]);

      if (value !== undefined)

        results.push(property.toJSON() + ': ' + value);

    }

    return '{' + results.join(', ') + '}';

  },



  keys: function(object) {

    var keys = [];

    for (var property in object)

      keys.push(property);

    return keys;

  },



  values: function(object) {

    var values = [];

    for (var property in object)

      values.push(object[property]);

    return values;

  },



  clone: function(object) {

    return Object.extend({}, object);

  }

});



Function.prototype.bind = function() {

  var __method = this, args = $A(arguments), object = args.shift();

  return function() {

    return __method.apply(object, args.concat($A(arguments)));

  }

}



Function.prototype.bindAsEventListener = function(object) {

  var __method = this, args = $A(arguments), object = args.shift();

  return function(event) {

    return __method.apply(object, [event || window.event].concat(args));

  }

}



Object.extend(Number.prototype, {

  toColorPart: function() {

    return this.toPaddedString(2, 16);

  },



  succ: function() {

    return this + 1;

  },



  times: function(iterator) {

    $R(0, this, true).each(iterator);

    return this;

  },



  toPaddedString: function(length, radix) {

    var string = this.toString(radix || 10);

    return '0'.times(length - string.length) + string;

  },



  toJSON: function() {

    return isFinite(this) ? this.toString() : 'null';

  }

});



Date.prototype.toJSON = function() {

  return '"' + this.getFullYear() + '-' +

    (this.getMonth() + 1).toPaddedString(2) + '-' +

    this.getDate().toPaddedString(2) + 'T' +

    this.getHours().toPaddedString(2) + ':' +

    this.getMinutes().toPaddedString(2) + ':' +

    this.getSeconds().toPaddedString(2) + '"';

};



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;

  }

}



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



var PeriodicalExecuter = Class.create();

PeriodicalExecuter.prototype = {

  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);

  },



  stop: function() {

    if (!this.timer) return;

    clearInterval(this.timer);

    this.timer = null;

  },



  onTimerEvent: function() {

    if (!this.currentlyExecuting) {

      try {

        this.currentlyExecuting = true;

        this.callback(this);

      } finally {

        this.currentlyExecuting = false;

      }

    }

  }

}

Object.extend(String, {

  interpret: function(value) {

    return value == null ? '' : String(value);

  },

  specialChar: {

    '\b': '\\b',

    '\t': '\\t',

    '\n': '\\n',

    '\f': '\\f',

    '\r': '\\r',

    '\\': '\\\\'

  }

});



Object.extend(String.prototype, {

  gsub: function(pattern, replacement) {

    var result = '', source = this, match;

    replacement = arguments.callee.prepareReplacement(replacement);



    while (source.length > 0) {

      if (match = source.match(pattern)) {

        result += source.slice(0, match.index);

        result += String.interpret(replacement(match));

        source  = source.slice(match.index + match[0].length);

      } else {

        result += source, source = '';

      }

    }

    return result;

  },



  sub: function(pattern, replacement, count) {

    replacement = this.gsub.prepareReplacement(replacement);

    count = count === undefined ? 1 : count;



    return this.gsub(pattern, function(match) {

      if (--count < 0) return match[0];

      return replacement(match);

    });

  },



  scan: function(pattern, iterator) {

    this.gsub(pattern, iterator);

    return this;

  },



  truncate: function(length, truncation) {

    length = length || 30;

    truncation = truncation === undefined ? '...' : truncation;

    return this.length > length ?

      this.slice(0, length - truncation.length) + truncation : this;

  },



  strip: function() {

    return this.replace(/^\s+/, '').replace(/\s+$/, '');

  },



  stripTags: function() {

    return this.replace(/<\/?[^>]+>/gi, '');

  },



  stripScripts: function() {

    return this.replace(new RegExp(Prototype.ScriptFragment, 'img'), '');

  },



  extractScripts: function() {

    var matchAll = new RegExp(Prototype.ScriptFragment, 'img');

    var matchOne = new RegExp(Prototype.ScriptFragment, 'im');

    return (this.match(matchAll) || []).map(function(scriptTag) {

      return (scriptTag.match(matchOne) || ['', ''])[1];

    });

  },



  evalScripts: function() {

    return this.extractScripts().map(function(script) { return eval(script) });

  },



  escapeHTML: function() {

    var self = arguments.callee;

    self.text.data = this;

    return self.div.innerHTML;

  },



  unescapeHTML: function() {

    var div = document.createElement('div');

    div.innerHTML = this.stripTags();

    return div.childNodes[0] ? (div.childNodes.length > 1 ?

      $A(div.childNodes).inject('', function(memo, node) { return memo+node.nodeValue }) :

      div.childNodes[0].nodeValue) : '';

  },



  toQueryParams: function(separator) {

    var match = this.strip().match(/([^?#]*)(#.*)?$/);

    if (!match) return {};



    return match[1].split(separator || '&').inject({}, function(hash, pair) {

      if ((pair = pair.split('='))[0]) {

        var key = decodeURIComponent(pair.shift());

        var value = pair.length > 1 ? pair.join('=') : pair[0];

        if (value != undefined) value = decodeURIComponent(value);



        if (key in hash) {

          if (hash[key].constructor != Array) hash[key] = [hash[key]];

          hash[key].push(value);

        }

        else hash[key] = value;

      }

      return hash;

    });

  },



  toArray: function() {

    return this.split('');

  },



  succ: function() {

    return this.slice(0, this.length - 1) +

      String.fromCharCode(this.charCodeAt(this.length - 1) + 1);

  },



  times: function(count) {

    var result = '';

    for (var i = 0; i < count; i++) result += this;

    return result;

  },



  camelize: function() {

    var parts = this.split('-'), len = parts.length;

    if (len == 1) return parts[0];



    var camelized = this.charAt(0) == '-'

      ? parts[0].charAt(0).toUpperCase() + parts[0].substring(1)

      : parts[0];



    for (var i = 1; i < len; i++)

      camelized += parts[i].charAt(0).toUpperCase() + parts[i].substring(1);



    return camelized;

  },



  capitalize: function() {

    return this.charAt(0).toUpperCase() + this.substring(1).toLowerCase();

  },



  underscore: function() {

    return this.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'#{1}_#{2}').gsub(/([a-z\d])([A-Z])/,'#{1}_#{2}').gsub(/-/,'_').toLowerCase();

  },



  dasherize: function() {

    return this.gsub(/_/,'-');

  },



  inspect: function(useDoubleQuotes) {

    var escapedString = this.gsub(/[\x00-\x1f\\]/, function(match) {

      var character = String.specialChar[match[0]];

      return character ? character : '\\u00' + match[0].charCodeAt().toPaddedString(2, 16);

    });

    if (useDoubleQuotes) return '"' + escapedString.replace(/"/g, '\\"') + '"';

    return "'" + escapedString.replace(/'/g, '\\\'') + "'";

  },



  toJSON: function() {

    return this.inspect(true);

  },



  unfilterJSON: function(filter) {

    return this.sub(filter || Prototype.JSONFilter, '#{1}');

  },



  isJSON: function() {

    var str = this.replace(/\\./g, '@').replace(/"[^"\\\n\r]*"/g, '');

    return (/^[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]*$/).test(str);

  },



  evalJSON: function(sanitize) {

    var json = this.unfilterJSON();

    try {

      if (!sanitize || json.isJSON()) return eval('(' + json + ')');

    } catch (e) { }

    throw new SyntaxError('Badly formed JSON string: ' + this.inspect());

  },



  include: function(pattern) {

    return this.indexOf(pattern) > -1;

  },



  startsWith: function(pattern) {

    return this.indexOf(pattern) === 0;

  },



  endsWith: function(pattern) {

    var d = this.length - pattern.length;

    return d >= 0 && this.lastIndexOf(pattern) === d;

  },



  empty: function() {

    return this == '';

  },



  blank: function() {

    return /^\s*$/.test(this);

  }

});



if (Prototype.Browser.WebKit || Prototype.Browser.IE) Object.extend(String.prototype, {

  escapeHTML: function() {

    return this.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');

  },

  unescapeHTML: function() {

    return this.replace(/&amp;/g,'&').replace(/&lt;/g,'<').replace(/&gt;/g,'>');

  }

});



String.prototype.gsub.prepareReplacement = function(replacement) {

  if (typeof replacement == 'function') return replacement;

  var template = new Template(replacement);

  return function(match) { return template.evaluate(match) };

}



String.prototype.parseQuery = String.prototype.toQueryParams;



Object.extend(String.prototype.escapeHTML, {

  div:  document.createElement('div'),

  text: document.createTextNode('')

});



with (String.prototype.escapeHTML) div.appendChild(text);



var Template = Class.create();

Template.Pattern = /(^|.|\r|\n)(#\{(.*?)\})/;

Template.prototype = {

  initialize: function(template, pattern) {

    this.template = template.toString();

    this.pattern  = pattern || Template.Pattern;

  },



  evaluate: function(object) {

    return this.template.gsub(this.pattern, function(match) {

      var before = match[1];

      if (before == '\\') return match[2];

      return before + String.interpret(object[match[3]]);

    });

  }

}



var $break = {}, $continue = new Error('"throw $continue" is deprecated, use "return" instead');



var Enumerable = {

  each: function(iterator) {

    var index = 0;

    try {

      this._each(function(value) {

        iterator(value, index++);

      });

    } catch (e) {

      if (e != $break) throw e;

    }

    return this;

  },



  eachSlice: function(number, iterator) {

    var index = -number, slices = [], array = this.toArray();

    while ((index += number) < array.length)

      slices.push(array.slice(index, index+number));

    return slices.map(iterator);

  },



  all: function(iterator) {

    var result = true;

    this.each(function(value, index) {

      result = result && !!(iterator || Prototype.K)(value, index);

      if (!result) throw $break;

    });

    return result;

  },



  any: function(iterator) {

    var result = false;

    this.each(function(value, index) {

      if (result = !!(iterator || Prototype.K)(value, index))

        throw $break;

    });

    return result;

  },



  collect: function(iterator) {

    var results = [];

    this.each(function(value, index) {

      results.push((iterator || Prototype.K)(value, index));

    });

    return results;

  },



  detect: function(iterator) {

    var result;

    this.each(function(value, index) {

      if (iterator(value, index)) {

        result = value;

        throw $break;

      }

    });

    return result;

  },



  findAll: function(iterator) {

    var results = [];

    this.each(function(value, index) {

      if (iterator(value, index))

        results.push(value);

    });

    return results;

  },



  grep: function(pattern, iterator) {

    var results = [];

    this.each(function(value, index) {

      var stringValue = value.toString();

      if (stringValue.match(pattern))

        results.push((iterator || Prototype.K)(value, index));

    })

    return results;

  },



  include: function(object) {

    var found = false;

    this.each(function(value) {

      if (value == object) {

        found = true;

        throw $break;

      }

    });

    return found;

  },



  inGroupsOf: function(number, fillWith) {

    fillWith = fillWith === undefined ? null : fillWith;

    return this.eachSlice(number, function(slice) {

      while(slice.length < number) slice.push(fillWith);

      return slice;

    });

  },



  inject: function(memo, iterator) {

    this.each(function(value, index) {

      memo = iterator(memo, value, index);

    });

    return memo;

  },



  invoke: function(method) {

    var args = $A(arguments).slice(1);

    return this.map(function(value) {

      return value[method].apply(value, args);

    });

  },



  max: function(iterator) {

    var result;

    this.each(function(value, index) {

      value = (iterator || Prototype.K)(value, index);

      if (result == undefined || value >= result)

        result = value;

    });

    return result;

  },



  min: function(iterator) {

    var result;

    this.each(function(value, index) {

      value = (iterator || Prototype.K)(value, index);

      if (result == undefined || value < result)

        result = value;

    });

    return result;

  },



  partition: function(iterator) {

    var trues = [], falses = [];

    this.each(function(value, index) {

      ((iterator || Prototype.K)(value, index) ?

        trues : falses).push(value);

    });

    return [trues, falses];

  },



  pluck: function(property) {

    var results = [];

    this.each(function(value, index) {

      results.push(value[property]);

    });

    return results;

  },



  reject: function(iterator) {

    var results = [];

    this.each(function(value, index) {

      if (!iterator(value, index))

        results.push(value);

    });

    return results;

  },



  sortBy: function(iterator) {

    return this.map(function(value, index) {

      return {value: value, criteria: iterator(value, index)};

    }).sort(function(left, right) {

      var a = left.criteria, b = right.criteria;

      return a < b ? -1 : a > b ? 1 : 0;

    }).pluck('value');

  },



  toArray: function() {

    return this.map();

  },



  zip: function() {

    var iterator = Prototype.K, args = $A(arguments);

    if (typeof args.last() == 'function')

      iterator = args.pop();



    var collections = [this].concat(args).map($A);

    return this.map(function(value, index) {

      return iterator(collections.pluck(index));

    });

  },



  size: function() {

    return this.toArray().length;

  },



  inspect: function() {

    return '#<Enumerable:' + this.toArray().inspect() + '>';

  }

}



Object.extend(Enumerable, {

  map:     Enumerable.collect,

  find:    Enumerable.detect,

  select:  Enumerable.findAll,

  member:  Enumerable.include,

  entries: Enumerable.toArray

});

var $A = Array.from = function(iterable) {

  if (!iterable) return [];

  if (iterable.toArray) {

    return iterable.toArray();

  } else {

    var results = [];

    for (var i = 0, length = iterable.length; i < length; i++)

      results.push(iterable[i]);

    return results;

  }

}



if (Prototype.Browser.WebKit) {

  $A = Array.from = function(iterable) {

    if (!iterable) return [];

    if (!(typeof iterable == 'function' && iterable == '[object NodeList]') &&

      iterable.toArray) {

      return iterable.toArray();

    } else {

      var results = [];

      for (var i = 0, length = iterable.length; i < length; i++)

        results.push(iterable[i]);

      return results;

    }

  }

}



Object.extend(Array.prototype, Enumerable);



if (!Array.prototype._reverse)

  Array.prototype._reverse = Array.prototype.reverse;



Object.extend(Array.prototype, {

  _each: function(iterator) {

    for (var i = 0, length = this.length; i < length; i++)

      iterator(this[i]);

  },



  clear: function() {

    this.length = 0;

    return this;

  },



  first: function() {

    return this[0];

  },



  last: function() {

    return this[this.length - 1];

  },



  compact: function() {

    return this.select(function(value) {

      return value != null;

    });

  },



  flatten: function() {

    return this.inject([], function(array, value) {

      return array.concat(value && value.constructor == Array ?

        value.flatten() : [value]);

    });

  },



  without: function() {

    var values = $A(arguments);

    return this.select(function(value) {

      return !values.include(value);

    });

  },



  indexOf: function(object) {

    for (var i = 0, length = this.length; i < length; i++)

      if (this[i] == object) return i;

    return -1;

  },



  reverse: function(inline) {

    return (inline !== false ? this : this.toArray())._reverse();

  },



  reduce: function() {

    return this.length > 1 ? this : this[0];

  },



  uniq: function(sorted) {

    return this.inject([], function(array, value, index) {

      if (0 == index || (sorted ? array.last() != value : !array.include(value)))

        array.push(value);

      return array;

    });

  },



  clone: function() {

    return [].concat(this);

  },



  size: function() {

    return this.length;

  },



  inspect: function() {

    return '[' + this.map(Object.inspect).join(', ') + ']';

  },



  toJSON: function() {

    var results = [];

    this.each(function(object) {

      var value = Object.toJSON(object);

      if (value !== undefined) results.push(value);

    });

    return '[' + results.join(', ') + ']';

  }

});



Array.prototype.toArray = Array.prototype.clone;



function $w(string) {

  string = string.strip();

  return string ? string.split(/\s+/) : [];

}



if (Prototype.Browser.Opera){

  Array.prototype.concat = function() {

    var array = [];

    for (var i = 0, length = this.length; i < length; i++) array.push(this[i]);

    for (var i = 0, length = arguments.length; i < length; i++) {

      if (arguments[i].constructor == Array) {

        for (var j = 0, arrayLength = arguments[i].length; j < arrayLength; j++)

          array.push(arguments[i][j]);

      } else {

        array.push(arguments[i]);

      }

    }

    return array;

  }

}

var Hash = function(object) {

  if (object instanceof Hash) this.merge(object);

  else Object.extend(this, object || {});

};



Object.extend(Hash, {

  toQueryString: function(obj) {

    var parts = [];

    parts.add = arguments.callee.addPair;



    this.prototype._each.call(obj, function(pair) {

      if (!pair.key) return;

      var value = pair.value;



      if (value && typeof value == 'object') {

        if (value.constructor == Array) value.each(function(value) {

          parts.add(pair.key, value);

        });

        return;

      }

      parts.add(pair.key, value);

    });



    return parts.join('&');

  },



  toJSON: function(object) {

    var results = [];

    this.prototype._each.call(object, function(pair) {

      var value = Object.toJSON(pair.value);

      if (value !== undefined) results.push(pair.key.toJSON() + ': ' + value);

    });

    return '{' + results.join(', ') + '}';

  }

});



Hash.toQueryString.addPair = function(key, value, prefix) {

  key = encodeURIComponent(key);

  if (value === undefined) this.push(key);

  else this.push(key + '=' + (value == null ? '' : encodeURIComponent(value)));

}



Object.extend(Hash.prototype, Enumerable);

Object.extend(Hash.prototype, {

  _each: function(iterator) {

    for (var key in this) {

      var value = this[key];

      if (value && value == Hash.prototype[key]) continue;



      var pair = [key, value];

      pair.key = key;

      pair.value = value;

      iterator(pair);

    }

  },



  keys: function() {

    return this.pluck('key');

  },



  values: function() {

    return this.pluck('value');

  },



  merge: function(hash) {

    return $H(hash).inject(this, function(mergedHash, pair) {

      mergedHash[pair.key] = pair.value;

      return mergedHash;

    });

  },



  remove: function() {

    var result;

    for(var i = 0, length = arguments.length; i < length; i++) {

      var value = this[arguments[i]];

      if (value !== undefined){

        if (result === undefined) result = value;

        else {

          if (result.constructor != Array) result = [result];

          result.push(value)

        }

      }

      delete this[arguments[i]];

    }

    return result;

  },



  toQueryString: function() {

    return Hash.toQueryString(this);

  },



  inspect: function() {

    return '#<Hash:{' + this.map(function(pair) {

      return pair.map(Object.inspect).join(': ');

    }).join(', ') + '}>';

  },



  toJSON: function() {

    return Hash.toJSON(this);

  }

});



function $H(object) {

  if (object instanceof Hash) return object;

  return new Hash(object);

};



// Safari iterates over shadowed properties

if (function() {

  var i = 0, Test = function(value) { this.key = value };

  Test.prototype.key = 'foo';

  for (var property in new Test('bar')) i++;

  return i > 1;

}()) Hash.prototype._each = function(iterator) {

  var cache = [];

  for (var key in this) {

    var value = this[key];

    if ((value && value == Hash.prototype[key]) || cache.include(key)) continue;

    cache.push(key);

    var pair = [key, value];

    pair.key = key;

    pair.value = value;

    iterator(pair);

  }

};

ObjectRange = Class.create();

Object.extend(ObjectRange.prototype, Enumerable);

Object.extend(ObjectRange.prototype, {

  initialize: function(start, end, exclusive) {

    this.start = start;

    this.end = end;

    this.exclusive = exclusive;

  },



  _each: function(iterator) {

    var value = this.start;

    while (this.include(value)) {

      iterator(value);

      value = value.succ();

    }

  },



  include: function(value) {

    if (value < this.start)

      return false;

    if (this.exclusive)

      return value < this.end;

    return value <= this.end;

  }

});



var $R = function(start, end, exclusive) {

  return new ObjectRange(start, end, exclusive);

}



var Ajax = {

  getTransport: function() {

    return Try.these(

      function() {return new XMLHttpRequest()},

      function() {return new ActiveXObject('Msxml2.XMLHTTP')},

      function() {return new ActiveXObject('Microsoft.XMLHTTP')}

    ) || false;

  },



  activeRequestCount: 0

}



Ajax.Responders = {

  responders: [],



  _each: function(iterator) {

    this.responders._each(iterator);

  },



  register: function(responder) {

    if (!this.include(responder))

      this.responders.push(responder);

  },



  unregister: function(responder) {

    this.responders = this.responders.without(responder);

  },



  dispatch: function(callback, request, transport, json) {

    this.each(function(responder) {

      if (typeof responder[callback] == 'function') {

        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 = function() {};

Ajax.Base.prototype = {

  setOptions: function(options) {

    this.options = {

      method:       'post',

      asyn******us: true,

      contentType:  'application/x-www-form-urlencoded',

      encoding:     'UTF-8',

      parameters:   ''

    }

    Object.extend(this.options, options || {});



    this.options.method = this.options.method.toLowerCase();

    if (typeof this.options.parameters == 'string')

      this.options.parameters = this.options.parameters.toQueryParams();

  }

}



Ajax.Request = Class.create();

Ajax.Request.Events =

  ['Uninitialized', 'Loading', 'Loaded', 'Interactive', 'Complete'];



Ajax.Request.prototype = Object.extend(new Ajax.Base(), {

  _complete: false,



  initialize: function(url, options) {

    this.transport = Ajax.getTransport();

    this.setOptions(options);

    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 = Hash.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 {

      if (this.options.onCreate) this.options.onCreate(this.transport);

      Ajax.Responders.dispatch('onCreate', this, this.transport);



      this.transport.open(this.method.toUpperCase(), this.url,

        this.options.asyn******us);



      if (this.options.asyn******us)

        setTimeout(function() { this.respondToReadyState(1) }.bind(this), 10);



      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 syn******us requests */

      if (!this.options.asyn******us && 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 (typeof extras.push == 'function')

        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() {

    return !this.transport.status

        || (this.transport.status >= 200 && this.transport.status < 300);

  },



  respondToReadyState: function(readyState) {

    var state = Ajax.Request.Events[readyState];

    var transport = this.transport, json = this.evalJSON();



    if (state == 'Complete') {

      try {

        this._complete = true;

        (this.options['on' + this.transport.status]

         || this.options['on' + (this.success() ? 'Success' : 'Failure')]

         || Prototype.emptyFunction)(transport, json);

      } catch (e) {

        this.dispatchException(e);

      }



      var contentType = this.getHeader('Content-type');

      if (contentType && contentType.strip().

        match(/^(text|application)\/(x-)?(java|ecma)script(;.*)?$/i))

          this.evalResponse();

    }



    try {

      (this.options['on' + state] || Prototype.emptyFunction)(transport, json);

      Ajax.Responders.dispatch('on' + state, this, transport, json);

    } catch (e) {

      this.dispatchException(e);

    }



    if (state == 'Complete') {

      // avoid memory leak in MSIE: clean up

      this.transport.onreadystatechange = Prototype.emptyFunction;

    }

  },



  getHeader: function(name) {

    try {

      return this.transport.getResponseHeader(name);

    } catch (e) { return null }

  },



  evalJSON: function() {

    try {

      var json = this.getHeader('X-JSON');

      return json ? json.evalJSON() : 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.Updater = Class.create();



Object.extend(Object.extend(Ajax.Updater.prototype, Ajax.Request.prototype), {

  initialize: function(container, url, options) {

    this.container = {

      success: (container.success || 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(transport, param) {

      this.updateContent();

      onComplete(transport, param);

    }).bind(this);



    this.request(url);

  },



  updateContent: function() {

    var receiver = this.container[this.success() ? 'success' : 'failure'];

    var response = this.transport.responseText;



    if (!this.options.evalScripts) response = response.stripScripts();



    if (receiver = $(receiver)) {

      if (this.options.insertion)

        new this.options.insertion(receiver, response);

      else

        receiver.update(response);

    }



    if (this.success()) {

      if (this.onComplete)

        setTimeout(this.onComplete.bind(this), 10);

    }

  }

});



Ajax.PeriodicalUpdater = Class.create();

Ajax.PeriodicalUpdater.prototype = Object.extend(new Ajax.Base(), {

  initialize: function(container, url, options) {

    this.setOptions(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(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);

  }

});

function $(element) {

  if (arguments.length > 1) {

    for (var i = 0, elements = [], length = arguments.length; i < length; i++)

      elements.push($(arguments[i]));

    return elements;

  }

  if (typeof element == 'string')

    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(query.snapshotItem(i));

    return results;

  };



  document.getElementsByClassName = function(className, parentElement) {

    var q = ".//*[contains(concat(' ', @class, ' '), ' " + className + " ')]";

    return document._getElementsByXPath(q, parentElement);

  }



} else document.getElementsByClassName = function(className, parentElement) {

  var children = ($(parentElement) || document.body).getElementsByTagName('*');

  var elements = [], child, pattern = new RegExp("(^|\\s)" + className + "(\\s|$)");

  for (var i = 0, length = children.length; i < length; i++) {

    child = children[i];

    var elementClassName = child.className;

    if (elementClassName.length == 0) continue;

    if (elementClassName == className || elementClassName.match(pattern))

      elements.push(Element.extend(child));

  }

  return elements;

};



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



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



Element.extend = function(element) {

  var F = Prototype.BrowserFeatures;

  if (!element || !element.tagName || element.nodeType == 3 ||

   element._extended || F.SpecificElementExtensions || element == window)

    return element;



  var methods = {}, tagName = element.tagName, cache = Element.extend.cache,

   T = Element.Methods.ByTag;



  // extend methods for all tags (Safari doesn't need this)

  if (!F.ElementExtensions) {

    Object.extend(methods, Element.Methods),

    Object.extend(methods, Element.Methods.Simulated);

  }



  // extend methods for specific tags

  if (T[tagName]) Object.extend(methods, T[tagName]);



  for (var property in methods) {

    var value = methods[property];

    if (typeof value == 'function' && !(property in element))

      element[property] = cache.findOrStore(value);

  }



  element._extended = Prototype.emptyFunction;

  return element;

};



Element.extend.cache = {

  findOrStore: function(value) {

    return this[value] = this[value] || function() {

      return value.apply(null, [this].concat($A(arguments)));

    }

  }

};



Element.Methods = {

  visible: function(element) {

    return $(element).style.display != 'none';

  },



  toggle: function(element) {

    element = $(element);

    Element[Element.visible(element) ? 'hide' : 'show'](element);

    return element;

  },



  hide: function(element) {

    $(element).style.display = 'none';

    return element;

  },



  show: function(element) {

    $(element).style.display = '';

    return element;

  },



  remove: function(element) {

    element = $(element);

    element.parentNode.removeChild(element);

    return element;

  },



  update: function(element, html) {

    html = typeof html == 'undefined' ? '' : html.toString();

    $(element).innerHTML = html.stripScripts();

    setTimeout(function() {html.evalScripts()}, 10);

    return element;

  },



  replace: function(element, html) {

    element = $(element);

    html = typeof html == 'undefined' ? '' : html.toString();

    if (element.outerHTML) {

      element.outerHTML = html.stripScripts();

    } else {

      var range = element.ownerDocument.createRange();

      range.selectNodeContents(element);

      element.parentNode.replaceChild(

        range.createContextualFragment(html.stripScripts()), element);

    }

    setTimeout(function() {html.evalScripts()}, 10);

    return element;

  },



  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 $A($(element).getElementsByTagName('*')).each(Element.extend);

  },



  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 (typeof selector == 'string')

      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 expression ? Selector.findElement(ancestors, expression, index) :

      ancestors[index || 0];

  },



  down: function(element, expression, index) {

    element = $(element);

    if (arguments.length == 1) return element.firstDescendant();

    var descendants = element.descendants();

    return expression ? Selector.findElement(descendants, expression, index) :

      descendants[index || 0];

  },



  previous: function(element, expression, index) {

    element = $(element);

    if (arguments.length == 1) return $(Selector.handlers.previousElementSibling(element));

    var previousSiblings = element.previousSiblings();

    return expression ? Selector.findElement(previousSiblings, expression, index) :

      previousSiblings[index || 0];

  },



  next: function(element, expression, index) {

    element = $(element);

    if (arguments.length == 1) return $(Selector.handlers.******ementSibling(element));

    var nextSiblings = element.nextSiblings();

    return expression ? Selector.findElement(nextSiblings, expression, index) :

      nextSiblings[index || 0];

  },



  getElementsBySelector: function() {

    var args = $A(arguments), element = $(args.shift());

    return Selector.findChildElements(element, args);

  },



  getElementsByClassName: function(element, className) {

    return document.getElementsByClassName(className, element);

  },



  readAttribute: function(element, name) {

    element = $(element);

    if (Prototype.Browser.IE) {

      if (!element.attributes) return null;

      var t = Element._attributeTranslations;

      if (t.values[name]) return t.values[name](element, name);

      if (t.names[name])  name = t.names[name];

      var attribute = element.attributes[name];

      return attribute ? attribute.nodeValue : null;

    }

    return element.getAttribute(name);

  },



  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;

    if (elementClassName.length == 0) return false;

    if (elementClassName == className ||

        elementClassName.match(new RegExp("(^|\\s)" + className + "(\\s|$)")))

      return true;

    return false;

  },



  addClassName: function(element, className) {

    if (!(element = $(element))) return;

    Element.classNames(element).add(className);

    return element;

  },



  removeClassName: function(element, className) {

    if (!(element = $(element))) return;

    Element.classNames(element).remove(className);

    return element;

  },



  toggleClassName: function(element, className) {

    if (!(element = $(element))) return;

    Element.classNames(element)[element.hasClassName(className) ? 'remove' : 'add'](className);

    return element;

  },



  observe: function() {

    Event.observe.apply(Event, arguments);

    return $A(arguments).first();

  },



  stopObserving: function() {

    Event.stopObserving.apply(Event, arguments);

    return $A(arguments).first();

  },



  // 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);

    while (element = element.parentNode)

      if (element == ancestor) return true;

    return false;

  },



  scrollTo: function(element) {

    element = $(element);

    var pos = Position.cumulativeOffset(element);

    window.scrollTo(pos[0], pos[1]);

    return element;

  },



  getStyle: function(element, style) {

    element = $(element);

    style = style == 'float' ? 'cssFloat' : style.camelize();

    var value = element.style[style];

    if (!value) {

      var css = document.defaultView.getComputedStyle(element, null);

      value = css ? css[style] : null;

    }

    if (style == 'opacity') return value ? parseFloat(value) : 1.0;

    return value == 'auto' ? null : value;

  },



  getOpacity: function(element) {

    return $(element).getStyle('opacity');

  },



  setStyle: function(element, styles, camelized) {

    element = $(element);

    var elementStyle = element.style;



    for (var property in styles)

      if (property == 'opacity') element.setOpacity(styles[property])

      else

        elementStyle[(property == 'float' || property == 'cssFloat') ?

          (elementStyle.styleFloat === undefined ? 'cssFloat' : 'styleFloat') :

          (camelized ? property : property.camelize())] = styles[property];



    return element;

  },



  setOpacity: function(element, value) {

    element = $(element);

    element.style.opacity = (value == 1 || value === '') ? '' :

      (value < 0.00001) ? 0 : value;

    return element;

  },



  getDimensions: function(element) {

    element = $(element);

    var display = $(element).getStyle('display');

    if (display != 'none' && display != null) // Safari bug

      return {width: element.offsetWidth, height: element.offsetHeight};



    // All *Width and *Height properties give 0 on elements with display none,

    // so enable the element temporarily

    var els = element.style;

    var originalVisibility = els.visibility;

    var originalPosition = els.position;

    var originalDisplay = els.display;

    els.visibility = 'hidden';

    els.position = 'absolute';

    els.display = 'block';

    var originalWidth = element.clientWidth;

    var originalHeight = element.clientHeight;

    els.display = originalDisplay;

    els.position = originalPosition;

    els.visibility = originalVisibility;

    return {width: originalWidth, height: originalHeight};

  },



  makePositioned: function(element) {

    element = $(element);

    var pos = Element.getStyle(element, 'position');

    if (pos == 'static' || !pos) {

      element._madePositioned = true;

      element.style.position = 'relative';

      // Opera returns the offset relative to the positioning context, when an

      // element is position relative but top and left have not been defined

      if (window.opera) {

        element.style.top = 0;

        element.style.left = 0;

      }

    }

    return element;

  },



  undoPositioned: function(element) {

    element = $(element);

    if (element._madePositioned) {

      element._madePositioned = undefined;

      element.style.position =

        element.style.top =

        element.style.left =

        element.style.bottom =

        element.style.right = '';

    }

    return element;

  },



  makeClipping: function(element) {

    element = $(element);

    if (element._overflow) return element;

    element._overflow = element.style.overflow || 'auto';

    if ((Element.getStyle(element, 'overflow') || 'visible') != '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;

  }

};



Object.extend(Element.Methods, {

  childOf: Element.Methods.descendantOf,

  childElements: Element.Methods.immediateDescendants

});



if (Prototype.Browser.Opera) {

  Element.Methods._getStyle = Element.Methods.getStyle;

  Element.Methods.getStyle = function(element, style) {

    switch(style) {

      case 'left':

      case 'top':

      case 'right':

      case 'bottom':

        if (Element._getStyle(element, 'position') == 'static') return null;

      default: return Element._getStyle(element, style);

    }

  };

}

else if (Prototype.Browser.IE) {

  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) {

    element = $(element);

    var filter = element.getStyle('filter'), style = element.style;

    if (value == 1 || value === '') {

      style.filter = filter.replace(/alpha\([^\)]*\)/gi,'');

      return element;

    } else if (value < 0.00001) value = 0;

    style.filter = filter.replace(/alpha\([^\)]*\)/gi, '') +

      'alpha(opacity=' + (value * 100) + ')';

    return element;

  };



  // IE is missing .innerHTML support for TABLE-related elements

  Element.Methods.update = function(element, html) {

    element = $(element);

    html = typeof html == 'undefined' ? '' : html.toString();

    var tagName = element.tagName.toUpperCase();

    if (['THEAD','TBODY','TR','TD'].include(tagName)) {

      var div = document.createElement('div');

      switch (tagName) {

        case 'THEAD':

        case 'TBODY':

          div.innerHTML = '<table><tbody>' +  html.stripScripts() + '</tbody></table>';

          depth = 2;

          break;

        case 'TR':

          div.innerHTML = '<table><tbody><tr>' +  html.stripScripts() + '</tr></tbody></table>';

          depth = 3;

          break;

        case 'TD':

          div.innerHTML = '<table><tbody><tr><td>' +  html.stripScripts() + '</td></tr></tbody></table>';

          depth = 4;

      }

      $A(element.childNodes).each(function(node) { element.removeChild(node) });

      depth.times(function() { div = div.firstChild });

      $A(div.childNodes).each(function(node) { element.appendChild(node) });

    } else {

      element.innerHTML = html.stripScripts();

    }

    setTimeout(function() { html.evalScripts() }, 10);

    return element;

  }

}

else if (Prototype.Browser.Gecko) {

  Element.Methods.setOpacity = function(element, value) {

    element = $(element);

    element.style.opacity = (value == 1) ? 0.999999 :

      (value === '') ? '' : (value < 0.00001) ? 0 : value;

    return element;

  };

}



Element._attributeTranslations = {

  names: {

    colspan:   "colSpan",

    rowspan:   "rowSpan",

    valign:    "vAlign",

    datetime:  "dateTime",

    accesskey: "accessKey",

    tabindex:  "tabIndex",

    enctype:   "encType",

    maxlength: "maxLength",

    readonly:  "readOnly",

    longdesc:  "longDesc"

  },

  values: {

    _getAttr: function(element, attribute) {

      return element.getAttribute(attribute, 2);

    },

    _flag: function(element, attribute) {

      return $(element).hasAttribute(attribute) ? attribute : null;

    },

    style: function(element) {

      return element.style.cssText.toLowerCase();

    },

    title: function(element) {

      var node = element.getAttributeNode('title');

      return node.specified ? node.nodeValue : null;

    }

  }

};



(function() {

  Object.extend(this, {

    href: this._getAttr,

    src:  this._getAttr,

    type: this._getAttr,

    disabled: this._flag,

    checked:  this._flag,

    readonly: this._flag,

    multiple: this._flag

  });

}).call(Element._attributeTranslations.values);



Element.Methods.Simulated = {

  hasAttribute: function(element, attribute) {

    var t = Element._attributeTranslations, node;

    attribute = t.names[attribute] || attribute;

    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.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 (tagName.constructor == Array) 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;

    var cache = Element.extend.cache;

    for (var property in methods) {

      var value = methods[property];

      if (!onlyIfAbsent || !(property in destination))

        destination[property] = cache.findOrStore(value);

    }

  }



  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 (typeof klass == "undefined") continue;

      copy(T[tag], klass.prototype);

    }

  }



  Object.extend(Element, Element.Methods);

  delete Element.ByTag;

};



var Toggle = { display: Element.toggle };



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



Abstract.Insertion = function(adjacency) {

  this.adjacency = adjacency;

}



Abstract.Insertion.prototype = {

  initialize: function(element, content) {

    this.element = $(element);

    this.content = content.stripScripts();



    if (this.adjacency && this.element.insertAdjacentHTML) {

      try {

        this.element.insertAdjacentHTML(this.adjacency, this.content);

      } catch (e) {

        var tagName = this.element.tagName.toUpperCase();

        if (['TBODY', 'TR'].include(tagName)) {

          this.insertContent(this.contentFromAnonymousTable());

        } else {

          throw e;

        }

      }

    } else {

      this.range = this.element.ownerDocument.createRange();

      if (this.initializeRange) this.initializeRange();

      this.insertContent([this.range.createContextualFragment(this.content)]);

    }



    setTimeout(function() {content.evalScripts()}, 10);

  },



  contentFromAnonymousTable: function() {

    var div = document.createElement('div');

    div.innerHTML = '<table><tbody>' + this.content + '</tbody></table>';

    return $A(div.childNodes[0].childNodes[0].childNodes);

  }

}



var Insertion = new Object();



Insertion.Before = Class.create();

Insertion.Before.prototype = Object.extend(new Abstract.Insertion('beforeBegin'), {

  initializeRange: function() {

    this.range.setStartBefore(this.element);

  },



  insertContent: function(fragments) {

    fragments.each((function(fragment) {

      this.element.parentNode.insertBefore(fragment, this.element);

    }).bind(this));

  }

});



Insertion.Top = Class.create();

Insertion.Top.prototype = Object.extend(new Abstract.Insertion('afterBegin'), {

  initializeRange: function() {

    this.range.selectNodeContents(this.element);

    this.range.collapse(true);

  },



  insertContent: function(fragments) {

    fragments.reverse(false).each((function(fragment) {

      this.element.insertBefore(fragment, this.element.firstChild);

    }).bind(this));

  }

});



Insertion.Bottom = Class.create();

Insertion.Bottom.prototype = Object.extend(new Abstract.Insertion('beforeEnd'), {

  initializeRange: function() {

    this.range.selectNodeContents(this.element);

    this.range.collapse(this.element);

  },



  insertContent: function(fragments) {

    fragments.each((function(fragment) {

      this.element.appendChild(fragment);

    }).bind(this));

  }

});



Insertion.After = Class.create();

Insertion.After.prototype = Object.extend(new Abstract.Insertion('afterEnd'), {

  initializeRange: function() {

    this.range.setStartAfter(this.element);

  },



  insertContent: function(fragments) {

    fragments.each((function(fragment) {

      this.element.parentNode.insertBefore(fragment,

        this.element.nextSibling);

    }).bind(this));

  }

});



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



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);

/* 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();



Selector.prototype = {

  initialize: function(expression) {

    this.expression = expression.strip();

    this.compileMatcher();

  },



  compileMatcher: function() {

    // Selectors with namespaced attributes can't use the XPath version

    if (Prototype.BrowserFeatures.XPath && !(/\[[\w-]*?:/).test(this.expression))

      return this.compileXPathMatcher();



    var e = this.expression, ps = Selector.patterns, h = Selector.handlers,

        c = Selector.criteria, le, p, m;



    if (Selector._cache[e]) {

      this.matcher = Selector._cache[e]; return;

    }

    this.matcher = ["this.matcher = function(root) {",

                    "var r = root, h = Selector.handlers, c = false, n;"];



    while (e && le != e && (/\S/).test(e)) {

      le = e;

      for (var i in ps) {

        p = ps[i];

        if (m = e.match(p)) {

          this.matcher.push(typeof c[i] == 'function' ? c[i](m) :

              new Template(c[i]).evaluate(m));

          e = e.replace(m[0], '');

          break;

        }

      }

    }



    this.matcher.push("return h.unique(n);\n}");

    eval(this.matcher.join('\n'));

    Selector._cache[this.expression] = this.matcher;

  },



  compileXPathMatcher: function() {

    var e = this.expression, ps = Selector.patterns,

        x = Selector.xpath, le,  m;



    if (Selector._cache[e]) {

      this.xpath = Selector._cache[e]; return;

    }



    this.matcher = ['.//*'];

    while (e && le != e && (/\S/).test(e)) {

      le = e;

      for (var i in ps) {

        if (m = e.match(ps[i])) {

          this.matcher.push(typeof x[i] == 'function' ? x[i](m) :

            new Template(x[i]).evaluate(m));

          e = e.replace(m[0], '');

          break;

        }

      }

    }



    this.xpath = this.matcher.join('');

    Selector._cache[this.expression] = this.xpath;

  },



  findElements: function(root) {

    root = root || document;

    if (this.xpath) return document._getElementsByXPath(this.xpath, root);

    return this.matcher(root);

  },



  match: function(element) {

    return this.findElements(document).include(element);

  },



  toString: function() {

    return this.expression;

  },



  inspect: function() {

    return "#<Selector:" + this.expression.inspect() + ">";

  }

};



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: "[@#{1}]",

    attr: function(m) {

      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 (typeof h === 'function') return h(m);

      return new Template(Selector.xpath.pseudos[m[1]]).evaluate(m);

    },

    operators: {

      '=':  "[@#{1}='#{3}']",

      '!=': "[@#{1}!='#{3}']",

      '^=': "[starts-with(@#{1}, '#{3}')]",

      '$=': "[substring(@#{1}, (string-length(@#{1}) - string-length('#{3}') + 1))='#{3}']",

      '*=': "[contains(@#{1}, '#{3}')]",

      '~=': "[contains(concat(' ', @#{1}, ' '), ' #{3} ')]",

      '|=': "[contains(concat('-', @#{1}, '-'), '-#{3}-')]"

    },

    pseudos: {

      'first-child': '[not(preceding-sibling::*)]',

      'last-child':  '[not(following-sibling::*)]',

      'only-child':  '[not(preceding-sibling::* or following-sibling::*)]',

      'empty':       "[count(*) = 0 and (count(text()) = 0 or translate(text(), ' \t\r\n', '') = '')]",

      'checked':     "[@checked]",

      'disabled':    "[@disabled]",

      'enabled':     "[not(@disabled)]",

      'not': function(m) {

        var e = m[6], p = Selector.patterns,

            x = Selector.xpath, le, m, v;



        var exclusion = [];

        while (e && le != e && (/\S/).test(e)) {

          le = e;

          for (var i in p) {

            if (m = e.match(p[i])) {

              v = typeof x[i] == 'function' ? x[i](m) : new Template(x[i]).evaluate(m);

              exclusion.push("(" + v.substring(1, v.length - 1) + ")");

              e = e.replace(m[0], '');

              break;

            }

          }

        }

        return "[not(" + exclusion.join(" and ") + ")]";

      },

      'nth-child':      function(m) {

        return Selector.xpath.pseudos.nth("(count(./preceding-sibling::*) + 1) ", m);

      },

      'nth-last-child': function(m) {

        return Selector.xpath.pseudos.nth("(count(./following-sibling::*) + 1) ", m);

      },

      'nth-of-type':    function(m) {

        return Selector.xpath.pseudos.nth("position() ", m);

      },

      'nth-last-of-type': function(m) {

        return Selector.xpath.pseudos.nth("(last() + 1 - position()) ", m);

      },

      'first-of-type':  function(m) {

        m[6] = "1"; return Selector.xpath.pseudos['nth-of-type'](m);

      },

      'last-of-type':   function(m) {

        m[6] = "1"; return Selector.xpath.pseudos['nth-last-of-type'](m);

      },

      'only-of-type':   function(m) {

        var p = Selector.xpath.pseudos; return p['first-of-type'](m) + p['last-of-type'](m);

      },

      nth: function(fragment, m) {

        var mm, formula = m[6], predicate;

        if (formula == 'even') formula = '2n+0';

        if (formula == 'odd')  formula = '2n+1';

        if (mm = formula.match(/^(\d+)$/)) // digit only

          return '[' + fragment + "= " + mm[1] + ']';

        if (mm = formula.match(/^(-?\d*)?n(([+-])(\d+))?/)) { // an+b

          if (mm[1] == "-") mm[1] = -1;

          var a = mm[1] ? Number(mm[1]) : 1;

          var b = mm[2] ? Number(mm[2]) : 0;

          predicate = "[((#{fragment} - #{b}) mod #{a} = 0) and " +

          "((#{fragment} - #{b}) div #{a} >= 0)]";

          return new Template(predicate).evaluate({

            fragment: fragment, a: a, b: b });

        }

      }

    }

  },



  criteria: {

    tagName:      'n = h.tagName(n, r, "#{1}", c);   c = false;',

    className:    'n = h.className(n, r, "#{1}", c); c = false;',

    id:           'n = h.id(n, r, "#{1}", c);        c = false;',

    attrPresence: 'n = h.attrPresence(n, r, "#{1}"); c = false;',

    attr: function(m) {

      m[3] = (m[5] || m[6]);

      return new Template('n = h.attr(n, r, "#{1}", "#{3}", "#{2}"); c = false;').evaluate(m);

    },

    pseudo:       function(m) {

      if (m[6]) m[6] = m[6].replace(/"/g, '\\"');

      return new Template('n = h.pseudo(n, "#{1}", "#{6}", r, c); c = false;').evaluate(m);

    },

    descendant:   'c = "descendant";',

    child:        'c = "child";',

    adjacent:     'c = "adjacent";',

    laterSibling: 'c = "laterSibling";'

  },



  patterns: {

    // combinators must be listed first

    // (and descendant needs to be last combinator)

    laterSibling: /^\s*~\s*/,

    child:        /^\s*>\s*/,

    adjacent:     /^\s*\+\s*/,

    descendant:   /^\s/,



    // selectors follow

    tagName:      /^\s*(\*|[\w\-]+)(\b|$)?/,

    id:           /^#([\w\-\*]+)(\b|$)/,

    className:    /^\.([\w\-\*]+)(\b|$)/,

    pseudo:       /^:((first|last|nth|nth-last|only)(-child|-of-type)|empty|checked|(en|dis)abled|not)(\((.*?)\))?(\b|$|\s|(?=:))/,

    attrPresence: /^\[([\w]+)\]/,

    attr:         /\[((?:[\w-]*:)?[\w-]+)\s*(?:([!^$*~|]?=)\s*((['"])([^\]]*?)\4|([^'"][^\]]*?)))?\]/

  },



  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) {

      for (var i = 0, node; node = nodes[i]; i++)

        node._counted = true;

      return nodes;

    },



    unmark: function(nodes) {

      for (var i = 0, node; node = nodes[i]; i++)

        node._counted = 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._counted = true;

      if (reverse) {

        for (var nodes = parentNode.childNodes, i = nodes.length - 1, j = 1; i >= 0; i--) {

          node = nodes[i];

          if (node.nodeType == 1 && (!ofType || node._counted)) node.nodeIndex = j++;

        }

      } else {

        for (var i = 0, j = 1, nodes = parentNode.childNodes; node = nodes[i]; i++)

          if (node.nodeType == 1 && (!ofType || node._counted)) 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])._counted) {

          n._counted = true;

          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, children = [], 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.******ementSibling(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;

    },



    ******ementSibling: 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) {

      tagName = 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() == tagName) results.push(node);

        return results;

      } else return root.getElementsByTagName(tagName);

    },



    id: function(nodes, root, id, combinator) {

      var targetNode = $(id), h = Selector.handlers;

      if (!nodes && root == document) return targetNode ? [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) {

      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) {

      if (!nodes) nodes = root.getElementsByTagName("*");

      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.******ementSibling(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.******ementSibling(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._counted) {

          h.index(node.parentNode, reverse, ofType);

          indexed.push(node.parentNode);

        }

      }

      if (formula.match(/^\d+$/)) { // just a number

        formula = Number(formula);

        for (var i = 0, node; node = nodes[i]; i++)

          if (node.nodeIndex == formula) results.push(node);

      } else if (m = formula.match(/^(-?\d*)?n(([+-])(\d+))?/)) { // an+b

        if (m[1] == "-") m[1] = -1;

        var a = m[1] ? Number(m[1]) : 1;

        var b = m[2] ? Number(m[2]) : 0;

        var indices = Selector.pseudos.getIndices(a, b, nodes.length);

        for (var i = 0, node, l = indices.length; node = nodes[i]; i++) {

          for (var j = 0; j < l; j++)

            if (node.nodeIndex == indices[j]) results.push(node);

        }

      }

      h.unmark(nodes);

      h.unmark(indexed);

      return results;

    },



    'empty': function(nodes, value, root) {

      for (var i = 0, results = [], node; node = nodes[i]; i++) {

        // IE treats comments as element nodes

        if (node.tagName == '!' || (node.firstChild && !node.innerHTML.match(/^\s*$/))) continue;

        results.push(node);

      }

      return results;

    },



    'not': function(nodes, selector, root) {

      var h = Selector.handlers, selectorType, m;

      var exclusions = new Selector(selector).findElements(root);

      h.mark(exclusions);

      for (var i = 0, results = [], node; node = nodes[i]; i++)

        if (!node._counted) results.push(node);

      h.unmark(exclusions);

      return results;

    },



    'enabled': function(nodes, value, root) {

      for (var i = 0, results = [], node; node = nodes[i]; i++)

        if (!node.disabled) results.push(node);

      return results;

    },



    'disabled': function(nodes, value, root) {

      for (var i = 0, results = [], node; node = nodes[i]; i++)

        if (node.disabled) results.push(node);

      return results;

    },



    'checked': function(nodes, value, root) {

      for (var i = 0, results = [], node; node = nodes[i]; i++)

        if (node.checked) results.push(node);

      return results;

    }

  },



  operators: {

    '=':  function(nv, v) { return nv == v; },

    '!=': function(nv, v) { return nv != v; },

    '^=': function(nv, v) { return nv.startsWith(v); },

    '$=': function(nv, v) { return nv.endsWith(v); },

    '*=': function(nv, v) { return nv.include(v); },

    '~=': function(nv, v) { return (' ' + nv + ' ').include(' ' + v + ' '); },

    '|=': function(nv, v) { return ('-' + nv.toUpperCase() + '-').include('-' + v.toUpperCase() + '-'); }

  },



  matchElements: function(elements, expression) {

    var matches = new Selector(expression).findElements(), h = Selector.handlers;

    h.mark(matches);

    for (var i = 0, results = [], element; element = elements[i]; i++)

      if (element._counted) results.push(element);

    h.unmark(matches);

    return results;

  },



  findElement: function(elements, expression, index) {

    if (typeof expression == 'number') {

      index = expression; expression = false;

    }

    return Selector.matchElements(elements, expression || '*')[index || 0];

  },



  findChildElements: function(element, expressions) {

    var exprs = expressions.join(','), expressions = [];

    exprs.scan(/(([\w#:.~>+()\s-]+|\*|\[.*?\])+)\s*(,|$)/, function(m) {

      expressions.push(m[1].strip());

    });

    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;

  }

});



function $$() {

  return Selector.findChildElements(document, $A(arguments));

}

var Form = {

  reset: function(form) {

    $(form).reset();

    return form;

  },



  serializeElements: function(elements, getHash) {

    var data = elements.inject({}, function(result, element) {

      if (!element.disabled && element.name) {

        var key = element.name, value = $(element).getValue();

        if (value != null) {

             if (key in result) {

            if (result[key].constructor != Array) result[key] = [result[key]];

            result[key].push(value);

          }

          else result[key] = value;

        }

      }

      return result;

    });



    return getHash ? data : Hash.toQueryString(data);

  }

};



Form.Methods = {

  serialize: function(form, getHash) {

    return Form.serializeElements(Form.getElements(form), getHash);

  },



  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) {

    return $(form).getElements().find(function(element) {

      return element.type != 'hidden' && !element.disabled &&

        ['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;

    options.parameters = form.serialize(true);



    if (params) {

      if (typeof params == 'string') params = params.toQueryParams();

      Object.extend(options.parameters, params);

    }



    if (form.hasAttribute('method') && !options.method)

      options.method = form.method;



    return new Ajax.Request(form.readAttribute('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 Hash.toQueryString(pair);

      }

    }

    return '';

  },



  getValue: function(element) {

    element = $(element);

    var method = element.tagName.toLowerCase();

    return Form.Element.Serializers[method](element);

  },



  clear: function(element) {

    $(element).value = '';

    return element;

  },



  present: function(element) {

    return $(element).value != '';

  },



  activate: function(element) {

    element = $(element);

    try {

      element.focus();

      if (element.select && (element.tagName.toLowerCase() != 'input' ||

        !['button', 'reset', 'submit'].include(element.type)))

        element.select();

    } catch (e) {}

    return element;

  },



  disable: function(element) {

    element = $(element);

    element.blur();

    element.disabled = true;

    return element;

  },



  enable: function(element) {

    element = $(element);

    element.disabled = false;

    return element;

  }

}



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



var Field = Form.Element;

var $F = Form.Element.Methods.getValue;



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



Form.Element.Serializers = {

  input: function(element) {

    switch (element.type.toLowerCase()) {

      case 'checkbox':

      case 'radio':

        return Form.Element.Serializers.inputSelector(element);

      default:

        return Form.Element.Serializers.textarea(element);

    }

  },



  inputSelector: function(element) {

    return element.checked ? element.value : null;

  },



  textarea: function(element) {

    return element.value;

  },



  select: function(element) {

    return this[element.type == 'select-one' ?

      'selectOne' : 'selectMany'](element);

  },



  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 = 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();

    var changed = ('string' == typeof this.lastValue && 'string' == typeof value

      ? this.lastValue != value : String(this.lastValue) != String(value));

    if (changed) {

      this.callback(this.element, value);

      this.lastValue = value;

    }

  }

}



Form.Element.Observer = Class.create();

Form.Element.Observer.prototype = Object.extend(new Abstract.TimedObserver(), {

  getValue: function() {

    return Form.Element.getValue(this.element);

  }

});



Form.Observer = Class.create();

Form.Observer.prototype = Object.extend(new Abstract.TimedObserver(), {

  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() {

    Form.getElements(this.element).each(this.registerCallback.bind(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();

Form.Element.EventObserver.prototype = Object.extend(new Abstract.EventObserver(), {

  getValue: function() {

    return Form.Element.getValue(this.element);

  }

});



Form.EventObserver = Class.create();

Form.EventObserver.prototype = Object.extend(new Abstract.EventObserver(), {

  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,

  KEY_HOME:     36,

  KEY_END:      35,

  KEY_PAGEUP:   33,

  KEY_PAGEDOWN: 34,



  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;

      event.cancelBubble = true;

    }

  },



  // 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, length = Event.observers.length; i < length; i++) {

      Event.stopObserving.apply(this, Event.observers[i]);

      Event.observers[i][0] = null;

    }

    Event.observers = false;

  },



  observe: function(element, name, observer, useCapture) {

    element = $(element);

    useCapture = useCapture || false;



    if (name == 'keypress' &&

      (Prototype.Browser.WebKit || element.attachEvent))

      name = 'keydown';



    Event._observeAndCache(element, name, observer, useCapture);

  },



  stopObserving: function(element, name, observer, useCapture) {

    element = $(element);

    useCapture = useCapture || false;



    if (name == 'keypress' &&

        (Prototype.Browser.WebKit || element.attachEvent))

      name = 'keydown';



    if (element.removeEventListener) {

      element.removeEventListener(name, observer, useCapture);

    } else if (element.detachEvent) {

      try {

        element.detachEvent('on' + name, observer);

      } catch (e) {}

    }

  }

});



/* prevent memory leaks in IE */

if (Prototype.Browser.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];

  },



  positionedOffset: function(element) {

    var valueT = 0, valueL = 0;

    do {

      valueT += element.offsetTop  || 0;

      valueL += element.offsetLeft || 0;

      element = element.offsetParent;

      if (element) {

        if(element.tagName=='BODY') break;

        var p = Element.getStyle(element, 'position');

        if (p == 'relative' || p == 'absolute') break;

      }

    } while (element);

    return [valueL, valueT];

  },



  offsetParent: function(element) {

    if (element.offsetParent) return element.offsetParent;

    if (element == document.body) return element;



    while ((element = element.parentNode) && element != document.body)

      if (Element.getStyle(element, 'position') != 'static')

        return element;



    return document.body;

  },



  // 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;

  },



  page: 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)

        if (Element.getStyle(element,'position')=='absolute') break;



    } while (element = element.offsetParent);



    element = forElement;

    do {

      if (!window.opera || element.tagName=='BODY') {

        valueT -= element.scrollTop  || 0;

        valueL -= element.scrollLeft || 0;

      }

    } while (element = element.parentNode);



    return [valueL, valueT];

  },



  clone: function(source, target) {

    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 = Position.page(source);



    // find coordinate system to use

    target = $(target);

    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(target,'position') == 'absolute') {

      parent = Position.offsetParent(target);

      delta = Position.page(parent);

    }



    // 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)   target.style.left  = (p[0] - delta[0] + options.offsetLeft) + 'px';

    if(options.setTop)    target.style.top   = (p[1] - delta[1] + options.offsetTop) + 'px';

    if(options.setWidth)  target.style.width = source.offsetWidth + 'px';

    if(options.setHeight) target.style.height = source.offsetHeight + 'px';

  },



  absolutize: function(element) {

    element = $(element);

    if (element.style.position == 'absolute') return;

    Position.prepare();



    var offsets = Position.positionedOffset(element);

    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';

  },



  relativize: function(element) {

    element = $(element);

    if (element.style.position == 'relative') return;

    Position.prepare();



    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;

  }

}



// Safari returns margins on body which is incorrect if the child is absolutely

// positioned.  For performance reasons, redefine Position.cumulativeOffset for

// KHTML/WebKit only.

if (Prototype.Browser.WebKit) {

  Position.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 [valueL, valueT];

  }

}



Element.addMethods();

This is important do not edit this it is already editing to what it is suppose to do. Once you have all this you need to tell where will the Iframe with the results will show up, in which you will need to add this:

PHP Code:


<div id="show"></div>

now after that you will have to create a new page with the iframe, lets call it result like in the example above. It will look like this, this is the example you need to edit this remember, just edit the values.

PHP Code:


<iframe name="Result Page" id="InlineFrame2" style="position:absolute;width:148px;height:148px;" src="http://www.yoursite.com/finalresult.php?range=$range" frameborder="1">Your browser does not support inline frames or is currently configured not to display inline frames.</iframe>

Now the iframe should be on a blank page but just have this what I wrote just change the size, they already have the iframe set up in bluevoda so you can see what it will look like, just remember the page would be called result.php since the example in the javascript is called result.php these pages all have to have the extension .php or it won't work. Once you created the new page with the iframe called result.php then you make sure the iframe is calling the page where the results are suppose to show up.

And that is it hopefully you understand what I have done and hopefully you will find it easier now. Sorry about the message before, I have to understand not everyone can know what I am talking about, please accept my apology. Well, Good Luck!

**Antonio878** · 07-14-2010, 01:25 AM

Re: Help to activate info in Iframe using MySQL data in listbox

Originally posted by navaldesign View Post

Got lost......

Antonio, if you can provide actual help (code) do so, if not, posting generic procedures doesn't help members that have no specific knowledge.

Sorry to bother you but could you possibly help with my thread about multiple tables? Additionally, how can I be close to a rank like yours rather then just Sergeant First Class?

**navaldesign** · 08-09-2010, 08:06 AM

Re: Help to activate info in Iframe using MySQL data in listbox

Rank comes with number of posts, automatically. Look at your main thread for the tables issue.

Help to activate info in Iframe using MySQL data in listbox

Help to activate info in Iframe using MySQL data in listbox

Comment

Comment

Comment

Comment

Comment

Comment

Comment