git.oblomov.eu Git - ohcount/blob - test/expected_dir/js1.js

   1 javascript      comment /*  Prototype JavaScript framework, version 1.4.0
   2 javascript      comment  *  (c) 2005 Sam Stephenson <sam@conio.net>
   3 javascript      comment  *
   4 javascript      comment  *  Prototype is freely distributable under the terms of an MIT-style license.
   5 javascript      comment  *  For details, see the Prototype web site: http://prototype.conio.net/
   6 javascript      comment  *
   7 javascript      comment /*--------------------------------------------------------------------------*/
   8 javascript      blank
   9 javascript      code    var Prototype = {
  10 javascript      code      Version: '1.4.0',
  11 javascript      code      ScriptFragment: '(?:<script.*?>)((\n|\r|.)*?)(?:<\/script>)',
  12 javascript      blank
  13 javascript      code      emptyFunction: function() {},
  14 javascript      code      K: function(x) {return x}
  15 javascript      code    }
  16 javascript      blank
  17 javascript      code    var Class = {
  18 javascript      code      create: function() {
  19 javascript      code        return function() {
  20 javascript      code          this.initialize.apply(this, arguments);
  21 javascript      code        }
  22 javascript      code      }
  23 javascript      code    }
  24 javascript      blank
  25 javascript      code    var Abstract = new Object();
  26 javascript      blank
  27 javascript      code    Object.extend = function(destination, source) {
  28 javascript      code      for (property in source) {
  29 javascript      code        destination[property] = source[property];
  30 javascript      code      }
  31 javascript      code      return destination;
  32 javascript      code    }
  33 javascript      blank
  34 javascript      code    Object.inspect = function(object) {
  35 javascript      code      try {
  36 javascript      code        if (object == undefined) return 'undefined';
  37 javascript      code        if (object == null) return 'null';
  38 javascript      code        return object.inspect ? object.inspect() : object.toString();
  39 javascript      code      } catch (e) {
  40 javascript      code        if (e instanceof RangeError) return '...';
  41 javascript      code        throw e;
  42 javascript      code      }
  43 javascript      code    }
  44 javascript      blank
  45 javascript      code    Function.prototype.bind = function() {
  46 javascript      code      var __method = this, args = $A(arguments), object = args.shift();
  47 javascript      code      return function() {
  48 javascript      code        return __method.apply(object, args.concat($A(arguments)));
  49 javascript      code      }
  50 javascript      code    }
  51 javascript      blank
  52 javascript      code    Function.prototype.bindAsEventListener = function(object) {
  53 javascript      code      var __method = this;
  54 javascript      code      return function(event) {
  55 javascript      code        return __method.call(object, event || window.event);
  56 javascript      code      }
  57 javascript      code    }
  58 javascript      blank
  59 javascript      code    Object.extend(Number.prototype, {
  60 javascript      code      toColorPart: function() {
  61 javascript      code        var digits = this.toString(16);
  62 javascript      code        if (this < 16) return '0' + digits;
  63 javascript      code        return digits;
  64 javascript      code      },
  65 javascript      blank
  66 javascript      code      succ: function() {
  67 javascript      code        return this + 1;
  68 javascript      code      },
  69 javascript      blank
  70 javascript      code      times: function(iterator) {
  71 javascript      code        $R(0, this, true).each(iterator);
  72 javascript      code        return this;
  73 javascript      code      }
  74 javascript      code    });
  75 javascript      blank
  76 javascript      code    var Try = {
  77 javascript      code      these: function() {
  78 javascript      code        var returnValue;
  79 javascript      blank
  80 javascript      code        for (var i = 0; i < arguments.length; i++) {
  81 javascript      code          var lambda = arguments[i];
  82 javascript      code          try {
  83 javascript      code            returnValue = lambda();
  84 javascript      code            break;
  85 javascript      code          } catch (e) {}
  86 javascript      code        }
  87 javascript      blank
  88 javascript      code        return returnValue;
  89 javascript      code      }
  90 javascript      code    }
  91 javascript      blank
  92 javascript      comment /*--------------------------------------------------------------------------*/
  93 javascript      blank
  94 javascript      code    var PeriodicalExecuter = Class.create();
  95 javascript      code    PeriodicalExecuter.prototype = {
  96 javascript      code      initialize: function(callback, frequency) {
  97 javascript      code        this.callback = callback;
  98 javascript      code        this.frequency = frequency;
  99 javascript      code        this.currentlyExecuting = false;
 100 javascript      blank
 101 javascript      code        this.registerCallback();
 102 javascript      code      },
 103 javascript      blank
 104 javascript      code      registerCallback: function() {
 105 javascript      code        setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
 106 javascript      code      },
 107 javascript      blank
 108 javascript      code      onTimerEvent: function() {
 109 javascript      code        if (!this.currentlyExecuting) {
 110 javascript      code          try {
 111 javascript      code            this.currentlyExecuting = true;
 112 javascript      code            this.callback();
 113 javascript      code          } finally {
 114 javascript      code            this.currentlyExecuting = false;
 115 javascript      code          }
 116 javascript      code        }
 117 javascript      code      }
 118 javascript      code    }
 119 javascript      blank
 120 javascript      comment /*--------------------------------------------------------------------------*/
 121 javascript      blank
 122 javascript      code    function $() {
 123 javascript      code      var elements = new Array();
 124 javascript      blank
 125 javascript      code      for (var i = 0; i < arguments.length; i++) {
 126 javascript      code        var element = arguments[i];
 127 javascript      code        if (typeof element == 'string')
 128 javascript      code          element = document.getElementById(element);
 129 javascript      blank
 130 javascript      code        if (arguments.length == 1)
 131 javascript      code          return element;
 132 javascript      blank
 133 javascript      code        elements.push(element);
 134 javascript      code      }
 135 javascript      blank
 136 javascript      code      return elements;
 137 javascript      code    }
 138 javascript      code    Object.extend(String.prototype, {
 139 javascript      code      stripTags: function() {
 140 javascript      code        return this.replace(/<\/?[^>]+>/gi, '');
 141 javascript      code      },
 142 javascript      blank
 143 javascript      code      stripScripts: function() {
 144 javascript      code        return this.replace(new RegExp(Prototype.ScriptFragment, 'img'), '');
 145 javascript      code      },
 146 javascript      blank
 147 javascript      code      extractScripts: function() {
 148 javascript      code        var matchAll = new RegExp(Prototype.ScriptFragment, 'img');
 149 javascript      code        var matchOne = new RegExp(Prototype.ScriptFragment, 'im');
 150 javascript      code        return (this.match(matchAll) || []).map(function(scriptTag) {
 151 javascript      code          return (scriptTag.match(matchOne) || ['', ''])[1];
 152 javascript      code        });
 153 javascript      code      },
 154 javascript      blank
 155 javascript      code      evalScripts: function() {
 156 javascript      code        return this.extractScripts().map(eval);
 157 javascript      code      },
 158 javascript      blank
 159 javascript      code      escapeHTML: function() {
 160 javascript      code        var div = document.createElement('div');
 161 javascript      code        var text = document.createTextNode(this);
 162 javascript      code        div.appendChild(text);
 163 javascript      code        return div.innerHTML;
 164 javascript      code      },
 165 javascript      blank
 166 javascript      code      unescapeHTML: function() {
 167 javascript      code        var div = document.createElement('div');
 168 javascript      code        div.innerHTML = this.stripTags();
 169 javascript      code        return div.childNodes[0] ? div.childNodes[0].nodeValue : '';
 170 javascript      code      },
 171 javascript      blank
 172 javascript      code      toQueryParams: function() {
 173 javascript      code        var pairs = this.match(/^\??(.*)$/)[1].split('&');
 174 javascript      code        return pairs.inject({}, function(params, pairString) {
 175 javascript      code          var pair = pairString.split('=');
 176 javascript      code          params[pair[0]] = pair[1];
 177 javascript      code          return params;
 178 javascript      code        });
 179 javascript      code      },
 180 javascript      blank
 181 javascript      code      toArray: function() {
 182 javascript      code        return this.split('');
 183 javascript      code      },
 184 javascript      blank
 185 javascript      code      camelize: function() {
 186 javascript      code        var oStringList = this.split('-');
 187 javascript      code        if (oStringList.length == 1) return oStringList[0];
 188 javascript      blank
 189 javascript      code        var camelizedString = this.indexOf('-') == 0
 190 javascript      code          ? oStringList[0].charAt(0).toUpperCase() + oStringList[0].substring(1)
 191 javascript      code          : oStringList[0];
 192 javascript      blank
 193 javascript      code        for (var i = 1, len = oStringList.length; i < len; i++) {
 194 javascript      code          var s = oStringList[i];
 195 javascript      code          camelizedString += s.charAt(0).toUpperCase() + s.substring(1);
 196 javascript      code        }
 197 javascript      blank
 198 javascript      code        return camelizedString;
 199 javascript      code      },
 200 javascript      blank
 201 javascript      code      inspect: function() {
 202 javascript      code        return "'" + this.replace('\\', '\\\\').replace("'", '\\\'') + "'";
 203 javascript      code      }
 204 javascript      code    });
 205 javascript      blank
 206 javascript      code    String.prototype.parseQuery = String.prototype.toQueryParams;
 207 javascript      blank
 208 javascript      code    var $break    = new Object();
 209 javascript      code    var $continue = new Object();
 210 javascript      blank
 211 javascript      code    var Enumerable = {
 212 javascript      code      each: function(iterator) {
 213 javascript      code        var index = 0;
 214 javascript      code        try {
 215 javascript      code          this._each(function(value) {
 216 javascript      code            try {
 217 javascript      code              iterator(value, index++);
 218 javascript      code            } catch (e) {
 219 javascript      code              if (e != $continue) throw e;
 220 javascript      code            }
 221 javascript      code          });
 222 javascript      code        } catch (e) {
 223 javascript      code          if (e != $break) throw e;
 224 javascript      code        }
 225 javascript      code      },
 226 javascript      blank
 227 javascript      code      all: function(iterator) {
 228 javascript      code        var result = true;
 229 javascript      code        this.each(function(value, index) {
 230 javascript      code          result = result && !!(iterator || Prototype.K)(value, index);
 231 javascript      code          if (!result) throw $break;
 232 javascript      code        });
 233 javascript      code        return result;
 234 javascript      code      },
 235 javascript      blank
 236 javascript      code      any: function(iterator) {
 237 javascript      code        var result = true;
 238 javascript      code        this.each(function(value, index) {
 239 javascript      code          if (result = !!(iterator || Prototype.K)(value, index))
 240 javascript      code            throw $break;
 241 javascript      code        });
 242 javascript      code        return result;
 243 javascript      code      },
 244 javascript      blank
 245 javascript      code      collect: function(iterator) {
 246 javascript      code        var results = [];
 247 javascript      code        this.each(function(value, index) {
 248 javascript      code          results.push(iterator(value, index));
 249 javascript      code        });
 250 javascript      code        return results;
 251 javascript      code      },
 252 javascript      blank
 253 javascript      code      detect: function (iterator) {
 254 javascript      code        var result;
 255 javascript      code        this.each(function(value, index) {
 256 javascript      code          if (iterator(value, index)) {
 257 javascript      code            result = value;
 258 javascript      code            throw $break;
 259 javascript      code          }
 260 javascript      code        });
 261 javascript      code        return result;
 262 javascript      code      },
 263 javascript      blank
 264 javascript      code      findAll: function(iterator) {
 265 javascript      code        var results = [];
 266 javascript      code        this.each(function(value, index) {
 267 javascript      code          if (iterator(value, index))
 268 javascript      code            results.push(value);
 269 javascript      code        });
 270 javascript      code        return results;
 271 javascript      code      },
 272 javascript      blank
 273 javascript      code      grep: function(pattern, iterator) {
 274 javascript      code        var results = [];
 275 javascript      code        this.each(function(value, index) {
 276 javascript      code          var stringValue = value.toString();
 277 javascript      code          if (stringValue.match(pattern))
 278 javascript      code            results.push((iterator || Prototype.K)(value, index));
 279 javascript      code        })
 280 javascript      code        return results;
 281 javascript      code      },
 282 javascript      blank
 283 javascript      code      include: function(object) {
 284 javascript      code        var found = false;
 285 javascript      code        this.each(function(value) {
 286 javascript      code          if (value == object) {
 287 javascript      code            found = true;
 288 javascript      code            throw $break;
 289 javascript      code          }
 290 javascript      code        });
 291 javascript      code        return found;
 292 javascript      code      },
 293 javascript      blank
 294 javascript      code      inject: function(memo, iterator) {
 295 javascript      code        this.each(function(value, index) {
 296 javascript      code          memo = iterator(memo, value, index);
 297 javascript      code        });
 298 javascript      code        return memo;
 299 javascript      code      },
 300 javascript      blank
 301 javascript      code      invoke: function(method) {
 302 javascript      code        var args = $A(arguments).slice(1);
 303 javascript      code        return this.collect(function(value) {
 304 javascript      code          return value[method].apply(value, args);
 305 javascript      code        });
 306 javascript      code      },
 307 javascript      blank
 308 javascript      code      max: function(iterator) {
 309 javascript      code        var result;
 310 javascript      code        this.each(function(value, index) {
 311 javascript      code          value = (iterator || Prototype.K)(value, index);
 312 javascript      code          if (value >= (result || value))
 313 javascript      code            result = value;
 314 javascript      code        });
 315 javascript      code        return result;
 316 javascript      code      },
 317 javascript      blank
 318 javascript      code      min: function(iterator) {
 319 javascript      code        var result;
 320 javascript      code        this.each(function(value, index) {
 321 javascript      code          value = (iterator || Prototype.K)(value, index);
 322 javascript      code          if (value <= (result || value))
 323 javascript      code            result = value;
 324 javascript      code        });
 325 javascript      code        return result;
 326 javascript      code      },
 327 javascript      blank
 328 javascript      code      partition: function(iterator) {
 329 javascript      code        var trues = [], falses = [];
 330 javascript      code        this.each(function(value, index) {
 331 javascript      code          ((iterator || Prototype.K)(value, index) ?
 332 javascript      code            trues : falses).push(value);
 333 javascript      code        });
 334 javascript      code        return [trues, falses];
 335 javascript      code      },
 336 javascript      blank
 337 javascript      code      pluck: function(property) {
 338 javascript      code        var results = [];
 339 javascript      code        this.each(function(value, index) {
 340 javascript      code          results.push(value[property]);
 341 javascript      code        });
 342 javascript      code        return results;
 343 javascript      code      },
 344 javascript      blank
 345 javascript      code      reject: function(iterator) {
 346 javascript      code        var results = [];
 347 javascript      code        this.each(function(value, index) {
 348 javascript      code          if (!iterator(value, index))
 349 javascript      code            results.push(value);
 350 javascript      code        });
 351 javascript      code        return results;
 352 javascript      code      },
 353 javascript      blank
 354 javascript      code      sortBy: function(iterator) {
 355 javascript      code        return this.collect(function(value, index) {
 356 javascript      code          return {value: value, criteria: iterator(value, index)};
 357 javascript      code        }).sort(function(left, right) {
 358 javascript      code          var a = left.criteria, b = right.criteria;
 359 javascript      code          return a < b ? -1 : a > b ? 1 : 0;
 360 javascript      code        }).pluck('value');
 361 javascript      code      },
 362 javascript      blank
 363 javascript      code      toArray: function() {
 364 javascript      code        return this.collect(Prototype.K);
 365 javascript      code      },
 366 javascript      blank
 367 javascript      code      zip: function() {
 368 javascript      code        var iterator = Prototype.K, args = $A(arguments);
 369 javascript      code        if (typeof args.last() == 'function')
 370 javascript      code          iterator = args.pop();
 371 javascript      blank
 372 javascript      code        var collections = [this].concat(args).map($A);
 373 javascript      code        return this.map(function(value, index) {
 374 javascript      code          iterator(value = collections.pluck(index));
 375 javascript      code          return value;
 376 javascript      code        });
 377 javascript      code      },
 378 javascript      blank
 379 javascript      code      inspect: function() {
 380 javascript      code        return '#<Enumerable:' + this.toArray().inspect() + '>';
 381 javascript      code      }
 382 javascript      code    }
 383 javascript      blank
 384 javascript      code    Object.extend(Enumerable, {
 385 javascript      code      map:     Enumerable.collect,
 386 javascript      code      find:    Enumerable.detect,
 387 javascript      code      select:  Enumerable.findAll,
 388 javascript      code      member:  Enumerable.include,
 389 javascript      code      entries: Enumerable.toArray
 390 javascript      code    });
 391 javascript      code    var $A = Array.from = function(iterable) {
 392 javascript      code      if (!iterable) return [];
 393 javascript      code      if (iterable.toArray) {
 394 javascript      code        return iterable.toArray();
 395 javascript      code      } else {
 396 javascript      code        var results = [];
 397 javascript      code        for (var i = 0; i < iterable.length; i++)
 398 javascript      code          results.push(iterable[i]);
 399 javascript      code        return results;
 400 javascript      code      }
 401 javascript      code    }
 402 javascript      blank
 403 javascript      code    Object.extend(Array.prototype, Enumerable);
 404 javascript      blank
 405 javascript      code    Array.prototype._reverse = Array.prototype.reverse;
 406 javascript      blank
 407 javascript      code    Object.extend(Array.prototype, {
 408 javascript      code      _each: function(iterator) {
 409 javascript      code        for (var i = 0; i < this.length; i++)
 410 javascript      code          iterator(this[i]);
 411 javascript      code      },
 412 javascript      blank
 413 javascript      code      clear: function() {
 414 javascript      code        this.length = 0;
 415 javascript      code        return this;
 416 javascript      code      },
 417 javascript      blank
 418 javascript      code      first: function() {
 419 javascript      code        return this[0];
 420 javascript      code      },
 421 javascript      blank
 422 javascript      code      last: function() {
 423 javascript      code        return this[this.length - 1];
 424 javascript      code      },
 425 javascript      blank
 426 javascript      code      compact: function() {
 427 javascript      code        return this.select(function(value) {
 428 javascript      code          return value != undefined || value != null;
 429 javascript      code        });
 430 javascript      code      },
 431 javascript      blank
 432 javascript      code      flatten: function() {
 433 javascript      code        return this.inject([], function(array, value) {
 434 javascript      code          return array.concat(value.constructor == Array ?
 435 javascript      code            value.flatten() : [value]);
 436 javascript      code        });
 437 javascript      code      },
 438 javascript      blank
 439 javascript      code      without: function() {
 440 javascript      code        var values = $A(arguments);
 441 javascript      code        return this.select(function(value) {
 442 javascript      code          return !values.include(value);
 443 javascript      code        });
 444 javascript      code      },
 445 javascript      blank
 446 javascript      code      indexOf: function(object) {
 447 javascript      code        for (var i = 0; i < this.length; i++)
 448 javascript      code          if (this[i] == object) return i;
 449 javascript      code        return -1;
 450 javascript      code      },
 451 javascript      blank
 452 javascript      code      reverse: function(inline) {
 453 javascript      code        return (inline !== false ? this : this.toArray())._reverse();
 454 javascript      code      },
 455 javascript      blank
 456 javascript      code      shift: function() {
 457 javascript      code        var result = this[0];
 458 javascript      code        for (var i = 0; i < this.length - 1; i++)
 459 javascript      code          this[i] = this[i + 1];
 460 javascript      code        this.length--;
 461 javascript      code        return result;
 462 javascript      code      },
 463 javascript      blank
 464 javascript      code      inspect: function() {
 465 javascript      code        return '[' + this.map(Object.inspect).join(', ') + ']';
 466 javascript      code      }
 467 javascript      code    });
 468 javascript      code    var Hash = {
 469 javascript      code      _each: function(iterator) {
 470 javascript      code        for (key in this) {
 471 javascript      code          var value = this[key];
 472 javascript      code          if (typeof value == 'function') continue;
 473 javascript      blank
 474 javascript      code          var pair = [key, value];
 475 javascript      code          pair.key = key;
 476 javascript      code          pair.value = value;
 477 javascript      code          iterator(pair);
 478 javascript      code        }
 479 javascript      code      },
 480 javascript      blank
 481 javascript      code      keys: function() {
 482 javascript      code        return this.pluck('key');
 483 javascript      code      },
 484 javascript      blank
 485 javascript      code      values: function() {
 486 javascript      code        return this.pluck('value');
 487 javascript      code      },
 488 javascript      blank
 489 javascript      code      merge: function(hash) {
 490 javascript      code        return $H(hash).inject($H(this), function(mergedHash, pair) {
 491 javascript      code          mergedHash[pair.key] = pair.value;
 492 javascript      code          return mergedHash;
 493 javascript      code        });
 494 javascript      code      },
 495 javascript      blank
 496 javascript      code      toQueryString: function() {
 497 javascript      code        return this.map(function(pair) {
 498 javascript      code          return pair.map(encodeURIComponent).join('=');
 499 javascript      code        }).join('&');
 500 javascript      code      },
 501 javascript      blank
 502 javascript      code      inspect: function() {
 503 javascript      code        return '#<Hash:{' + this.map(function(pair) {
 504 javascript      code          return pair.map(Object.inspect).join(': ');
 505 javascript      code        }).join(', ') + '}>';
 506 javascript      code      }
 507 javascript      code    }
 508 javascript      blank
 509 javascript      code    function $H(object) {
 510 javascript      code      var hash = Object.extend({}, object || {});
 511 javascript      code      Object.extend(hash, Enumerable);
 512 javascript      code      Object.extend(hash, Hash);
 513 javascript      code      return hash;
 514 javascript      code    }
 515 javascript      code    ObjectRange = Class.create();
 516 javascript      code    Object.extend(ObjectRange.prototype, Enumerable);
 517 javascript      code    Object.extend(ObjectRange.prototype, {
 518 javascript      code      initialize: function(start, end, exclusive) {
 519 javascript      code        this.start = start;
 520 javascript      code        this.end = end;
 521 javascript      code        this.exclusive = exclusive;
 522 javascript      code      },
 523 javascript      blank
 524 javascript      code      _each: function(iterator) {
 525 javascript      code        var value = this.start;
 526 javascript      code        do {
 527 javascript      code          iterator(value);
 528 javascript      code          value = value.succ();
 529 javascript      code        } while (this.include(value));
 530 javascript      code      },
 531 javascript      blank
 532 javascript      code      include: function(value) {
 533 javascript      code        if (value < this.start)
 534 javascript      code          return false;
 535 javascript      code        if (this.exclusive)
 536 javascript      code          return value < this.end;
 537 javascript      code        return value <= this.end;
 538 javascript      code      }
 539 javascript      code    });
 540 javascript      blank
 541 javascript      code    var $R = function(start, end, exclusive) {
 542 javascript      code      return new ObjectRange(start, end, exclusive);
 543 javascript      code    }
 544 javascript      blank
 545 javascript      code    var Ajax = {
 546 javascript      code      getTransport: function() {
 547 javascript      code        return Try.these(
 548 javascript      code          function() {return new ActiveXObject('Msxml2.XMLHTTP')},
 549 javascript      code          function() {return new ActiveXObject('Microsoft.XMLHTTP')},
 550 javascript      code          function() {return new XMLHttpRequest()}
 551 javascript      code        ) || false;
 552 javascript      code      },
 553 javascript      blank
 554 javascript      code      activeRequestCount: 0
 555 javascript      code    }
 556 javascript      blank
 557 javascript      code    Ajax.Responders = {
 558 javascript      code      responders: [],
 559 javascript      blank
 560 javascript      code      _each: function(iterator) {
 561 javascript      code        this.responders._each(iterator);
 562 javascript      code      },
 563 javascript      blank
 564 javascript      code      register: function(responderToAdd) {
 565 javascript      code        if (!this.include(responderToAdd))
 566 javascript      code          this.responders.push(responderToAdd);
 567 javascript      code      },
 568 javascript      blank
 569 javascript      code      unregister: function(responderToRemove) {
 570 javascript      code        this.responders = this.responders.without(responderToRemove);
 571 javascript      code      },
 572 javascript      blank
 573 javascript      code      dispatch: function(callback, request, transport, json) {
 574 javascript      code        this.each(function(responder) {
 575 javascript      code          if (responder[callback] && typeof responder[callback] == 'function') {
 576 javascript      code            try {
 577 javascript      code              responder[callback].apply(responder, [request, transport, json]);
 578 javascript      code            } catch (e) {}
 579 javascript      code          }
 580 javascript      code        });
 581 javascript      code      }
 582 javascript      code    };
 583 javascript      blank
 584 javascript      code    Object.extend(Ajax.Responders, Enumerable);
 585 javascript      blank
 586 javascript      code    Ajax.Responders.register({
 587 javascript      code      onCreate: function() {
 588 javascript      code        Ajax.activeRequestCount++;
 589 javascript      code      },
 590 javascript      blank
 591 javascript      code      onComplete: function() {
 592 javascript      code        Ajax.activeRequestCount--;
 593 javascript      code      }
 594 javascript      code    });
 595 javascript      blank
 596 javascript      code    Ajax.Base = function() {};
 597 javascript      code    Ajax.Base.prototype = {
 598 javascript      code      setOptions: function(options) {
 599 javascript      code        this.options = {
 600 javascript      code          method:       'post',
 601 javascript      code          asynchronous: true,
 602 javascript      code          parameters:   ''
 603 javascript      code        }
 604 javascript      code        Object.extend(this.options, options || {});
 605 javascript      code      },
 606 javascript      blank
 607 javascript      code      responseIsSuccess: function() {
 608 javascript      code        return this.transport.status == undefined
 609 javascript      code            || this.transport.status == 0
 610 javascript      code            || (this.transport.status >= 200 && this.transport.status < 300);
 611 javascript      code      },
 612 javascript      blank
 613 javascript      code      responseIsFailure: function() {
 614 javascript      code        return !this.responseIsSuccess();
 615 javascript      code      }
 616 javascript      code    }
 617 javascript      blank
 618 javascript      code    Ajax.Request = Class.create();
 619 javascript      code    Ajax.Request.Events =
 620 javascript      code      ['Uninitialized', 'Loading', 'Loaded', 'Interactive', 'Complete'];
 621 javascript      blank
 622 javascript      code    Ajax.Request.prototype = Object.extend(new Ajax.Base(), {
 623 javascript      code      initialize: function(url, options) {
 624 javascript      code        this.transport = Ajax.getTransport();
 625 javascript      code        this.setOptions(options);
 626 javascript      code        this.request(url);
 627 javascript      code      },
 628 javascript      blank
 629 javascript      code      request: function(url) {
 630 javascript      code        var parameters = this.options.parameters || '';
 631 javascript      code        if (parameters.length > 0) parameters += '&_=';
 632 javascript      blank
 633 javascript      code        try {
 634 javascript      code          this.url = url;
 635 javascript      code          if (this.options.method == 'get' && parameters.length > 0)
 636 javascript      code            this.url += (this.url.match(/\?/) ? '&' : '?') + parameters;
 637 javascript      blank
 638 javascript      code          Ajax.Responders.dispatch('onCreate', this, this.transport);
 639 javascript      blank
 640 javascript      code          this.transport.open(this.options.method, this.url,
 641 javascript      code            this.options.asynchronous);
 642 javascript      blank
 643 javascript      code          if (this.options.asynchronous) {
 644 javascript      code            this.transport.onreadystatechange = this.onStateChange.bind(this);
 645 javascript      code            setTimeout((function() {this.respondToReadyState(1)}).bind(this), 10);
 646 javascript      code          }
 647 javascript      blank
 648 javascript      code          this.setRequestHeaders();
 649 javascript      blank
 650 javascript      code          var body = this.options.postBody ? this.options.postBody : parameters;
 651 javascript      code          this.transport.send(this.options.method == 'post' ? body : null);
 652 javascript      blank
 653 javascript      code        } catch (e) {
 654 javascript      code          this.dispatchException(e);
 655 javascript      code        }
 656 javascript      code      },
 657 javascript      blank
 658 javascript      code      setRequestHeaders: function() {
 659 javascript      code        var requestHeaders =
 660 javascript      code          ['X-Requested-With', 'XMLHttpRequest',
 661 javascript      code           'X-Prototype-Version', Prototype.Version];
 662 javascript      blank
 663 javascript      code        if (this.options.method == 'post') {
 664 javascript      code          requestHeaders.push('Content-type',
 665 javascript      code            'application/x-www-form-urlencoded');
 666 javascript      blank
 667 javascript      comment       /* Force "Connection: close" for Mozilla browsers to work around
 668 javascript      comment        * a bug where XMLHttpReqeuest sends an incorrect Content-length
 669 javascript      comment        * header. See Mozilla Bugzilla #246651.
 670 javascript      comment        */
 671 javascript      code          if (this.transport.overrideMimeType)
 672 javascript      code            requestHeaders.push('Connection', 'close');
 673 javascript      code        }
 674 javascript      blank
 675 javascript      code        if (this.options.requestHeaders)
 676 javascript      code          requestHeaders.push.apply(requestHeaders, this.options.requestHeaders);
 677 javascript      blank
 678 javascript      code        for (var i = 0; i < requestHeaders.length; i += 2)
 679 javascript      code          this.transport.setRequestHeader(requestHeaders[i], requestHeaders[i+1]);
 680 javascript      code      },
 681 javascript      blank
 682 javascript      code      onStateChange: function() {
 683 javascript      code        var readyState = this.transport.readyState;
 684 javascript      code        if (readyState != 1)
 685 javascript      code          this.respondToReadyState(this.transport.readyState);
 686 javascript      code      },
 687 javascript      blank
 688 javascript      code      header: function(name) {
 689 javascript      code        try {
 690 javascript      code          return this.transport.getResponseHeader(name);
 691 javascript      code        } catch (e) {}
 692 javascript      code      },
 693 javascript      blank
 694 javascript      code      evalJSON: function() {
 695 javascript      code        try {
 696 javascript      code          return eval(this.header('X-JSON'));
 697 javascript      code        } catch (e) {}
 698 javascript      code      },
 699 javascript      blank
 700 javascript      code      evalResponse: function() {
 701 javascript      code        try {
 702 javascript      code          return eval(this.transport.responseText);
 703 javascript      code        } catch (e) {
 704 javascript      code          this.dispatchException(e);
 705 javascript      code        }
 706 javascript      code      },
 707 javascript      blank
 708 javascript      code      respondToReadyState: function(readyState) {
 709 javascript      code        var event = Ajax.Request.Events[readyState];
 710 javascript      code        var transport = this.transport, json = this.evalJSON();
 711 javascript      blank
 712 javascript      code        if (event == 'Complete') {
 713 javascript      code          try {
 714 javascript      code            (this.options['on' + this.transport.status]
 715 javascript      code             || this.options['on' + (this.responseIsSuccess() ? 'Success' : 'Failure')]
 716 javascript      code             || Prototype.emptyFunction)(transport, json);
 717 javascript      code          } catch (e) {
 718 javascript      code            this.dispatchException(e);
 719 javascript      code          }
 720 javascript      blank
 721 javascript      code          if ((this.header('Content-type') || '').match(/^text\/javascript/i))
 722 javascript      code            this.evalResponse();
 723 javascript      code        }
 724 javascript      blank
 725 javascript      code        try {
 726 javascript      code          (this.options['on' + event] || Prototype.emptyFunction)(transport, json);
 727 javascript      code          Ajax.Responders.dispatch('on' + event, this, transport, json);
 728 javascript      code        } catch (e) {
 729 javascript      code          this.dispatchException(e);
 730 javascript      code        }
 731 javascript      blank
 732 javascript      comment     /* Avoid memory leak in MSIE: clean up the oncomplete event handler */
 733 javascript      code        if (event == 'Complete')
 734 javascript      code          this.transport.onreadystatechange = Prototype.emptyFunction;
 735 javascript      code      },
 736 javascript      blank
 737 javascript      code      dispatchException: function(exception) {
 738 javascript      code        (this.options.onException || Prototype.emptyFunction)(this, exception);
 739 javascript      code        Ajax.Responders.dispatch('onException', this, exception);
 740 javascript      code      }
 741 javascript      code    });
 742 javascript      blank
 743 javascript      code    Ajax.Updater = Class.create();
 744 javascript      blank
 745 javascript      code    Object.extend(Object.extend(Ajax.Updater.prototype, Ajax.Request.prototype), {
 746 javascript      code      initialize: function(container, url, options) {
 747 javascript      code        this.containers = {
 748 javascript      code          success: container.success ? $(container.success) : $(container),
 749 javascript      code          failure: container.failure ? $(container.failure) :
 750 javascript      code            (container.success ? null : $(container))
 751 javascript      code        }
 752 javascript      blank
 753 javascript      code        this.transport = Ajax.getTransport();
 754 javascript      code        this.setOptions(options);
 755 javascript      blank
 756 javascript      code        var onComplete = this.options.onComplete || Prototype.emptyFunction;
 757 javascript      code        this.options.onComplete = (function(transport, object) {
 758 javascript      code          this.updateContent();
 759 javascript      code          onComplete(transport, object);
 760 javascript      code        }).bind(this);
 761 javascript      blank
 762 javascript      code        this.request(url);
 763 javascript      code      },
 764 javascript      blank
 765 javascript      code      updateContent: function() {
 766 javascript      code        var receiver = this.responseIsSuccess() ?
 767 javascript      code          this.containers.success : this.containers.failure;
 768 javascript      code        var response = this.transport.responseText;
 769 javascript      blank
 770 javascript      code        if (!this.options.evalScripts)
 771 javascript      code          response = response.stripScripts();
 772 javascript      blank
 773 javascript      code        if (receiver) {
 774 javascript      code          if (this.options.insertion) {
 775 javascript      code            new this.options.insertion(receiver, response);
 776 javascript      code          } else {
 777 javascript      code            Element.update(receiver, response);
 778 javascript      code          }
 779 javascript      code        }
 780 javascript      blank
 781 javascript      code        if (this.responseIsSuccess()) {
 782 javascript      code          if (this.onComplete)
 783 javascript      code            setTimeout(this.onComplete.bind(this), 10);
 784 javascript      code        }
 785 javascript      code      }
 786 javascript      code    });
 787 javascript      blank
 788 javascript      code    Ajax.PeriodicalUpdater = Class.create();
 789 javascript      code    Ajax.PeriodicalUpdater.prototype = Object.extend(new Ajax.Base(), {
 790 javascript      code      initialize: function(container, url, options) {
 791 javascript      code        this.setOptions(options);
 792 javascript      code        this.onComplete = this.options.onComplete;
 793 javascript      blank
 794 javascript      code        this.frequency = (this.options.frequency || 2);
 795 javascript      code        this.decay = (this.options.decay || 1);
 796 javascript      blank
 797 javascript      code        this.updater = {};
 798 javascript      code        this.container = container;
 799 javascript      code        this.url = url;
 800 javascript      blank
 801 javascript      code        this.start();
 802 javascript      code      },
 803 javascript      blank
 804 javascript      code      start: function() {
 805 javascript      code        this.options.onComplete = this.updateComplete.bind(this);
 806 javascript      code        this.onTimerEvent();
 807 javascript      code      },
 808 javascript      blank
 809 javascript      code      stop: function() {
 810 javascript      code        this.updater.onComplete = undefined;
 811 javascript      code        clearTimeout(this.timer);
 812 javascript      code        (this.onComplete || Prototype.emptyFunction).apply(this, arguments);
 813 javascript      code      },
 814 javascript      blank
 815 javascript      code      updateComplete: function(request) {
 816 javascript      code        if (this.options.decay) {
 817 javascript      code          this.decay = (request.responseText == this.lastText ?
 818 javascript      code            this.decay * this.options.decay : 1);
 819 javascript      blank
 820 javascript      code          this.lastText = request.responseText;
 821 javascript      code        }
 822 javascript      code        this.timer = setTimeout(this.onTimerEvent.bind(this),
 823 javascript      code          this.decay * this.frequency * 1000);
 824 javascript      code      },
 825 javascript      blank
 826 javascript      code      onTimerEvent: function() {
 827 javascript      code        this.updater = new Ajax.Updater(this.container, this.url, this.options);
 828 javascript      code      }
 829 javascript      code    });
 830 javascript      code    document.getElementsByClassName = function(className, parentElement) {
 831 javascript      code      var children = ($(parentElement) || document.body).getElementsByTagName('*');
 832 javascript      code      return $A(children).inject([], function(elements, child) {
 833 javascript      code        if (child.className.match(new RegExp("(^|\\s)" + className + "(\\s|$)")))
 834 javascript      code          elements.push(child);
 835 javascript      code        return elements;
 836 javascript      code      });
 837 javascript      code    }
 838 javascript      blank
 839 javascript      comment /*--------------------------------------------------------------------------*/
 840 javascript      blank
 841 javascript      code    if (!window.Element) {
 842 javascript      code      var Element = new Object();
 843 javascript      code    }
 844 javascript      blank
 845 javascript      code    Object.extend(Element, {
 846 javascript      code      visible: function(element) {
 847 javascript      code        return $(element).style.display != 'none';
 848 javascript      code      },
 849 javascript      blank
 850 javascript      code      toggle: function() {
 851 javascript      code        for (var i = 0; i < arguments.length; i++) {
 852 javascript      code          var element = $(arguments[i]);
 853 javascript      code          Element[Element.visible(element) ? 'hide' : 'show'](element);
 854 javascript      code        }
 855 javascript      code      },
 856 javascript      blank
 857 javascript      code      hide: function() {
 858 javascript      code        for (var i = 0; i < arguments.length; i++) {
 859 javascript      code          var element = $(arguments[i]);
 860 javascript      code          element.style.display = 'none';
 861 javascript      code        }
 862 javascript      code      },
 863 javascript      blank
 864 javascript      code      show: function() {
 865 javascript      code        for (var i = 0; i < arguments.length; i++) {
 866 javascript      code          var element = $(arguments[i]);
 867 javascript      code          element.style.display = '';
 868 javascript      code        }
 869 javascript      code      },
 870 javascript      blank
 871 javascript      code      remove: function(element) {
 872 javascript      code        element = $(element);
 873 javascript      code        element.parentNode.removeChild(element);
 874 javascript      code      },
 875 javascript      blank
 876 javascript      code      update: function(element, html) {
 877 javascript      code        $(element).innerHTML = html.stripScripts();
 878 javascript      code        setTimeout(function() {html.evalScripts()}, 10);
 879 javascript      code      },
 880 javascript      blank
 881 javascript      code      getHeight: function(element) {
 882 javascript      code        element = $(element);
 883 javascript      code        return element.offsetHeight;
 884 javascript      code      },
 885 javascript      blank
 886 javascript      code      classNames: function(element) {
 887 javascript      code        return new Element.ClassNames(element);
 888 javascript      code      },
 889 javascript      blank
 890 javascript      code      hasClassName: function(element, className) {
 891 javascript      code        if (!(element = $(element))) return;
 892 javascript      code        return Element.classNames(element).include(className);
 893 javascript      code      },
 894 javascript      blank
 895 javascript      code      addClassName: function(element, className) {
 896 javascript      code        if (!(element = $(element))) return;
 897 javascript      code        return Element.classNames(element).add(className);
 898 javascript      code      },
 899 javascript      blank
 900 javascript      code      removeClassName: function(element, className) {
 901 javascript      code        if (!(element = $(element))) return;
 902 javascript      code        return Element.classNames(element).remove(className);
 903 javascript      code      },
 904 javascript      blank
 905 javascript      comment   // removes whitespace-only text node children
 906 javascript      code      cleanWhitespace: function(element) {
 907 javascript      code        element = $(element);
 908 javascript      code        for (var i = 0; i < element.childNodes.length; i++) {
 909 javascript      code          var node = element.childNodes[i];
 910 javascript      code          if (node.nodeType == 3 && !/\S/.test(node.nodeValue))
 911 javascript      code            Element.remove(node);
 912 javascript      code        }
 913 javascript      code      },
 914 javascript      blank
 915 javascript      code      empty: function(element) {
 916 javascript      code        return $(element).innerHTML.match(/^\s*$/);
 917 javascript      code      },
 918 javascript      blank
 919 javascript      code      scrollTo: function(element) {
 920 javascript      code        element = $(element);
 921 javascript      code        var x = element.x ? element.x : element.offsetLeft,
 922 javascript      code            y = element.y ? element.y : element.offsetTop;
 923 javascript      code        window.scrollTo(x, y);
 924 javascript      code      },
 925 javascript      blank
 926 javascript      code      getStyle: function(element, style) {
 927 javascript      code        element = $(element);
 928 javascript      code        var value = element.style[style.camelize()];
 929 javascript      code        if (!value) {
 930 javascript      code          if (document.defaultView && document.defaultView.getComputedStyle) {
 931 javascript      code            var css = document.defaultView.getComputedStyle(element, null);
 932 javascript      code            value = css ? css.getPropertyValue(style) : null;
 933 javascript      code          } else if (element.currentStyle) {
 934 javascript      code            value = element.currentStyle[style.camelize()];
 935 javascript      code          }
 936 javascript      code        }
 937 javascript      blank
 938 javascript      code        if (window.opera && ['left', 'top', 'right', 'bottom'].include(style))
 939 javascript      code          if (Element.getStyle(element, 'position') == 'static') value = 'auto';
 940 javascript      blank
 941 javascript      code        return value == 'auto' ? null : value;
 942 javascript      code      },
 943 javascript      blank
 944 javascript      code      setStyle: function(element, style) {
 945 javascript      code        element = $(element);
 946 javascript      code        for (name in style)
 947 javascript      code          element.style[name.camelize()] = style[name];
 948 javascript      code      },
 949 javascript      blank
 950 javascript      code      getDimensions: function(element) {
 951 javascript      code        element = $(element);
 952 javascript      code        if (Element.getStyle(element, 'display') != 'none')
 953 javascript      code          return {width: element.offsetWidth, height: element.offsetHeight};
 954 javascript      blank
 955 javascript      comment     // All *Width and *Height properties give 0 on elements with display none,
 956 javascript      comment     // so enable the element temporarily
 957 javascript      code        var els = element.style;
 958 javascript      code        var originalVisibility = els.visibility;
 959 javascript      code        var originalPosition = els.position;
 960 javascript      code        els.visibility = 'hidden';
 961 javascript      code        els.position = 'absolute';
 962 javascript      code        els.display = '';
 963 javascript      code        var originalWidth = element.clientWidth;
 964 javascript      code        var originalHeight = element.clientHeight;
 965 javascript      code        els.display = 'none';
 966 javascript      code        els.position = originalPosition;
 967 javascript      code        els.visibility = originalVisibility;
 968 javascript      code        return {width: originalWidth, height: originalHeight};
 969 javascript      code      },
 970 javascript      blank
 971 javascript      code      makePositioned: function(element) {
 972 javascript      code        element = $(element);
 973 javascript      code        var pos = Element.getStyle(element, 'position');
 974 javascript      code        if (pos == 'static' || !pos) {
 975 javascript      code          element._madePositioned = true;
 976 javascript      code          element.style.position = 'relative';
 977 javascript      comment       // Opera returns the offset relative to the positioning context, when an
 978 javascript      comment       // element is position relative but top and left have not been defined
 979 javascript      code          if (window.opera) {
 980 javascript      code            element.style.top = 0;
 981 javascript      code            element.style.left = 0;
 982 javascript      code          }
 983 javascript      code        }
 984 javascript      code      },
 985 javascript      blank
 986 javascript      code      undoPositioned: function(element) {
 987 javascript      code        element = $(element);
 988 javascript      code        if (element._madePositioned) {
 989 javascript      code          element._madePositioned = undefined;
 990 javascript      code          element.style.position =
 991 javascript      code            element.style.top =
 992 javascript      code            element.style.left =
 993 javascript      code            element.style.bottom =
 994 javascript      code            element.style.right = '';
 995 javascript      code        }
 996 javascript      code      },
 997 javascript      blank
 998 javascript      code      makeClipping: function(element) {
 999 javascript      code        element = $(element);
1000 javascript      code        if (element._overflow) return;
1001 javascript      code        element._overflow = element.style.overflow;
1002 javascript      code        if ((Element.getStyle(element, 'overflow') || 'visible') != 'hidden')
1003 javascript      code          element.style.overflow = 'hidden';
1004 javascript      code      },
1005 javascript      blank
1006 javascript      code      undoClipping: function(element) {
1007 javascript      code        element = $(element);
1008 javascript      code        if (element._overflow) return;
1009 javascript      code        element.style.overflow = element._overflow;
1010 javascript      code        element._overflow = undefined;
1011 javascript      code      }
1012 javascript      code    });
1013 javascript      blank
1014 javascript      code    var Toggle = new Object();
1015 javascript      code    Toggle.display = Element.toggle;
1016 javascript      blank
1017 javascript      comment /*--------------------------------------------------------------------------*/
1018 javascript      blank
1019 javascript      code    Abstract.Insertion = function(adjacency) {
1020 javascript      code      this.adjacency = adjacency;
1021 javascript      code    }
1022 javascript      blank
1023 javascript      code    Abstract.Insertion.prototype = {
1024 javascript      code      initialize: function(element, content) {
1025 javascript      code        this.element = $(element);
1026 javascript      code        this.content = content.stripScripts();
1027 javascript      blank
1028 javascript      code        if (this.adjacency && this.element.insertAdjacentHTML) {
1029 javascript      code          try {
1030 javascript      code            this.element.insertAdjacentHTML(this.adjacency, this.content);
1031 javascript      code          } catch (e) {
1032 javascript      code            if (this.element.tagName.toLowerCase() == 'tbody') {
1033 javascript      code              this.insertContent(this.contentFromAnonymousTable());
1034 javascript      code            } else {
1035 javascript      code              throw e;
1036 javascript      code            }
1037 javascript      code          }
1038 javascript      code        } else {
1039 javascript      code          this.range = this.element.ownerDocument.createRange();
1040 javascript      code          if (this.initializeRange) this.initializeRange();
1041 javascript      code          this.insertContent([this.range.createContextualFragment(this.content)]);
1042 javascript      code        }
1043 javascript      blank
1044 javascript      code        setTimeout(function() {content.evalScripts()}, 10);
1045 javascript      code      },
1046 javascript      blank
1047 javascript      code      contentFromAnonymousTable: function() {
1048 javascript      code        var div = document.createElement('div');
1049 javascript      code        div.innerHTML = '<table><tbody>' + this.content + '</tbody></table>';
1050 javascript      code        return $A(div.childNodes[0].childNodes[0].childNodes);
1051 javascript      code      }
1052 javascript      code    }
1053 javascript      blank
1054 javascript      code    var Insertion = new Object();
1055 javascript      blank
1056 javascript      code    Insertion.Before = Class.create();
1057 javascript      code    Insertion.Before.prototype = Object.extend(new Abstract.Insertion('beforeBegin'), {
1058 javascript      code      initializeRange: function() {
1059 javascript      code        this.range.setStartBefore(this.element);
1060 javascript      code      },
1061 javascript      blank
1062 javascript      code      insertContent: function(fragments) {
1063 javascript      code        fragments.each((function(fragment) {
1064 javascript      code          this.element.parentNode.insertBefore(fragment, this.element);
1065 javascript      code        }).bind(this));
1066 javascript      code      }
1067 javascript      code    });
1068 javascript      blank
1069 javascript      code    Insertion.Top = Class.create();
1070 javascript      code    Insertion.Top.prototype = Object.extend(new Abstract.Insertion('afterBegin'), {
1071 javascript      code      initializeRange: function() {
1072 javascript      code        this.range.selectNodeContents(this.element);
1073 javascript      code        this.range.collapse(true);
1074 javascript      code      },
1075 javascript      blank
1076 javascript      code      insertContent: function(fragments) {
1077 javascript      code        fragments.reverse(false).each((function(fragment) {
1078 javascript      code          this.element.insertBefore(fragment, this.element.firstChild);
1079 javascript      code        }).bind(this));
1080 javascript      code      }
1081 javascript      code    });
1082 javascript      blank
1083 javascript      code    Insertion.Bottom = Class.create();
1084 javascript      code    Insertion.Bottom.prototype = Object.extend(new Abstract.Insertion('beforeEnd'), {
1085 javascript      code      initializeRange: function() {
1086 javascript      code        this.range.selectNodeContents(this.element);
1087 javascript      code        this.range.collapse(this.element);
1088 javascript      code      },
1089 javascript      blank
1090 javascript      code      insertContent: function(fragments) {
1091 javascript      code        fragments.each((function(fragment) {
1092 javascript      code          this.element.appendChild(fragment);
1093 javascript      code        }).bind(this));
1094 javascript      code      }
1095 javascript      code    });
1096 javascript      blank
1097 javascript      code    Insertion.After = Class.create();
1098 javascript      code    Insertion.After.prototype = Object.extend(new Abstract.Insertion('afterEnd'), {
1099 javascript      code      initializeRange: function() {
1100 javascript      code        this.range.setStartAfter(this.element);
1101 javascript      code      },
1102 javascript      blank
1103 javascript      code      insertContent: function(fragments) {
1104 javascript      code        fragments.each((function(fragment) {
1105 javascript      code          this.element.parentNode.insertBefore(fragment,
1106 javascript      code            this.element.nextSibling);
1107 javascript      code        }).bind(this));
1108 javascript      code      }
1109 javascript      code    });
1110 javascript      blank
1111 javascript      comment /*--------------------------------------------------------------------------*/
1112 javascript      blank
1113 javascript      code    Element.ClassNames = Class.create();
1114 javascript      code    Element.ClassNames.prototype = {
1115 javascript      code      initialize: function(element) {
1116 javascript      code        this.element = $(element);
1117 javascript      code      },
1118 javascript      blank
1119 javascript      code      _each: function(iterator) {
1120 javascript      code        this.element.className.split(/\s+/).select(function(name) {
1121 javascript      code          return name.length > 0;
1122 javascript      code        })._each(iterator);
1123 javascript      code      },
1124 javascript      blank
1125 javascript      code      set: function(className) {
1126 javascript      code        this.element.className = className;
1127 javascript      code      },
1128 javascript      blank
1129 javascript      code      add: function(classNameToAdd) {
1130 javascript      code        if (this.include(classNameToAdd)) return;
1131 javascript      code        this.set(this.toArray().concat(classNameToAdd).join(' '));
1132 javascript      code      },
1133 javascript      blank
1134 javascript      code      remove: function(classNameToRemove) {
1135 javascript      code        if (!this.include(classNameToRemove)) return;
1136 javascript      code        this.set(this.select(function(className) {
1137 javascript      code          return className != classNameToRemove;
1138 javascript      code        }).join(' '));
1139 javascript      code      },
1140 javascript      blank
1141 javascript      code      toString: function() {
1142 javascript      code        return this.toArray().join(' ');
1143 javascript      code      }
1144 javascript      code    }
1145 javascript      blank
1146 javascript      code    Object.extend(Element.ClassNames.prototype, Enumerable);
1147 javascript      code    var Field = {
1148 javascript      code      clear: function() {
1149 javascript      code        for (var i = 0; i < arguments.length; i++)
1150 javascript      code          $(arguments[i]).value = '';
1151 javascript      code      },
1152 javascript      blank
1153 javascript      code      focus: function(element) {
1154 javascript      code        $(element).focus();
1155 javascript      code      },
1156 javascript      blank
1157 javascript      code      present: function() {
1158 javascript      code        for (var i = 0; i < arguments.length; i++)
1159 javascript      code          if ($(arguments[i]).value == '') return false;
1160 javascript      code        return true;
1161 javascript      code      },
1162 javascript      blank
1163 javascript      code      select: function(element) {
1164 javascript      code        $(element).select();
1165 javascript      code      },
1166 javascript      blank
1167 javascript      code      activate: function(element) {
1168 javascript      code        element = $(element);
1169 javascript      code        element.focus();
1170 javascript      code        if (element.select)
1171 javascript      code          element.select();
1172 javascript      code      }
1173 javascript      code    }
1174 javascript      blank
1175 javascript      comment /*--------------------------------------------------------------------------*/
1176 javascript      blank
1177 javascript      code    var Form = {
1178 javascript      code      serialize: function(form) {
1179 javascript      code        var elements = Form.getElements($(form));
1180 javascript      code        var queryComponents = new Array();
1181 javascript      blank
1182 javascript      code        for (var i = 0; i < elements.length; i++) {
1183 javascript      code          var queryComponent = Form.Element.serialize(elements[i]);
1184 javascript      code          if (queryComponent)
1185 javascript      code            queryComponents.push(queryComponent);
1186 javascript      code        }
1187 javascript      blank
1188 javascript      code        return queryComponents.join('&');
1189 javascript      code      },
1190 javascript      blank
1191 javascript      code      getElements: function(form) {
1192 javascript      code        form = $(form);
1193 javascript      code        var elements = new Array();
1194 javascript      blank
1195 javascript      code        for (tagName in Form.Element.Serializers) {
1196 javascript      code          var tagElements = form.getElementsByTagName(tagName);
1197 javascript      code          for (var j = 0; j < tagElements.length; j++)
1198 javascript      code            elements.push(tagElements[j]);
1199 javascript      code        }
1200 javascript      code        return elements;
1201 javascript      code      },
1202 javascript      blank
1203 javascript      code      getInputs: function(form, typeName, name) {
1204 javascript      code        form = $(form);
1205 javascript      code        var inputs = form.getElementsByTagName('input');
1206 javascript      blank
1207 javascript      code        if (!typeName && !name)
1208 javascript      code          return inputs;
1209 javascript      blank
1210 javascript      code        var matchingInputs = new Array();
1211 javascript      code        for (var i = 0; i < inputs.length; i++) {
1212 javascript      code          var input = inputs[i];
1213 javascript      code          if ((typeName && input.type != typeName) ||
1214 javascript      code              (name && input.name != name))
1215 javascript      code            continue;
1216 javascript      code          matchingInputs.push(input);
1217 javascript      code        }
1218 javascript      blank
1219 javascript      code        return matchingInputs;
1220 javascript      code      },
1221 javascript      blank
1222 javascript      code      disable: function(form) {
1223 javascript      code        var elements = Form.getElements(form);
1224 javascript      code        for (var i = 0; i < elements.length; i++) {
1225 javascript      code          var element = elements[i];
1226 javascript      code          element.blur();
1227 javascript      code          element.disabled = 'true';
1228 javascript      code        }
1229 javascript      code      },
1230 javascript      blank
1231 javascript      code      enable: function(form) {
1232 javascript      code        var elements = Form.getElements(form);
1233 javascript      code        for (var i = 0; i < elements.length; i++) {
1234 javascript      code          var element = elements[i];
1235 javascript      code          element.disabled = '';
1236 javascript      code        }
1237 javascript      code      },
1238 javascript      blank
1239 javascript      code      findFirstElement: function(form) {
1240 javascript      code        return Form.getElements(form).find(function(element) {
1241 javascript      code          return element.type != 'hidden' && !element.disabled &&
1242 javascript      code            ['input', 'select', 'textarea'].include(element.tagName.toLowerCase());
1243 javascript      code        });
1244 javascript      code      },
1245 javascript      blank
1246 javascript      code      focusFirstElement: function(form) {
1247 javascript      code        Field.activate(Form.findFirstElement(form));
1248 javascript      code      },
1249 javascript      blank
1250 javascript      code      reset: function(form) {
1251 javascript      code        $(form).reset();
1252 javascript      code      }
1253 javascript      code    }
1254 javascript      blank
1255 javascript      code    Form.Element = {
1256 javascript      code      serialize: function(element) {
1257 javascript      code        element = $(element);
1258 javascript      code        var method = element.tagName.toLowerCase();
1259 javascript      code        var parameter = Form.Element.Serializers[method](element);
1260 javascript      blank
1261 javascript      code        if (parameter) {
1262 javascript      code          var key = encodeURIComponent(parameter[0]);
1263 javascript      code          if (key.length == 0) return;
1264 javascript      blank
1265 javascript      code          if (parameter[1].constructor != Array)
1266 javascript      code            parameter[1] = [parameter[1]];
1267 javascript      blank
1268 javascript      code          return parameter[1].map(function(value) {
1269 javascript      code            return key + '=' + encodeURIComponent(value);
1270 javascript      code          }).join('&');
1271 javascript      code        }
1272 javascript      code      },
1273 javascript      blank
1274 javascript      code      getValue: function(element) {
1275 javascript      code        element = $(element);
1276 javascript      code        var method = element.tagName.toLowerCase();
1277 javascript      code        var parameter = Form.Element.Serializers[method](element);
1278 javascript      blank
1279 javascript      code        if (parameter)
1280 javascript      code          return parameter[1];
1281 javascript      code      }
1282 javascript      code    }
1283 javascript      blank
1284 javascript      code    Form.Element.Serializers = {
1285 javascript      code      input: function(element) {
1286 javascript      code        switch (element.type.toLowerCase()) {
1287 javascript      code          case 'submit':
1288 javascript      code          case 'hidden':
1289 javascript      code          case 'password':
1290 javascript      code          case 'text':
1291 javascript      code            return Form.Element.Serializers.textarea(element);
1292 javascript      code          case 'checkbox':
1293 javascript      code          case 'radio':
1294 javascript      code            return Form.Element.Serializers.inputSelector(element);
1295 javascript      code        }
1296 javascript      code        return false;
1297 javascript      code      },
1298 javascript      blank
1299 javascript      code      inputSelector: function(element) {
1300 javascript      code        if (element.checked)
1301 javascript      code          return [element.name, element.value];
1302 javascript      code      },
1303 javascript      blank
1304 javascript      code      textarea: function(element) {
1305 javascript      code        return [element.name, element.value];
1306 javascript      code      },
1307 javascript      blank
1308 javascript      code      select: function(element) {
1309 javascript      code        return Form.Element.Serializers[element.type == 'select-one' ?
1310 javascript      code          'selectOne' : 'selectMany'](element);
1311 javascript      code      },
1312 javascript      blank
1313 javascript      code      selectOne: function(element) {
1314 javascript      code        var value = '', opt, index = element.selectedIndex;
1315 javascript      code        if (index >= 0) {
1316 javascript      code          opt = element.options[index];
1317 javascript      code          value = opt.value;
1318 javascript      code          if (!value && !('value' in opt))
1319 javascript      code            value = opt.text;
1320 javascript      code        }
1321 javascript      code        return [element.name, value];
1322 javascript      code      },
1323 javascript      blank
1324 javascript      code      selectMany: function(element) {
1325 javascript      code        var value = new Array();
1326 javascript      code        for (var i = 0; i < element.length; i++) {
1327 javascript      code          var opt = element.options[i];
1328 javascript      code          if (opt.selected) {
1329 javascript      code            var optValue = opt.value;
1330 javascript      code            if (!optValue && !('value' in opt))
1331 javascript      code              optValue = opt.text;
1332 javascript      code            value.push(optValue);
1333 javascript      code          }
1334 javascript      code        }
1335 javascript      code        return [element.name, value];
1336 javascript      code      }
1337 javascript      code    }
1338 javascript      blank
1339 javascript      comment /*--------------------------------------------------------------------------*/
1340 javascript      blank
1341 javascript      code    var $F = Form.Element.getValue;
1342 javascript      blank
1343 javascript      comment /*--------------------------------------------------------------------------*/
1344 javascript      blank
1345 javascript      code    Abstract.TimedObserver = function() {}
1346 javascript      code    Abstract.TimedObserver.prototype = {
1347 javascript      code      initialize: function(element, frequency, callback) {
1348 javascript      code        this.frequency = frequency;
1349 javascript      code        this.element   = $(element);
1350 javascript      code        this.callback  = callback;
1351 javascript      blank
1352 javascript      code        this.lastValue = this.getValue();
1353 javascript      code        this.registerCallback();
1354 javascript      code      },
1355 javascript      blank
1356 javascript      code      registerCallback: function() {
1357 javascript      code        setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
1358 javascript      code      },
1359 javascript      blank
1360 javascript      code      onTimerEvent: function() {
1361 javascript      code        var value = this.getValue();
1362 javascript      code        if (this.lastValue != value) {
1363 javascript      code          this.callback(this.element, value);
1364 javascript      code          this.lastValue = value;
1365 javascript      code        }
1366 javascript      code      }
1367 javascript      code    }
1368 javascript      blank
1369 javascript      code    Form.Element.Observer = Class.create();
1370 javascript      code    Form.Element.Observer.prototype = Object.extend(new Abstract.TimedObserver(), {
1371 javascript      code      getValue: function() {
1372 javascript      code        return Form.Element.getValue(this.element);
1373 javascript      code      }
1374 javascript      code    });
1375 javascript      blank
1376 javascript      code    Form.Observer = Class.create();
1377 javascript      code    Form.Observer.prototype = Object.extend(new Abstract.TimedObserver(), {
1378 javascript      code      getValue: function() {
1379 javascript      code        return Form.serialize(this.element);
1380 javascript      code      }
1381 javascript      code    });
1382 javascript      blank
1383 javascript      comment /*--------------------------------------------------------------------------*/
1384 javascript      blank
1385 javascript      code    Abstract.EventObserver = function() {}
1386 javascript      code    Abstract.EventObserver.prototype = {
1387 javascript      code      initialize: function(element, callback) {
1388 javascript      code        this.element  = $(element);
1389 javascript      code        this.callback = callback;
1390 javascript      blank
1391 javascript      code        this.lastValue = this.getValue();
1392 javascript      code        if (this.element.tagName.toLowerCase() == 'form')
1393 javascript      code          this.registerFormCallbacks();
1394 javascript      code        else
1395 javascript      code          this.registerCallback(this.element);
1396 javascript      code      },
1397 javascript      blank
1398 javascript      code      onElementEvent: function() {
1399 javascript      code        var value = this.getValue();
1400 javascript      code        if (this.lastValue != value) {
1401 javascript      code          this.callback(this.element, value);
1402 javascript      code          this.lastValue = value;
1403 javascript      code        }
1404 javascript      code      },
1405 javascript      blank
1406 javascript      code      registerFormCallbacks: function() {
1407 javascript      code        var elements = Form.getElements(this.element);
1408 javascript      code        for (var i = 0; i < elements.length; i++)
1409 javascript      code          this.registerCallback(elements[i]);
1410 javascript      code      },
1411 javascript      blank
1412 javascript      code      registerCallback: function(element) {
1413 javascript      code        if (element.type) {
1414 javascript      code          switch (element.type.toLowerCase()) {
1415 javascript      code            case 'checkbox':
1416 javascript      code            case 'radio':
1417 javascript      code              Event.observe(element, 'click', this.onElementEvent.bind(this));
1418 javascript      code              break;
1419 javascript      code            case 'password':
1420 javascript      code            case 'text':
1421 javascript      code            case 'textarea':
1422 javascript      code            case 'select-one':
1423 javascript      code            case 'select-multiple':
1424 javascript      code              Event.observe(element, 'change', this.onElementEvent.bind(this));
1425 javascript      code              break;
1426 javascript      code          }
1427 javascript      code        }
1428 javascript      code      }
1429 javascript      code    }
1430 javascript      blank
1431 javascript      code    Form.Element.EventObserver = Class.create();
1432 javascript      code    Form.Element.EventObserver.prototype = Object.extend(new Abstract.EventObserver(), {
1433 javascript      code      getValue: function() {
1434 javascript      code        return Form.Element.getValue(this.element);
1435 javascript      code      }
1436 javascript      code    });
1437 javascript      blank
1438 javascript      code    Form.EventObserver = Class.create();
1439 javascript      code    Form.EventObserver.prototype = Object.extend(new Abstract.EventObserver(), {
1440 javascript      code      getValue: function() {
1441 javascript      code        return Form.serialize(this.element);
1442 javascript      code      }
1443 javascript      code    });
1444 javascript      code    if (!window.Event) {
1445 javascript      code      var Event = new Object();
1446 javascript      code    }
1447 javascript      blank
1448 javascript      code    Object.extend(Event, {
1449 javascript      code      KEY_BACKSPACE: 8,
1450 javascript      code      KEY_TAB:       9,
1451 javascript      code      KEY_RETURN:   13,
1452 javascript      code      KEY_ESC:      27,
1453 javascript      code      KEY_LEFT:     37,
1454 javascript      code      KEY_UP:       38,
1455 javascript      code      KEY_RIGHT:    39,
1456 javascript      code      KEY_DOWN:     40,
1457 javascript      code      KEY_DELETE:   46,
1458 javascript      blank
1459 javascript      code      element: function(event) {
1460 javascript      code        return event.target || event.srcElement;
1461 javascript      code      },
1462 javascript      blank
1463 javascript      code      isLeftClick: function(event) {
1464 javascript      code        return (((event.which) && (event.which == 1)) ||
1465 javascript      code                ((event.button) && (event.button == 1)));
1466 javascript      code      },
1467 javascript      blank
1468 javascript      code      pointerX: function(event) {
1469 javascript      code        return event.pageX || (event.clientX +
1470 javascript      code          (document.documentElement.scrollLeft || document.body.scrollLeft));
1471 javascript      code      },
1472 javascript      blank
1473 javascript      code      pointerY: function(event) {
1474 javascript      code        return event.pageY || (event.clientY +
1475 javascript      code          (document.documentElement.scrollTop || document.body.scrollTop));
1476 javascript      code      },
1477 javascript      blank
1478 javascript      code      stop: function(event) {
1479 javascript      code        if (event.preventDefault) {
1480 javascript      code          event.preventDefault();
1481 javascript      code          event.stopPropagation();
1482 javascript      code        } else {
1483 javascript      code          event.returnValue = false;
1484 javascript      code          event.cancelBubble = true;
1485 javascript      code        }
1486 javascript      code      },
1487 javascript      blank
1488 javascript      comment   // find the first node with the given tagName, starting from the
1489 javascript      comment   // node the event was triggered on; traverses the DOM upwards
1490 javascript      code      findElement: function(event, tagName) {
1491 javascript      code        var element = Event.element(event);
1492 javascript      code        while (element.parentNode && (!element.tagName ||
1493 javascript      code            (element.tagName.toUpperCase() != tagName.toUpperCase())))
1494 javascript      code          element = element.parentNode;
1495 javascript      code        return element;
1496 javascript      code      },
1497 javascript      blank
1498 javascript      code      observers: false,
1499 javascript      blank
1500 javascript      code      _observeAndCache: function(element, name, observer, useCapture) {
1501 javascript      code        if (!this.observers) this.observers = [];
1502 javascript      code        if (element.addEventListener) {
1503 javascript      code          this.observers.push([element, name, observer, useCapture]);
1504 javascript      code          element.addEventListener(name, observer, useCapture);
1505 javascript      code        } else if (element.attachEvent) {
1506 javascript      code          this.observers.push([element, name, observer, useCapture]);
1507 javascript      code          element.attachEvent('on' + name, observer);
1508 javascript      code        }
1509 javascript      code      },
1510 javascript      blank
1511 javascript      code      unloadCache: function() {
1512 javascript      code        if (!Event.observers) return;
1513 javascript      code        for (var i = 0; i < Event.observers.length; i++) {
1514 javascript      code          Event.stopObserving.apply(this, Event.observers[i]);
1515 javascript      code          Event.observers[i][0] = null;
1516 javascript      code        }
1517 javascript      code        Event.observers = false;
1518 javascript      code      },
1519 javascript      blank
1520 javascript      code      observe: function(element, name, observer, useCapture) {
1521 javascript      code        var element = $(element);
1522 javascript      code        useCapture = useCapture || false;
1523 javascript      blank
1524 javascript      code        if (name == 'keypress' &&
1525 javascript      code            (navigator.appVersion.match(/Konqueror|Safari|KHTML/)
1526 javascript      code            || element.attachEvent))
1527 javascript      code          name = 'keydown';
1528 javascript      blank
1529 javascript      code        this._observeAndCache(element, name, observer, useCapture);
1530 javascript      code      },
1531 javascript      blank
1532 javascript      code      stopObserving: function(element, name, observer, useCapture) {
1533 javascript      code        var element = $(element);
1534 javascript      code        useCapture = useCapture || false;
1535 javascript      blank
1536 javascript      code        if (name == 'keypress' &&
1537 javascript      code            (navigator.appVersion.match(/Konqueror|Safari|KHTML/)
1538 javascript      code            || element.detachEvent))
1539 javascript      code          name = 'keydown';
1540 javascript      blank
1541 javascript      code        if (element.removeEventListener) {
1542 javascript      code          element.removeEventListener(name, observer, useCapture);
1543 javascript      code        } else if (element.detachEvent) {
1544 javascript      code          element.detachEvent('on' + name, observer);
1545 javascript      code        }
1546 javascript      code      }
1547 javascript      code    });
1548 javascript      blank
1549 javascript      comment /* prevent memory leaks in IE */
1550 javascript      code    Event.observe(window, 'unload', Event.unloadCache, false);
1551 javascript      code    var Position = {
1552 javascript      comment   // set to true if needed, warning: firefox performance problems
1553 javascript      comment   // NOT neeeded for page scrolling, only if draggable contained in
1554 javascript      comment   // scrollable elements
1555 javascript      code      includeScrollOffsets: false,
1556 javascript      blank
1557 javascript      comment   // must be called before calling withinIncludingScrolloffset, every time the
1558 javascript      comment   // page is scrolled
1559 javascript      code      prepare: function() {
1560 javascript      code        this.deltaX =  window.pageXOffset
1561 javascript      code                    || document.documentElement.scrollLeft
1562 javascript      code                    || document.body.scrollLeft
1563 javascript      code                    || 0;
1564 javascript      code        this.deltaY =  window.pageYOffset
1565 javascript      code                    || document.documentElement.scrollTop
1566 javascript      code                    || document.body.scrollTop
1567 javascript      code                    || 0;
1568 javascript      code      },
1569 javascript      blank
1570 javascript      code      realOffset: function(element) {
1571 javascript      code        var valueT = 0, valueL = 0;
1572 javascript      code        do {
1573 javascript      code          valueT += element.scrollTop  || 0;
1574 javascript      code          valueL += element.scrollLeft || 0;
1575 javascript      code          element = element.parentNode;
1576 javascript      code        } while (element);
1577 javascript      code        return [valueL, valueT];
1578 javascript      code      },
1579 javascript      blank
1580 javascript      code      cumulativeOffset: function(element) {
1581 javascript      code        var valueT = 0, valueL = 0;
1582 javascript      code        do {
1583 javascript      code          valueT += element.offsetTop  || 0;
1584 javascript      code          valueL += element.offsetLeft || 0;
1585 javascript      code          element = element.offsetParent;
1586 javascript      code        } while (element);
1587 javascript      code        return [valueL, valueT];
1588 javascript      code      },
1589 javascript      blank
1590 javascript      code      positionedOffset: function(element) {
1591 javascript      code        var valueT = 0, valueL = 0;
1592 javascript      code        do {
1593 javascript      code          valueT += element.offsetTop  || 0;
1594 javascript      code          valueL += element.offsetLeft || 0;
1595 javascript      code          element = element.offsetParent;
1596 javascript      code          if (element) {
1597 javascript      code            p = Element.getStyle(element, 'position');
1598 javascript      code            if (p == 'relative' || p == 'absolute') break;
1599 javascript      code          }
1600 javascript      code        } while (element);
1601 javascript      code        return [valueL, valueT];
1602 javascript      code      },
1603 javascript      blank
1604 javascript      code      offsetParent: function(element) {
1605 javascript      code        if (element.offsetParent) return element.offsetParent;
1606 javascript      code        if (element == document.body) return element;
1607 javascript      blank
1608 javascript      code        while ((element = element.parentNode) && element != document.body)
1609 javascript      code          if (Element.getStyle(element, 'position') != 'static')
1610 javascript      code            return element;
1611 javascript      blank
1612 javascript      code        return document.body;
1613 javascript      code      },
1614 javascript      blank
1615 javascript      comment   // caches x/y coordinate pair to use with overlap
1616 javascript      code      within: function(element, x, y) {
1617 javascript      code        if (this.includeScrollOffsets)
1618 javascript      code          return this.withinIncludingScrolloffsets(element, x, y);
1619 javascript      code        this.xcomp = x;
1620 javascript      code        this.ycomp = y;
1621 javascript      code        this.offset = this.cumulativeOffset(element);
1622 javascript      blank
1623 javascript      code        return (y >= this.offset[1] &&
1624 javascript      code                y <  this.offset[1] + element.offsetHeight &&
1625 javascript      code                x >= this.offset[0] &&
1626 javascript      code                x <  this.offset[0] + element.offsetWidth);
1627 javascript      code      },
1628 javascript      blank
1629 javascript      code      withinIncludingScrolloffsets: function(element, x, y) {
1630 javascript      code        var offsetcache = this.realOffset(element);
1631 javascript      blank
1632 javascript      code        this.xcomp = x + offsetcache[0] - this.deltaX;
1633 javascript      code        this.ycomp = y + offsetcache[1] - this.deltaY;
1634 javascript      code        this.offset = this.cumulativeOffset(element);
1635 javascript      blank
1636 javascript      code        return (this.ycomp >= this.offset[1] &&
1637 javascript      code                this.ycomp <  this.offset[1] + element.offsetHeight &&
1638 javascript      code                this.xcomp >= this.offset[0] &&
1639 javascript      code                this.xcomp <  this.offset[0] + element.offsetWidth);
1640 javascript      code      },
1641 javascript      blank
1642 javascript      comment   // within must be called directly before
1643 javascript      code      overlap: function(mode, element) {
1644 javascript      code        if (!mode) return 0;
1645 javascript      code        if (mode == 'vertical')
1646 javascript      code          return ((this.offset[1] + element.offsetHeight) - this.ycomp) /
1647 javascript      code            element.offsetHeight;
1648 javascript      code        if (mode == 'horizontal')
1649 javascript      code          return ((this.offset[0] + element.offsetWidth) - this.xcomp) /
1650 javascript      code            element.offsetWidth;
1651 javascript      code      },
1652 javascript      blank
1653 javascript      code      clone: function(source, target) {
1654 javascript      code        source = $(source);
1655 javascript      code        target = $(target);
1656 javascript      code        target.style.position = 'absolute';
1657 javascript      code        var offsets = this.cumulativeOffset(source);
1658 javascript      code        target.style.top    = offsets[1] + 'px';
1659 javascript      code        target.style.left   = offsets[0] + 'px';
1660 javascript      code        target.style.width  = source.offsetWidth + 'px';
1661 javascript      code        target.style.height = source.offsetHeight + 'px';
1662 javascript      code      },
1663 javascript      blank
1664 javascript      code      page: function(forElement) {
1665 javascript      code        var valueT = 0, valueL = 0;
1666 javascript      blank
1667 javascript      code        var element = forElement;
1668 javascript      code        do {
1669 javascript      code          valueT += element.offsetTop  || 0;
1670 javascript      code          valueL += element.offsetLeft || 0;
1671 javascript      blank
1672 javascript      comment       // Safari fix
1673 javascript      code          if (element.offsetParent==document.body)
1674 javascript      code            if (Element.getStyle(element,'position')=='absolute') break;
1675 javascript      blank
1676 javascript      code        } while (element = element.offsetParent);
1677 javascript      blank
1678 javascript      code        element = forElement;
1679 javascript      code        do {
1680 javascript      code          valueT -= element.scrollTop  || 0;
1681 javascript      code          valueL -= element.scrollLeft || 0;
1682 javascript      code        } while (element = element.parentNode);
1683 javascript      blank
1684 javascript      code        return [valueL, valueT];
1685 javascript      code      },
1686 javascript      blank
1687 javascript      code      clone: function(source, target) {
1688 javascript      code        var options = Object.extend({
1689 javascript      code          setLeft:    true,
1690 javascript      code          setTop:     true,
1691 javascript      code          setWidth:   true,
1692 javascript      code          setHeight:  true,
1693 javascript      code          offsetTop:  0,
1694 javascript      code          offsetLeft: 0
1695 javascript      code        }, arguments[2] || {})
1696 javascript      blank
1697 javascript      comment     // find page position of source
1698 javascript      code        source = $(source);
1699 javascript      code        var p = Position.page(source);
1700 javascript      blank
1701 javascript      comment     // find coordinate system to use
1702 javascript      code        target = $(target);
1703 javascript      code        var delta = [0, 0];
1704 javascript      code        var parent = null;
1705 javascript      comment     // delta [0,0] will do fine with position: fixed elements,
1706 javascript      comment     // position:absolute needs offsetParent deltas
1707 javascript      code        if (Element.getStyle(target,'position') == 'absolute') {
1708 javascript      code          parent = Position.offsetParent(target);
1709 javascript      code          delta = Position.page(parent);
1710 javascript      code        }
1711 javascript      blank
1712 javascript      comment     // correct by body offsets (fixes Safari)
1713 javascript      code        if (parent == document.body) {
1714 javascript      code          delta[0] -= document.body.offsetLeft;
1715 javascript      code          delta[1] -= document.body.offsetTop;
1716 javascript      code        }
1717 javascript      blank
1718 javascript      comment     // set position
1719 javascript      code        if(options.setLeft)   target.style.left  = (p[0] - delta[0] + options.offsetLeft) + 'px';
1720 javascript      code        if(options.setTop)    target.style.top   = (p[1] - delta[1] + options.offsetTop) + 'px';
1721 javascript      code        if(options.setWidth)  target.style.width = source.offsetWidth + 'px';
1722 javascript      code        if(options.setHeight) target.style.height = source.offsetHeight + 'px';
1723 javascript      code      },
1724 javascript      blank
1725 javascript      code      absolutize: function(element) {
1726 javascript      code        element = $(element);
1727 javascript      code        if (element.style.position == 'absolute') return;
1728 javascript      code        Position.prepare();
1729 javascript      blank
1730 javascript      code        var offsets = Position.positionedOffset(element);
1731 javascript      code        var top     = offsets[1];
1732 javascript      code        var left    = offsets[0];
1733 javascript      code        var width   = element.clientWidth;
1734 javascript      code        var height  = element.clientHeight;
1735 javascript      blank
1736 javascript      code        element._originalLeft   = left - parseFloat(element.style.left  || 0);
1737 javascript      code        element._originalTop    = top  - parseFloat(element.style.top || 0);
1738 javascript      code        element._originalWidth  = element.style.width;
1739 javascript      code        element._originalHeight = element.style.height;
1740 javascript      blank
1741 javascript      code        element.style.position = 'absolute';
1742 javascript      code        element.style.top    = top + 'px';;
1743 javascript      code        element.style.left   = left + 'px';;
1744 javascript      code        element.style.width  = width + 'px';;
1745 javascript      code        element.style.height = height + 'px';;
1746 javascript      code      },
1747 javascript      blank
1748 javascript      code      relativize: function(element) {
1749 javascript      code        element = $(element);
1750 javascript      code        if (element.style.position == 'relative') return;
1751 javascript      code        Position.prepare();
1752 javascript      blank
1753 javascript      code        element.style.position = 'relative';
1754 javascript      code        var top  = parseFloat(element.style.top  || 0) - (element._originalTop || 0);
1755 javascript      code        var left = parseFloat(element.style.left || 0) - (element._originalLeft || 0);
1756 javascript      blank
1757 javascript      code        element.style.top    = top + 'px';
1758 javascript      code        element.style.left   = left + 'px';
1759 javascript      code        element.style.height = element._originalHeight;
1760 javascript      code        element.style.width  = element._originalWidth;
1761 javascript      code      }
1762 javascript      code    }
1763 javascript      blank
1764 javascript      comment // Safari returns margins on body which is incorrect if the child is absolutely
1765 javascript      comment // positioned.  For performance reasons, redefine Position.cumulativeOffset for
1766 javascript      comment // KHTML/WebKit only.
1767 javascript      code    if (/Konqueror|Safari|KHTML/.test(navigator.userAgent)) {
1768 javascript      code      Position.cumulativeOffset = function(element) {
1769 javascript      code        var valueT = 0, valueL = 0;
1770 javascript      code        do {
1771 javascript      code          valueT += element.offsetTop  || 0;
1772 javascript      code          valueL += element.offsetLeft || 0;
1773 javascript      code          if (element.offsetParent == document.body)
1774 javascript      code            if (Element.getStyle(element, 'position') == 'absolute') break;
1775 javascript      blank
1776 javascript      code          element = element.offsetParent;
1777 javascript      code        } while (element);
1778 javascript      blank
1779 javascript      code        return [valueL, valueT];
1780 javascript      code      }
1781 javascript      code    }