Help to activate info in Iframe using MySQL data in listbox

Collapse
X
 
  • Filter
  • Time
  • Show
Clear All
new posts
  • Rob (SA)
    Lieutenant Colonel

    • Nov 2006
    • 586

    Help to activate info in Iframe using MySQL data in listbox

    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
    Kind Regards
    Rob
    www.gnjgf.co.za
    www.oryan-projects.com
  • Antonio878
    Master Sergeant

    • Sep 2007
    • 68

    #2
    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.
    Check out:
    Great Windmill (A Place Where You Can Have Fun!)

    You can do so much on the website, check it out!

    Comment

    • Rob (SA)
      Lieutenant Colonel

      • Nov 2006
      • 586

      #3
      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.
      Kind Regards
      Rob
      www.gnjgf.co.za
      www.oryan-projects.com

      Comment

      • Antonio878
        Master Sergeant

        • Sep 2007
        • 68

        #4
        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.
        Check out:
        Great Windmill (A Place Where You Can Have Fun!)

        You can do so much on the website, check it out!

        Comment

        • navaldesign
          General & Forum Moderator

          • Oct 2005
          • 12080

          #5
          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.
          Navaldesign
          Logger Lite: Low Cost, Customizable, multifeatured Login script
          Instant Download Cart: a Powerfull, Customized, in site, DB driven, e-products Cart
          DBTechnosystems.com Forms, Databases, Shopping Carts, Instant Download Carts, Loggin Systems and more....
          Advanced BlueVoda Form Processor : No coding form processor! Just install and use! Now with built in CAPTCHA!

          Comment

          • Antonio878
            Master Sergeant

            • Sep 2007
            • 68

            #6
            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'),
                                
            onCompleteshowResponse 
                                
            });
                            }

                        function 
            showResponse(req){
                            $(
            'show').innerHTMLreq.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,
                
            WebKitnavigator.userAgent.indexOf('*****WebKit/') > -1,
                
            Gecko:  navigator.userAgent.indexOf('Gecko') > -&& 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 }
            }

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

            var Abstract = new 
            Object();

            Object.extend = function(destinationsource) {
              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 (
            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 thisargs $A(arguments), object args.shift();
              return function() {
                return 
            __method.apply(objectargs.concat($A(arguments)));
              }
            }

            Function.
            prototype.bindAsEventListener = function(object) {
              var 
            __method thisargs $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(216);
              },

              
            succ: function() {
                return 
            this 1;
              },

              
            times: function(iterator) {
                
            $R(0thistrue).each(iterator);
                return 
            this;
              },

              
            toPaddedString: function(lengthradix) {
                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 
            0length arguments.lengthlengthi++) {
                  var 
            lambda arguments[i];
                  try {
                    
            returnValue lambda();
                    break;
                  } catch (
            e) {}
                }

                return 
            returnValue;
              }
            }

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

            var PeriodicalExecuter = Class.create();
            PeriodicalExecuter.prototype = {
              
            initialize: function(callbackfrequency) {
                
            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(patternreplacement) {
                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 += sourcesource '';
                  }
                }
                return 
            result;
              },

              
            sub: function(patternreplacementcount) {
                
            replacement this.gsub.prepareReplacement(replacement);
                
            count count === undefined count;

                return 
            this.gsub(pattern, function(match) {
                  if (--
            count 0) return match[0];
                  return 
            replacement(match);
                });
              },

              
            scan: function(patterniterator) {
                
            this.gsub(patterniterator);
                return 
            this;
              },

              
            truncate: function(lengthtruncation) {
                
            length length || 30;
                
            truncation truncation === undefined '...' truncation;
                return 
            this.length length ?
                  
            this.slice(0length 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 ?
                  
            $A(div.childNodes).inject('', function(memonode) { 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(hashpair) {
                  if ((
            pair pair.split('='))[0]) {
                    var 
            key decodeURIComponent(pair.shift());
                    var 
            value pair.length pair.join('=') : pair[0];
                    if (
            value != undefinedvalue 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(0this.length 1) +
                  
            String.fromCharCode(this.charCodeAt(this.length 1) + 1);
              },

              
            times: function(count) {
                var 
            result '';
                for (var 
            0counti++) 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 
            1leni++)
                  
            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(216);
                });
                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 "
            Connectionclose" 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(qparentElement);
              }

            } else 
            document.getElementsByClassName = function(classNameparentElement) {
              var 
            children = ($(parentElement) || document.body).getElementsByTagName('*');
              var 
            elements = [], childpattern = new RegExp("(^|\\s)" className "(\\s|$)");
              for (var 
            0length children.lengthlengthi++) {
                
            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 
            Prototype.BrowserFeatures;
              if (!
            element || !element.tagName || element.nodeType == ||
               
            element._extended || F.SpecificElementExtensions || element == window)
                return 
            element;

              var 
            methods = {}, tagName element.tagNamecache Element.extend.cache,
               
            Element.Methods.ByTag;

              
            // extend methods for all tags (Safari doesn't need this)
              
            if (!F.ElementExtensions) {
                
            Object.extend(methodsElement.Methods),
                
            Object.extend(methodsElement.Methods.Simulated);
              }

              
            // extend methods for specific tags
              
            if (T[tagName]) Object.extend(methodsT[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(elementhtml) {
                
            html typeof html == 'undefined' '' html.toString();
                $(
            element).innerHTML html.stripScripts();
                
            setTimeout(function() {html.evalScripts()}, 10);
                return 
            element;
              },

              
            replace: function(elementhtml) {
                
            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 (
            valueresult += ' ' attribute '=' value.inspect(true);
                });
                return 
            result '>';
              },

              
            recursivelyCollect: function(elementproperty) {
                
            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 != 1element element.nextSibling;
                return $(
            element);
              },

              
            immediateDescendants: function(element) {
                if (!(
            element = $(element).firstChild)) return [];
                while (
            element && element.nodeType != 1element 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(
            elementselector) {
                if (
            typeof selector == 'string')
                  
            selector = new Selector(selector);
                return 
            selector.match($(element));
              },

              
            up: function(elementexpressionindex) {
                
            element = $(element);
                if (
            arguments.length == 1) return $(element.parentNode);
                var 
            ancestors element.ancestors();
                return 
            expression Selector.findElement(ancestorsexpressionindex) :
                  
            ancestors[index || 0];
              },

              
            down: function(elementexpressionindex) {
                
            element = $(element);
                if (
            arguments.length == 1) return element.firstDescendant();
                var 
            descendants element.descendants();
                return 
            expression Selector.findElement(descendantsexpressionindex) :
                  
            descendants[index || 0];
              },

              
            previous: function(elementexpressionindex) {
                
            element = $(element);
                if (
            arguments.length == 1) return $(Selector.handlers.previousElementSibling(element));
                var 
            previousSiblings element.previousSiblings();
                return 
            expression Selector.findElement(previousSiblingsexpressionindex) :
                  
            previousSiblings[index || 0];
              },

              
            next: function(elementexpressionindex) {
                
            element = $(element);
                if (
            arguments.length == 1) return $(Selector.handlers.******ementSibling(element));
                var 
            nextSiblings element.nextSiblings();
                return 
            expression Selector.findElement(nextSiblingsexpressionindex) :
                  
            nextSiblings[index || 0];
              },

              
            getElementsBySelector: function() {
                var 
            args $A(arguments), element = $(args.shift());
                return 
            Selector.findChildElements(elementargs);
              },

              
            getElementsByClassName: function(elementclassName) {
                return 
            document.getElementsByClassName(classNameelement);
              },

              
            readAttribute: function(elementname) {
                
            element = $(element);
                if (
            Prototype.Browser.IE) {
                  if (!
            element.attributes) return null;
                  var 
            Element._attributeTranslations;
                  if (
            t.values[name]) return t.values[name](elementname);
                  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(elementclassName) {
                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(elementclassName) {
                if (!(
            element = $(element))) return;
                
            Element.classNames(element).add(className);
                return 
            element;
              },

              
            removeClassName: function(elementclassName) {
                if (!(
            element = $(element))) return;
                
            Element.classNames(element).remove(className);
                return 
            element;
              },

              
            toggleClassName: function(elementclassName) {
                if (!(
            element = $(element))) return;
                
            Element.classNames(element)[element.hasClassName(className) ? 'remove' 'add'](className);
                return 
            element;
              },

              
            observe: function() {
                
            Event.observe.apply(Eventarguments);
                return 
            $A(arguments).first();
              },

              
            stopObserving: function() {
                
            Event.stopObserving.apply(Eventarguments);
                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 == && !/\S/.test(node.nodeValue))
                    
            element.removeChild(node);
                  
            node nextNode;
                }
                return 
            element;
              },

              empty: function(
            element) {
                return $(
            element).innerHTML.blank();
              },

              
            descendantOf: function(elementancestor) {
                
            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(elementstyle) {
                
            element = $(element);
                
            style style == 'float' 'cssFloat' style.camelize();
                var 
            value element.style[style];
                if (!
            value) {
                  var 
            css document.defaultView.getComputedStyle(elementnull);
                  
            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(elementstylescamelized) {
                
            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(elementvalue) {
                
            element = $(element);
                
            element.style.opacity = (value == || value === '') ? '' :
                  (
            value 0.00001) ? value;
                return 
            element;
              },

              
            getDimensions: function(element) {
                
            element = $(element);
                var 
            display = $(element).getStyle('display');
                if (
            display != 'none' && display != null// Safari bug
                  
            return {widthelement.offsetWidthheightelement.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 {
            widthoriginalWidthheightoriginalHeight};
              },

              
            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, {
              
            childOfElement.Methods.descendantOf,
              
            childElementsElement.Methods.immediateDescendants
            });

            if (
            Prototype.Browser.Opera) {
              
            Element.Methods._getStyle Element.Methods.getStyle;
              
            Element.Methods.getStyle = function(elementstyle) {
                switch(
            style) {
                  case 
            'left':
                  case 
            'top':
                  case 
            'right':
                  case 
            'bottom':
                    if (
            Element._getStyle(element'position') == 'static') return null;
                  default: return 
            Element._getStyle(elementstyle);
                }
              };
            }
            else if (
            Prototype.Browser.IE) {
              
            Element.Methods.getStyle = function(elementstyle) {
                
            element = $(element);
                
            style = (style == 'float' || style == 'cssFloat') ? 'styleFloat' style.camelize();
                var 
            value element.style[style];
                if (!
            value && element.currentStylevalue 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(elementvalue) {
                
            element = $(element);
                var 
            filter element.getStyle('filter'), style element.style;
                if (
            value == || value === '') {
                  
            style.filter filter.replace(/alpha\([^\)]*\)/gi,'');
                  return 
            element;
                } else if (
            value 0.00001value 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(elementhtml) {
                
            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(elementvalue) {
                
            element = $(element);
                
            element.style.opacity = (value == 1) ? 0.999999 :
                  (
            value === '') ? '' : (value 0.00001) ? 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(elementattribute) {
                  return 
            element.getAttribute(attribute2);
                },
                
            _flag: function(elementattribute) {
                  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, {
                
            hrefthis._getAttr,
                
            src:  this._getAttr,
                
            typethis._getAttr,
                
            disabledthis._flag,
                
            checked:  this._flag,
                readonly: 
            this._flag,
                
            multiplethis._flag
              
            });
            }).
            call(Element._attributeTranslations.values);

            Element.Methods.Simulated = {
              
            hasAttribute: function(elementattribute) {
                var 
            Element._attributeTranslationsnode;
                
            attribute t.names[attribute] || attribute;
                
            node = $(element).getAttributeNode(attribute);
                return 
            node && node.specified;
              }
            };

            Element.Methods.ByTag = {};

            Object.extend(ElementElement.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(elementattribute) {
              if (
            element.hasAttribute) return element.hasAttribute(attribute);
              return 
            Element.Methods.Simulated.hasAttribute(elementattribute);
            };

            Element.addMethods = function(methods) {
              var 
            Prototype.BrowserFeaturesElement.Methods.ByTag;

              if (!
            methods) {
                
            Object.extend(FormForm.Methods);
                
            Object.extend(Form.ElementForm.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 (!
            tagNameObject.extend(Element.Methodsmethods || {});
              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(methodsdestinationonlyIfAbsent) {
                
            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.MethodsHTMLElement.prototype);
                
            copy(Element.Methods.SimulatedHTMLElement.prototypetrue);
              }

              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(ElementElement.Methods);
              
            delete Element.ByTag;
            };

            var 
            Toggle = { displayElement.toggle };

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

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

            Abstract.
            Insertion.prototype = {
              
            initialize: function(elementcontent) {
                
            this.element = $(element);
                
            this.content content.stripScripts();

                if (
            this.adjacency && this.element.insertAdjacentHTML) {
                  try {
                    
            this.element.insertAdjacentHTML(this.adjacencythis.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.initializeRangethis.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(fragmentthis.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(fragmentthis.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.prototypeEnumerable);
            /* 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 
            this.expressionps Selector.patternsSelector.handlers,
                    
            Selector.criterialepm;

                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 (
            && le != && (/\S/).test(e)) {
                  
            le e;
                  for (var 
            i in ps) {
                    
            ps[i];
                    if (
            e.match(p)) {
                      
            this.matcher.push(typeof c[i] == 'function' c[i](m) :
                          new 
            Template(c[i]).evaluate(m));
                      
            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 
            this.expressionps Selector.patterns,
                    
            Selector.xpathle,  m;

                if (
            Selector._cache[e]) {
                  
            this.xpath Selector._cache[e]; return;
                }

                
            this.matcher = ['.//*'];
                while (
            && le != && (/\S/).test(e)) {
                  
            le e;
                  for (var 
            i in ps) {
                    if (
            e.match(ps[i])) {
                      
            this.matcher.push(typeof x[i] == 'function' x[i](m) :
                        new 
            Template(x[i]).evaluate(m));
                      
            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.xpathroot);
                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 
            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 
            m[6], Selector.patterns,
                        
            Selector.xpathlemv;

                    var 
            exclusion = [];
                    while (
            && le != && (/\S/).test(e)) {
                      
            le e;
                      for (var 
            i in p) {
                        if (
            e.match(p[i])) {
                          
            typeof x[i] == 'function' x[i](m) : new Template(x[i]).evaluate(m);
                          
            exclusion.push("(" v.substring(1v.length 1) + ")");
                          
            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 
            Selector.xpath.pseudos; return p['first-of-type'](m) + p['last-of-type'](m);
                  },
                  
            nth: function(fragmentm) {
                    var 
            mmformula 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 
            mm[1] ? Number(mm[1]) : 1;
                      var 
            mm[2] ? Number(mm[2]) : 0;
                      
            predicate "[((#{fragment} - #{b}) mod #{a} = 0) and " +
                      
            "((#{fragment} - #{b}) div #{a} >= 0)]";
                      return new 
            Template(predicate).evaluate({
                        
            fragmentfragmentaab});
                    }
                  }
                }
              },

              
            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('
            h.pseudo(n"#{1}""#{6}"rc); false;').evaluate(m);
                },
                descendant:   '
            "descendant";',
                child:        '
            "child";',
                adjacent:     '
            "adjacent";',
                laterSibling: '
            "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(ab) {
                  for (var 
            0nodenode b[i]; i++)
                    
            a.push(node);
                  return 
            a;
                },

                
            // marks an array of nodes for counting
                
            mark: function(nodes) {
                  for (var 
            0nodenode nodes[i]; i++)
                    
            node._counted true;
                  return 
            nodes;
                },

                
            unmark: function(nodes) {
                  for (var 
            0nodenode 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(parentNodereverseofType) {
                  
            parentNode._counted true;
                  if (
            reverse) {
                    for (var 
            nodes parentNode.childNodesnodes.length 11>= 0i--) {
                      
            node nodes[i];
                      if (
            node.nodeType == && (!ofType || node._counted)) node.nodeIndex j++;
                    }
                  } else {
                    for (var 
            01nodes parentNode.childNodesnode nodes[i]; i++)
                      if (
            node.nodeType == && (!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 
            0nodes.lengthli++)
                    if (!(
            nodes[i])._counted) {
                      
            n._counted true;
                      
            results.push(Element.extend(n));
                    }
                  return 
            Selector.handlers.unmark(results);
                },

                
            // COMBINATOR FUNCTIONS
                
            descendant: function(nodes) {
                  var 
            Selector.handlers;
                  for (var 
            0results = [], nodenode nodes[i]; i++)
                    
            h.concat(resultsnode.getElementsByTagName('*'));
                  return 
            results;
                },

                
            child: function(nodes) {
                  var 
            Selector.handlers;
                  for (var 
            0results = [], nodenode nodes[i]; i++) {
                    for (var 
            0children = [], childchild node.childNodes[j]; j++)
                      if (
            child.nodeType == && child.tagName != '!'results.push(child);
                  }
                  return 
            results;
                },

                
            adjacent: function(nodes) {
                  for (var 
            0results = [], nodenode nodes[i]; i++) {
                    var 
            next this.******ementSibling(node);
                    if (
            nextresults.push(next);
                  }
                  return 
            results;
                },

                
            laterSibling: function(nodes) {
                  var 
            Selector.handlers;
                  for (var 
            0results = [], nodenode nodes[i]; i++)
                    
            h.concat(resultsElement.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(nodesroottagNamecombinator) {
                  
            tagName tagName.toUpperCase();
                  var 
            results = [], Selector.handlers;
                  if (
            nodes) {
                    if (
            combinator) {
                      
            // fastlane for ordinary descendant combinators
                      
            if (combinator == "descendant") {
                        for (var 
            0nodenode nodes[i]; i++)
                          
            h.concat(resultsnode.getElementsByTagName(tagName));
                        return 
            results;
                      } else 
            nodes this[combinator](nodes);
                      if (
            tagName == "*") return nodes;
                    }
                    for (var 
            0nodenode nodes[i]; i++)
                      if (
            node.tagName.toUpperCase() == tagNameresults.push(node);
                    return 
            results;
                  } else return 
            root.getElementsByTagName(tagName);
                },

                
            id: function(nodesrootidcombinator) {
                  var 
            targetNode = $(id), Selector.handlers;
                  if (!
            nodes && root == document) return targetNode ? [targetNode] : [];
                  if (
            nodes) {
                    if (
            combinator) {
                      if (
            combinator == 'child') {
                        for (var 
            0nodenode nodes[i]; i++)
                          if (
            targetNode.parentNode == node) return [targetNode];
                      } else if (
            combinator == 'descendant') {
                        for (var 
            0nodenode nodes[i]; i++)
                          if (
            Element.descendantOf(targetNodenode)) return [targetNode];
                      } else if (
            combinator == 'adjacent') {
                        for (var 
            0nodenode nodes[i]; i++)
                          if (
            Selector.handlers.previousElementSibling(targetNode) == node)
                            return [
            targetNode];
                      } else 
            nodes h[combinator](nodes);
                    }
                    for (var 
            0nodenode nodes[i]; i++)
                      if (
            node == targetNode) return [targetNode];
                    return [];
                  }
                  return (
            targetNode && Element.descendantOf(targetNoderoot)) ? [targetNode] : [];
                },

                
            className: function(nodesrootclassNamecombinator) {
                  if (
            nodes && combinatornodes this[combinator](nodes);
                  return 
            Selector.handlers.byClassName(nodesrootclassName);
                },

                
            byClassName: function(nodesrootclassName) {
                  if (!
            nodesnodes Selector.handlers.descendant([root]);
                  var 
            needle ' ' className ' ';
                  for (var 
            0results = [], nodenodeClassNamenode nodes[i]; i++) {
                    
            nodeClassName node.className;
                    if (
            nodeClassName.length == 0) continue;
                    if (
            nodeClassName == className || (' ' nodeClassName ' ').include(needle))
                      
            results.push(node);
                  }
                  return 
            results;
                },

                
            attrPresence: function(nodesrootattr) {
                  var 
            results = [];
                  for (var 
            0nodenode nodes[i]; i++)
                    if (
            Element.hasAttribute(nodeattr)) results.push(node);
                  return 
            results;
                },

                
            attr: function(nodesrootattrvalueoperator) {
                  if (!
            nodesnodes root.getElementsByTagName("*");
                  var 
            handler Selector.operators[operator], results = [];
                  for (var 
            0nodenode nodes[i]; i++) {
                    var 
            nodeValue Element.readAttribute(nodeattr);
                    if (
            nodeValue === null) continue;
                    if (
            handler(nodeValuevalue)) results.push(node);
                  }
                  return 
            results;
                },

                
            pseudo: function(nodesnamevaluerootcombinator) {
                  if (
            nodes && combinatornodes this[combinator](nodes);
                  if (!
            nodesnodes root.getElementsByTagName("*");
                  return 
            Selector.pseudos[name](nodesvalueroot);
                }
              },

              
            pseudos: {
                
            'first-child': function(nodesvalueroot) {
                  for (var 
            0results = [], nodenode nodes[i]; i++) {
                    if (
            Selector.handlers.previousElementSibling(node)) continue;
                      
            results.push(node);
                  }
                  return 
            results;
                },
                
            'last-child': function(nodesvalueroot) {
                  for (var 
            0results = [], nodenode nodes[i]; i++) {
                    if (
            Selector.handlers.******ementSibling(node)) continue;
                      
            results.push(node);
                  }
                  return 
            results;
                },
                
            'only-child': function(nodesvalueroot) {
                  var 
            Selector.handlers;
                  for (var 
            0results = [], nodenode nodes[i]; i++)
                    if (!
            h.previousElementSibling(node) && !h.******ementSibling(node))
                      
            results.push(node);
                  return 
            results;
                },
                
            'nth-child':        function(nodesformularoot) {
                  return 
            Selector.pseudos.nth(nodesformularoot);
                },
                
            'nth-last-child':   function(nodesformularoot) {
                  return 
            Selector.pseudos.nth(nodesformularoottrue);
                },
                
            'nth-of-type':      function(nodesformularoot) {
                  return 
            Selector.pseudos.nth(nodesformularootfalsetrue);
                },
                
            'nth-last-of-type': function(nodesformularoot) {
                  return 
            Selector.pseudos.nth(nodesformularoottruetrue);
                },
                
            'first-of-type':    function(nodesformularoot) {
                  return 
            Selector.pseudos.nth(nodes"1"rootfalsetrue);
                },
                
            'last-of-type':     function(nodesformularoot) {
                  return 
            Selector.pseudos.nth(nodes"1"roottruetrue);
                },
                
            'only-of-type':     function(nodesformularoot) {
                  var 
            Selector.pseudos;
                  return 
            p['last-of-type'](p['first-of-type'](nodesformularoot), formularoot);
                },

                
            // handles the an+b logic
                
            getIndices: function(abtotal) {
                  if (
            == 0) return ? [b] : [];
                  return 
            $R(1total).inject([], function(memoi) {
                    if (
            == (b) % && (b) / >= 0memo.push(i);
                    return 
            memo;
                  });
                },

                
            // handles nth(-last)-child, nth(-last)-of-type, and (first|last)-of-type
                
            nth: function(nodesformularootreverseofType) {
                  if (
            nodes.length == 0) return [];
                  if (
            formula == 'even'formula '2n+0';
                  if (
            formula == 'odd')  formula '2n+1';
                  var 
            Selector.handlersresults = [], indexed = [], m;
                  
            h.mark(nodes);
                  for (var 
            0nodenode nodes[i]; i++) {
                    if (!
            node.parentNode._counted) {
                      
            h.index(node.parentNodereverseofType);
                      
            indexed.push(node.parentNode);
                    }
                  }
                  if (
            formula.match(/^\d+$/)) { // just a number
                    
            formula Number(formula);
                    for (var 
            0nodenode nodes[i]; i++)
                      if (
            node.nodeIndex == formularesults.push(node);
                  } else if (
            formula.match(/^(-?\d*)?n(([+-])(\d+))?/)) { // an+b
                    
            if (m[1] == "-"m[1] = -1;
                    var 
            m[1] ? Number(m[1]) : 1;
                    var 
            m[2] ? Number(m[2]) : 0;
                    var 
            indices Selector.pseudos.getIndices(abnodes.length);
                    for (var 
            0nodeindices.lengthnode nodes[i]; i++) {
                      for (var 
            0lj++)
                        if (
            node.nodeIndex == indices[j]) results.push(node);
                    }
                  }
                  
            h.unmark(nodes);
                  
            h.unmark(indexed);
                  return 
            results;
                },

                
            'empty': function(nodesvalueroot) {
                  for (var 
            0results = [], nodenode 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(nodesselectorroot) {
                  var 
            Selector.handlersselectorTypem;
                  var 
            exclusions = new Selector(selector).findElements(root);
                  
            h.mark(exclusions);
                  for (var 
            0results = [], nodenode nodes[i]; i++)
                    if (!
            node._countedresults.push(node);
                  
            h.unmark(exclusions);
                  return 
            results;
                },

                
            'enabled': function(nodesvalueroot) {
                  for (var 
            0results = [], nodenode nodes[i]; i++)
                    if (!
            node.disabledresults.push(node);
                  return 
            results;
                },

                
            'disabled': function(nodesvalueroot) {
                  for (var 
            0results = [], nodenode nodes[i]; i++)
                    if (
            node.disabledresults.push(node);
                  return 
            results;
                },

                
            'checked': function(nodesvalueroot) {
                  for (var 
            0results = [], nodenode nodes[i]; i++)
                    if (
            node.checkedresults.push(node);
                  return 
            results;
                }
              },

              
            operators: {
                
            '=':  function(nvv) { return nv == v; },
                
            '!=': function(nvv) { return nv != v; },
                
            '^=': function(nvv) { return nv.startsWith(v); },
                
            '$=': function(nvv) { return nv.endsWith(v); },
                
            '*=': function(nvv) { return nv.include(v); },
                
            '~=': function(nvv) { return (' ' nv ' ').include(' ' ' '); },
                
            '|=': function(nvv) { return ('-' nv.toUpperCase() + '-').include('-' v.toUpperCase() + '-'); }
              },

              
            matchElements: function(elementsexpression) {
                var 
            matches = new Selector(expression).findElements(), Selector.handlers;
                
            h.mark(matches);
                for (var 
            0results = [], elementelement elements[i]; i++)
                  if (
            element._countedresults.push(element);
                
            h.unmark(matches);
                return 
            results;
              },

              
            findElement: function(elementsexpressionindex) {
                if (
            typeof expression == 'number') {
                  
            index expressionexpression false;
                }
                return 
            Selector.matchElements(elementsexpression || '*')[index || 0];
              },

              
            findChildElements: function(elementexpressions) {
                var 
            exprs expressions.join(','), expressions = [];
                
            exprs.scan(/(([\w#:.~>+()\s-]+|\*|\[.*?\])+)\s*(,|$)/, function(m) {
                  
            expressions.push(m[1].strip());
                });
                var 
            results = [], Selector.handlers;
                for (var 
            0expressions.lengthselectorli++) {
                  
            selector = new Selector(expressions[i].strip());
                  
            h.concat(resultsselector.findElements(element));
                }
                return (
            1) ? h.unique(results) : results;
              }
            });

            function $$() {
              return 
            Selector.findChildElements(document$A(arguments));
            }
            var 
            Form = {
              
            reset: function(form) {
                $(
            form).reset();
                return 
            form;
              },

              
            serializeElements: function(elementsgetHash) {
                var 
            data elements.inject({}, function(resultelement) {
                  if (!
            element.disabled && element.name) {
                    var 
            key element.namevalue = $(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(formgetHash) {
                return 
            Form.serializeElements(Form.getElements(form), getHash);
              },

              
            getElements: function(form) {
                return 
            $A($(form).getElementsByTagName('*')).inject([],
                  function(
            elementschild) {
                    if (
            Form.Element.Serializers[child.tagName.toLowerCase()])
                      
            elements.push(Element.extend(child));
                    return 
            elements;
                  }
                );
              },

              
            getInputs: function(formtypeNamename) {
                
            form = $(form);
                var 
            inputs form.getElementsByTagName('input');

                if (!
            typeName && !name) return $A(inputs).map(Element.extend);

                for (var 
            0matchingInputs = [], length inputs.lengthlengthi++) {
                  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(formoptions) {
                
            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.parametersparams);
                }

                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 >= this.optionValue(element.options[index]) : null;
              },

              
            selectMany: function(element) {
                var 
            valueslength element.length;
                if (!
            length) return null;

                for (var 
            0values = []; lengthi++) {
                  var 
            opt element.options[i];
                  if (
            opt.selectedvalues.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(elementfrequencycallback) {
                
            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.elementvalue);
                  
            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(elementcallback) {
                
            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.elementvalue);
                  
            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_BACKSPACE8,
              
            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_PAGEDOWN34,

              
            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(eventtagName) {
                var 
            element Event.element(event);
                while (
            element.parentNode && (!element.tagName ||
                    (
            element.tagName.toUpperCase() != tagName.toUpperCase())))
                  
            element element.parentNode;
                return 
            element;
              },

              
            observersfalse,

              
            _observeAndCache: function(elementnameobserveruseCapture) {
                if (!
            this.observersthis.observers = [];
                if (
            element.addEventListener) {
                  
            this.observers.push([elementnameobserveruseCapture]);
                  
            element.addEventListener(nameobserveruseCapture);
                } else if (
            element.attachEvent) {
                  
            this.observers.push([elementnameobserveruseCapture]);
                  
            element.attachEvent('on' nameobserver);
                }
              },

              
            unloadCache: function() {
                if (!
            Event.observers) return;
                for (var 
            0length Event.observers.lengthlengthi++) {
                  
            Event.stopObserving.apply(thisEvent.observers[i]);
                  
            Event.observers[i][0] = null;
                }
                
            Event.observers false;
              },

              
            observe: function(elementnameobserveruseCapture) {
                
            element = $(element);
                
            useCapture useCapture || false;

                if (
            name == 'keypress' &&
                  (
            Prototype.Browser.WebKit || element.attachEvent))
                  
            name 'keydown';

                
            Event._observeAndCache(elementnameobserveruseCapture);
              },

              
            stopObserving: function(elementnameobserveruseCapture) {
                
            element = $(element);
                
            useCapture useCapture || false;

                if (
            name == 'keypress' &&
                    (
            Prototype.Browser.WebKit || element.attachEvent))
                  
            name 'keydown';

                if (
            element.removeEventListener) {
                  
            element.removeEventListener(nameobserveruseCapture);
                } else if (
            element.detachEvent) {
                  try {
                    
            element.detachEvent('on' nameobserver);
                  } catch (
            e) {}
                }
              }
            });

            /* prevent memory leaks in IE */
            if (Prototype.Browser.IE)
              
            Event.observe(window'unload'Event.unloadCachefalse);
            var 
            Position = {
              
            // set to true if needed, warning: firefox performance problems
              // NOT neeeded for page scrolling, only if draggable contained in
              // scrollable elements
              
            includeScrollOffsetsfalse,

              
            // 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 0valueL 0;
                do {
                  
            valueT += element.scrollTop  || 0;
                  
            valueL += element.scrollLeft || 0;
                  
            element element.parentNode;
                } while (
            element);
                return [
            valueLvalueT];
              },

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

              
            positionedOffset: function(element) {
                var 
            valueT 0valueL 0;
                do {
                  
            valueT += element.offsetTop  || 0;
                  
            valueL += element.offsetLeft || 0;
                  
            element element.offsetParent;
                  if (
            element) {
                    if(
            element.tagName=='BODY') break;
                    var 
            Element.getStyle(element'position');
                    if (
            == 'relative' || == 'absolute') break;
                  }
                } while (
            element);
                return [
            valueLvalueT];
              },

              
            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(elementxy) {
                if (
            this.includeScrollOffsets)
                  return 
            this.withinIncludingScrolloffsets(elementxy);
                
            this.xcomp x;
                
            this.ycomp y;
                
            this.offset this.cumulativeOffset(element);

                return (
            >= this.offset[1] &&
                        
            <  this.offset[1] + element.offsetHeight &&
                        
            >= this.offset[0] &&
                        
            <  this.offset[0] + element.offsetWidth);
              },

              
            withinIncludingScrolloffsets: function(elementxy) {
                var 
            offsetcache this.realOffset(element);

                
            this.xcomp offsetcache[0] - this.deltaX;
                
            this.ycomp 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(modeelement) {
                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 0valueL 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 [
            valueLvalueT];
              },

              clone: function(
            sourcetarget) {
                var 
            options Object.extend({
                  
            setLeft:    true,
                  
            setTop:     true,
                  
            setWidth:   true,
                  
            setHeight:  true,
                  
            offsetTop:  0,
                  
            offsetLeft0
                
            }, arguments[2] || {})

                
            // find page position of source
                
            source = $(source);
                var 
            Position.page(source);

                
            // find coordinate system to use
                
            target = $(target);
                var 
            delta = [00];
                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.setHeighttarget.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 0valueL 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 [
            valueLvalueT];
              }
            }

            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=$rangeframeborder="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!
            Check out:
            Great Windmill (A Place Where You Can Have Fun!)

            You can do so much on the website, check it out!

            Comment

            • Antonio878
              Master Sergeant

              • Sep 2007
              • 68

              #7
              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?
              Check out:
              Great Windmill (A Place Where You Can Have Fun!)

              You can do so much on the website, check it out!

              Comment

              • navaldesign
                General & Forum Moderator

                • Oct 2005
                • 12080

                #8
                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.
                Navaldesign
                Logger Lite: Low Cost, Customizable, multifeatured Login script
                Instant Download Cart: a Powerfull, Customized, in site, DB driven, e-products Cart
                DBTechnosystems.com Forms, Databases, Shopping Carts, Instant Download Carts, Loggin Systems and more....
                Advanced BlueVoda Form Processor : No coding form processor! Just install and use! Now with built in CAPTCHA!

                Comment

                Working...
                X