1

/*  Prototype JavaScript framework, version 1.6.0.2

     2

 *  (c) 2005-2008 Sam Stephenson

     3

 *

     4

 *  Prototype is freely distributable under the terms of an MIT-style license.

     5

 *  For details, see the Prototype web site: http://www.prototypejs.org/

     6

 *

     7

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

     8

     9

var Prototype = {

    10

  Version: '1.6.0.2',

    11

    12

  Browser: {

    13

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

    14

    Opera:  !!window.opera,

    15

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

    16

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

    17

    MobileSafari: !!navigator.userAgent.match(/Apple.*Mobile.*Safari/)

    18

  },

    19

    20

  BrowserFeatures: {

    21

    XPath: !!document.evaluate,

    22

    ElementExtensions: !!window.HTMLElement,

    23

    SpecificElementExtensions:

    24

      document.createElement('div').__proto__ &&

    25

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

    26

        document.createElement('form').__proto__

    27

  },

    28

    29

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

    30

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

    31

    32

  emptyFunction: function() { },

    33

  K: function(x) { return x }

    34

};

    35

    36

if (Prototype.Browser.MobileSafari)

    37

  Prototype.BrowserFeatures.SpecificElementExtensions = false;

    38

    39

    40

/* Based on Alex Arnell's inheritance implementation. */

    41

var Class = {

    42

  create: function() {

    43

    var parent = null, properties = $A(arguments);

    44

    if (Object.isFunction(properties[0]))

    45

      parent = properties.shift();

    46

    47

    function klass() {

    48

      this.initialize.apply(this, arguments);

    49

    }

    50

    51

    Object.extend(klass, Class.Methods);

    52

    klass.superclass = parent;

    53

    klass.subclasses = [];

    54

    55

    if (parent) {

    56

      var subclass = function() { };

    57

      subclass.prototype = parent.prototype;

    58

      klass.prototype = new subclass;

    59

      parent.subclasses.push(klass);

    60

    }

    61

    62

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

    63

      klass.addMethods(properties[i]);

    64

    65

    if (!klass.prototype.initialize)

    66

      klass.prototype.initialize = Prototype.emptyFunction;

    67

    68

    klass.prototype.constructor = klass;

    69

    70

    return klass;

    71

  }

    72

};

    73

    74

Class.Methods = {

    75

  addMethods: function(source) {

    76

    var ancestor   = this.superclass && this.superclass.prototype;

    77

    var properties = Object.keys(source);

    78

    79

    if (!Object.keys({ toString: true }).length)

    80

      properties.push("toString", "valueOf");

    81

    82

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

    83

      var property = properties[i], value = source[property];

    84

      if (ancestor && Object.isFunction(value) &&

    85

          value.argumentNames().first() == "$super") {

    86

        var method = value, value = Object.extend((function(m) {

    87

          return function() { return ancestor[m].apply(this, arguments) };

    88

        })(property).wrap(method), {

    89

          valueOf:  function() { return method },

    90

          toString: function() { return method.toString() }

    91

        });

    92

      }

    93

      this.prototype[property] = value;

    94

    }

    95

    96

    return this;

    97

  }

    98

};

    99

   100

var Abstract = { };

   101

   102

Object.extend = function(destination, source) {

   103

  for (var property in source)

   104

    destination[property] = source[property];

   105

  return destination;

   106

};

   107

   108

Object.extend(Object, {

   109

  inspect: function(object) {

   110

    try {

   111

      if (Object.isUndefined(object)) return 'undefined';

   112

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

   113

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

   114

    } catch (e) {

   115

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

   116

      throw e;

   117

    }

   118

  },

   119

   120

  toJSON: function(object) {

   121

    var type = typeof object;

   122

    switch (type) {

   123

      case 'undefined':

   124

      case 'function':

   125

      case 'unknown': return;

   126

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

   127

    }

   128

   129

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

   130

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

   131

    if (Object.isElement(object)) return;

   132

   133

    var results = [];

   134

    for (var property in object) {

   135

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

   136

      if (!Object.isUndefined(value))

   137

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

   138

    }

   139

   140

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

   141

  },

   142

   143

  toQueryString: function(object) {

   144

    return $H(object).toQueryString();

   145

  },

   146

   147

  toHTML: function(object) {

   148

    return object && object.toHTML ? object.toHTML() : String.interpret(object);

   149

  },

   150

   151

  keys: function(object) {

   152

    var keys = [];

   153

    for (var property in object)

   154

      keys.push(property);

   155

    return keys;

   156

  },

   157

   158

  values: function(object) {

   159

    var values = [];

   160

    for (var property in object)

   161

      values.push(object[property]);

   162

    return values;

   163

  },

   164

   165

  clone: function(object) {

   166

    return Object.extend({ }, object);

   167

  },

   168

   169

  isElement: function(object) {

   170

    return object && object.nodeType == 1;

   171

  },

   172

   173

  isArray: function(object) {

   174

    return object != null && typeof object == "object" &&

   175

      'splice' in object && 'join' in object;

   176

  },

   177

   178

  isHash: function(object) {

   179

    return object instanceof Hash;

   180

  },

   181

   182

  isFunction: function(object) {

   183

    return typeof object == "function";

   184

  },

   185

   186

  isString: function(object) {

   187

    return typeof object == "string";

   188

  },

   189

   190

  isNumber: function(object) {

   191

    return typeof object == "number";

   192

  },

   193

   194

  isUndefined: function(object) {

   195

    return typeof object == "undefined";

   196

  }

   197

});

   198

   199

Object.extend(Function.prototype, {

   200

  argumentNames: function() {

   201

    var names = this.toString().match(/^[\s\(]*function[^(]*\((.*?)\)/)[1].split(",").invoke("strip");

   202

    return names.length == 1 && !names[0] ? [] : names;

   203

  },

   204

   205

  bind: function() {

   206

    if (arguments.length < 2 && Object.isUndefined(arguments[0])) return this;

   207

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

   208

    return function() {

   209

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

   210

    }

   211

  },

   212

   213

  bindAsEventListener: function() {

   214

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

   215

    return function(event) {

   216

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

   217

    }

   218

  },

   219

   220

  curry: function() {

   221

    if (!arguments.length) return this;

   222

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

   223

    return function() {

   224

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

   225

    }

   226

  },

   227

   228

  delay: function() {

   229

    var __method = this, args = $A(arguments), timeout = args.shift() * 1000;

   230

    return window.setTimeout(function() {

   231

      return __method.apply(__method, args);

   232

    }, timeout);

   233

  },

   234

   235

  wrap: function(wrapper) {

   236

    var __method = this;

   237

    return function() {

   238

      return wrapper.apply(this, [__method.bind(this)].concat($A(arguments)));

   239

    }

   240

  },

   241

   242

  methodize: function() {

   243

    if (this._methodized) return this._methodized;

   244

    var __method = this;

   245

    return this._methodized = function() {

   246

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

   247

    };

   248

  }

   249

});

   250

   251

Function.prototype.defer = Function.prototype.delay.curry(0.01);

   252

   253

Date.prototype.toJSON = function() {

   254

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

   255

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

   256

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

   257

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

   258

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

   259

    this.getUTCSeconds().toPaddedString(2) + 'Z"';

   260

};

   261

   262

var Try = {

   263

  these: function() {

   264

    var returnValue;

   265

   266

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

   267

      var lambda = arguments[i];

   268

      try {

   269

        returnValue = lambda();

   270

        break;

   271

      } catch (e) { }

   272

    }

   273

   274

    return returnValue;

   275

  }

   276

};

   277

   278

RegExp.prototype.match = RegExp.prototype.test;

   279

   280

RegExp.escape = function(str) {

   281

  return String(str).replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1');

   282

};

   283

   284

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

   285

   286

var PeriodicalExecuter = Class.create({

   287

  initialize: function(callback, frequency) {

   288

    this.callback = callback;

   289

    this.frequency = frequency;

   290

    this.currentlyExecuting = false;

   291

   292

    this.registerCallback();

   293

  },

   294

   295

  registerCallback: function() {

   296

    this.timer = setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);

   297

  },

   298

   299

  execute: function() {

   300

    this.callback(this);

   301

  },

   302

   303

  stop: function() {

   304

    if (!this.timer) return;

   305

    clearInterval(this.timer);

   306

    this.timer = null;

   307

  },

   308

   309

  onTimerEvent: function() {

   310

    if (!this.currentlyExecuting) {

   311

      try {

   312

        this.currentlyExecuting = true;

   313

        this.execute();

   314

      } finally {

   315

        this.currentlyExecuting = false;

   316

      }

   317

    }

   318

  }

   319

});

   320

Object.extend(String, {

   321

  interpret: function(value) {

   322

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

   323

  },

   324

  specialChar: {

   325

    '\b': '\\b',

   326

    '\t': '\\t',

   327

    '\n': '\\n',

   328

    '\f': '\\f',

   329

    '\r': '\\r',

   330

    '\\': '\\\\'

   331

  }

   332

});

   333

   334

Object.extend(String.prototype, {

   335

  gsub: function(pattern, replacement) {

   336

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

   337

    replacement = arguments.callee.prepareReplacement(replacement);

   338

   339

    while (source.length > 0) {

   340

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

   341

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

   342

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

   343

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

   344

      } else {

   345

        result += source, source = '';

   346

      }

   347

    }

   348

    return result;

   349

  },

   350

   351

  sub: function(pattern, replacement, count) {

   352

    replacement = this.gsub.prepareReplacement(replacement);

   353

    count = Object.isUndefined(count) ? 1 : count;

   354

   355

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

   356

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

   357

      return replacement(match);

   358

    });

   359

  },

   360

   361

  scan: function(pattern, iterator) {

   362

    this.gsub(pattern, iterator);

   363

    return String(this);

   364

  },

   365

   366

  truncate: function(length, truncation) {

   367

    length = length || 30;

   368

    truncation = Object.isUndefined(truncation) ? '...' : truncation;

   369

    return this.length > length ?

   370

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

   371

  },

   372

   373

  strip: function() {

   374

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

   375

  },

   376

   377

  stripTags: function() {

   378

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

   379

  },

   380

   381

  stripScripts: function() {

   382

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

   383

  },

   384

   385

  extractScripts: function() {

   386

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

   387

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

   388

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

   389

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

   390

    });

   391

  },

   392

   393

  evalScripts: function() {

   394

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

   395

  },

   396

   397

  escapeHTML: function() {

   398

    var self = arguments.callee;

   399

    self.text.data = this;

   400

    return self.div.innerHTML;

   401

  },

   402

   403

  unescapeHTML: function() {

   404

    var div = new Element('div');

   405

    div.innerHTML = this.stripTags();

   406

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

   407

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

   408

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

   409

  },

   410

   411

  toQueryParams: function(separator) {

   412

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

   413

    if (!match) return { };

   414

   415

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

   416

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

   417

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

   418

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

   419

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

   420

   421

        if (key in hash) {

   422

          if (!Object.isArray(hash[key])) hash[key] = [hash[key]];

   423

          hash[key].push(value);

   424

        }

   425

        else hash[key] = value;

   426

      }

   427

      return hash;

   428

    });

   429

  },

   430

   431

  toArray: function() {

   432

    return this.split('');

   433

  },

   434

   435

  succ: function() {

   436

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

   437

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

   438

  },

   439

   440

  times: function(count) {

   441

    return count < 1 ? '' : new Array(count + 1).join(this);

   442

  },

   443

   444

  camelize: function() {

   445

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

   446

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

   447

   448

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

   449

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

   450

      : parts[0];

   451

   452

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

   453

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

   454

   455

    return camelized;

   456

  },

   457

   458

  capitalize: function() {

   459

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

   460

  },

   461

   462

  underscore: function() {

   463

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

   464

  },

   465

   466

  dasherize: function() {

   467

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

   468

  },

   469

   470

  inspect: function(useDoubleQuotes) {

   471

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

   472

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

   473

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

   474

    });

   475

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

   476

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

   477

  },

   478

   479

  toJSON: function() {

   480

    return this.inspect(true);

   481

  },

   482

   483

  unfilterJSON: function(filter) {

   484

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

   485

  },

   486

   487

  isJSON: function() {

   488

    var str = this;

   489

    if (str.blank()) return false;

   490

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

   491

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

   492

  },

   493

   494

  evalJSON: function(sanitize) {

   495

    var json = this.unfilterJSON();

   496

    try {

   497

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

   498

    } catch (e) { }

   499

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

   500

  },

   501

   502

  include: function(pattern) {

   503

    return this.indexOf(pattern) > -1;

   504

  },

   505

   506

  startsWith: function(pattern) {

   507

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

   508

  },

   509

   510

  endsWith: function(pattern) {

   511

    var d = this.length - pattern.length;

   512

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

   513

  },

   514

   515

  empty: function() {

   516

    return this == '';

   517

  },

   518

   519

  blank: function() {

   520

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

   521

  },

   522

   523

  interpolate: function(object, pattern) {

   524

    return new Template(this, pattern).evaluate(object);

   525

  }

   526

});

   527

   528

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

   529

  escapeHTML: function() {

   530

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