SoundSoftware Code Site

function collapseAllRowGroups(el) {

  var tbody = Element.up(el, 'tbody');

  tbody.childElements('tr').each(function(tr) {

    if (tr.hasClassName('group')) {

      tr.removeClassName('open');

    } else {

      tr.hide();

    }

  })

}

function expandAllRowGroups(el) {

  var tbody = Element.up(el, 'tbody');

  tbody.childElements('tr').each(function(tr) {

    if (tr.hasClassName('group')) {

      tr.addClassName('open');

    } else {

      tr.show();

    }

  })

}

function toggleAllRowGroups(el) {

	var tr = Element.up(el, 'tr');

  if (tr.hasClassName('open')) {

    collapseAllRowGroups(el);

  } else {

    expandAllRowGroups(el);

  }

}

/* 

 * 1 - registers a callback which copies the csrf token into the

 * X-CSRF-Token header with each ajax request.  Necessary to 

 * work with rails applications which have fixed

 * CVE-2011-0447

 * 2 - shows and hides ajax indicator

 */

    onCreate: function(request){

        var csrf_meta_tag = $$('meta[name=csrf-token]')[0];

        if (csrf_meta_tag) {

            var header = 'X-CSRF-Token',

                token = csrf_meta_tag.readAttribute('content');

            if (!request.options.requestHeaders) {

              request.options.requestHeaders = {};

            }

            request.options.requestHeaders[header] = token;

          }

  	if (Event.element(e).tagName == 'A' || Event.element(e).tagName == 'IMG') { return; }

          if (e.ctrlKey || e.metaKey) {

/*  Prototype JavaScript framework, version 1.7

 *  (c) 2005-2010 Sam Stephenson

  Version: '1.7',

  Browser: (function(){

    var ua = navigator.userAgent;

    var isOpera = Object.prototype.toString.call(window.opera) == '[object Opera]';

    return {

      IE:             !!window.attachEvent && !isOpera,

      Opera:          isOpera,

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

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

      MobileSafari:   /Apple.*Mobile/.test(ua)

    }

  })(),

    ElementExtensions: (function() {

      var constructor = window.Element || window.HTMLElement;

      return !!(constructor && constructor.prototype);

    })(),

    SpecificElementExtensions: (function() {

      if (typeof window.HTMLDivElement !== 'undefined')

        return true;

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

          form = document.createElement('form'),

          isSupported = false;

      if (div['__proto__'] && (div['__proto__'] !== form['__proto__'])) {

        isSupported = true;

      }

      div = form = null;

      return isSupported;

    })()

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

var Class = (function() {

  var IS_DONTENUM_BUGGY = (function(){

    for (var p in { toString: 1 }) {

      if (p === 'toString') return false;

    }

    return true;

  })();

  function subclass() {};

  function create() {

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

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

      parent = properties.shift();

    function klass() {

      this.initialize.apply(this, arguments);

    }

    Object.extend(klass, Class.Methods);

    klass.superclass = parent;

    klass.subclasses = [];

    if (parent) {

      subclass.prototype = parent.prototype;

      klass.prototype = new subclass;

      parent.subclasses.push(klass);

    }

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

      klass.addMethods(properties[i]);

    if (!klass.prototype.initialize)

      klass.prototype.initialize = Prototype.emptyFunction;

    klass.prototype.constructor = klass;

    return klass;

  }

  function addMethods(source) {

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

        properties = Object.keys(source);

    if (IS_DONTENUM_BUGGY) {

      if (source.toString != Object.prototype.toString)

        properties.push("toString");

      if (source.valueOf != Object.prototype.valueOf)

        properties.push("valueOf");

    }

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

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

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

          value.argumentNames()[0] == "$super") {

        var method = value;

        value = (function(m) {

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

        })(property).wrap(method);

        value.valueOf = method.valueOf.bind(method);

        value.toString = method.toString.bind(method);

      }

      this.prototype[property] = value;

    }

    return this;

  }

  return {

    create: create,

    Methods: {

      addMethods: addMethods

    }

  };

})();

(function() {

  var _toString = Object.prototype.toString,

      NULL_TYPE = 'Null',

      UNDEFINED_TYPE = 'Undefined',

      BOOLEAN_TYPE = 'Boolean',

      NUMBER_TYPE = 'Number',

      STRING_TYPE = 'String',

      OBJECT_TYPE = 'Object',

      FUNCTION_CLASS = '[object Function]',

      BOOLEAN_CLASS = '[object Boolean]',

      NUMBER_CLASS = '[object Number]',

      STRING_CLASS = '[object String]',

      ARRAY_CLASS = '[object Array]',

      DATE_CLASS = '[object Date]',

      NATIVE_JSON_STRINGIFY_SUPPORT = window.JSON &&

        typeof JSON.stringify === 'function' &&

        JSON.stringify(0) === '0' &&

        typeof JSON.stringify(Prototype.K) === 'undefined';

  function Type(o) {

    switch(o) {

      case null: return NULL_TYPE;

      case (void 0): return UNDEFINED_TYPE;

    }

    var type = typeof o;

    switch(type) {

      case 'boolean': return BOOLEAN_TYPE;

      case 'number':  return NUMBER_TYPE;

      case 'string':  return STRING_TYPE;

    }

    return OBJECT_TYPE;

  }

  function extend(destination, source) {

    for (var property in source)

      destination[property] = source[property];

    return destination;

  }

  function inspect(object) {

    try {

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

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

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

    } catch (e) {

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

      throw e;

    }

  }

  function toJSON(value) {

    return Str('', { '': value }, []);

  }

  function Str(key, holder, stack) {

    var value = holder[key],

        type = typeof value;

    if (Type(value) === OBJECT_TYPE && typeof value.toJSON === 'function') {

      value = value.toJSON(key);

    }

    var _class = _toString.call(value);

    switch (_class) {

      case NUMBER_CLASS:

      case BOOLEAN_CLASS:

      case STRING_CLASS:

        value = value.valueOf();

    }

    switch (value) {

      case null: return 'null';

      case true: return 'true';

      case false: return 'false';

    }

    type = typeof value;

    switch (type) {

      case 'string':

        return value.inspect(true);

      case 'number':

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

      case 'object':

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

          if (stack[i] === value) { throw new TypeError(); }

        }

        stack.push(value);

        var partial = [];

        if (_class === ARRAY_CLASS) {

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

            var str = Str(i, value, stack);

            partial.push(typeof str === 'undefined' ? 'null' : str);

          }

          partial = '[' + partial.join(',') + ']';

        } else {

          var keys = Object.keys(value);

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

            var key = keys[i], str = Str(key, value, stack);

            if (typeof str !== "undefined") {

               partial.push(key.inspect(true)+ ':' + str);

             }

          }

          partial = '{' + partial.join(',') + '}';

        }

        stack.pop();

        return partial;

    }

  }

  function stringify(object) {

    return JSON.stringify(object);

  }

  function toQueryString(object) {

    return $H(object).toQueryString();

  }

  function toHTML(object) {

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

  }

  function keys(object) {

    if (Type(object) !== OBJECT_TYPE) { throw new TypeError(); }

    var results = [];

    for (var property in object) {

      if (object.hasOwnProperty(property)) {

        results.push(property);

      }

    }

    return results;

  }

  function values(object) {

    var results = [];

    for (var property in object)

      results.push(object[property]);

    return results;

  }

  function clone(object) {

    return extend({ }, object);

  }

  function isElement(object) {

    return !!(object && object.nodeType == 1);

  }

  function isArray(object) {

    return _toString.call(object) === ARRAY_CLASS;

  }

  var hasNativeIsArray = (typeof Array.isArray == 'function')

    && Array.isArray([]) && !Array.isArray({});

  if (hasNativeIsArray) {

    isArray = Array.isArray;

  }

  function isHash(object) {

    return object instanceof Hash;

  }

  function isFunction(object) {

    return _toString.call(object) === FUNCTION_CLASS;

  }

  function isString(object) {

    return _toString.call(object) === STRING_CLASS;

  }

  function isNumber(object) {

    return _toString.call(object) === NUMBER_CLASS;

  }

  function isDate(object) {

    return _toString.call(object) === DATE_CLASS;

  }

  function isUndefined(object) {

    return typeof object === "undefined";

  }

  extend(Object, {

    extend:        extend,

    inspect:       inspect,

    toJSON:        NATIVE_JSON_STRINGIFY_SUPPORT ? stringify : toJSON,

    toQueryString: toQueryString,

    toHTML:        toHTML,

    keys:          Object.keys || keys,

    values:        values,

    clone:         clone,

    isElement:     isElement,

    isArray:       isArray,

    isHash:        isHash,

    isFunction:    isFunction,

    isString:      isString,

    isNumber:      isNumber,

    isDate:        isDate,

    isUndefined:   isUndefined

  });

})();

Object.extend(Function.prototype, (function() {

  var slice = Array.prototype.slice;

  function update(array, args) {

    var arrayLength = array.length, length = args.length;

    while (length--) array[arrayLength + length] = args[length];

    return array;

  }

  function merge(array, args) {

    array = slice.call(array, 0);

    return update(array, args);

  }

  function argumentNames() {

    var names = this.toString().match(/^[\s\(]*function[^(]*\(([^)]*)\)/)[1]

      .replace(/\/\/.*?[\r\n]|\/\*(?:.|[\r\n])*?\*\//g, '')

      .replace(/\s+/g, '').split(',');

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

  }

  function bind(context) {

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

    var __method = this, args = slice.call(arguments, 1);

    return function() {

      var a = merge(args, arguments);

      return __method.apply(context, a);

    }

  }

  function bindAsEventListener(context) {

    var __method = this, args = slice.call(arguments, 1);

    return function(event) {

      var a = update([event || window.event], args);

      return __method.apply(context, a);

    }

  }

  function curry() {

    if (!arguments.length) return this;

    var __method = this, args = slice.call(arguments, 0);

    return function() {

      var a = merge(args, arguments);

      return __method.apply(this, a);

    }

  }

  function delay(timeout) {

    var __method = this, args = slice.call(arguments, 1);

    timeout = timeout * 1000;

    return window.setTimeout(function() {

      return __method.apply(__method, args);

    }, timeout);

  }

  function defer() {

    var args = update([0.01], arguments);

    return this.delay.apply(this, args);

  }

  function wrap(wrapper) {

    var __method = this;

    return function() {

      var a = update([__method.bind(this)], arguments);

      return wrapper.apply(this, a);

    }

  }

  function methodize() {

    if (this._methodized) return this._methodized;

    var __method = this;

    return this._methodized = function() {

      var a = update([this], arguments);

      return __method.apply(null, a);

    };

  }

  return {

    argumentNames:       argumentNames,

    bind:                bind,

    bindAsEventListener: bindAsEventListener,

    curry:               curry,

    delay:               delay,

    defer:               defer,

    wrap:                wrap,

    methodize:           methodize

  }

})());

(function(proto) {

  function toISOString() {

    return this.getUTCFullYear() + '-' +

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

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

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

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

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

  }

  function toJSON() {

    return this.toISOString();

  }

  if (!proto.toISOString) proto.toISOString = toISOString;

  if (!proto.toJSON) proto.toJSON = toJSON;

})(Date.prototype);

      } catch(e) {

        this.currentlyExecuting = false;

        throw e;

Object.extend(String.prototype, (function() {

  var NATIVE_JSON_PARSE_SUPPORT = window.JSON &&

    typeof JSON.parse === 'function' &&

    JSON.parse('{"test": true}').test;

  function prepareReplacement(replacement) {

    if (Object.isFunction(replacement)) return replacement;

    var template = new Template(replacement);

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

  }

  function gsub(pattern, replacement) {

    replacement = prepareReplacement(replacement);

    if (Object.isString(pattern))

      pattern = RegExp.escape(pattern);

    if (!(pattern.length || pattern.source)) {

      replacement = replacement('');

      return replacement + source.split('').join(replacement) + replacement;

    }

  }

  function sub(pattern, replacement, count) {

    replacement = prepareReplacement(replacement);

  }

  function scan(pattern, iterator) {

  }

  function truncate(length, truncation) {

  }

  function strip() {

  }

  function stripTags() {

    return this.replace(/<\w+(\s+("[^"]*"|'[^']*'|[^>])+)?>|<\/\w+>/gi, '');

  }

  function stripScripts() {

  }

  function extractScripts() {

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

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

  }

  function evalScripts() {

  }

  function escapeHTML() {

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

  }

  function unescapeHTML() {

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

  }

  function toQueryParams(separator) {

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

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

  }

  function toArray() {

  }

  function succ() {

  }

  function times(count) {

  }

  function camelize() {

    return this.replace(/-+(.)?/g, function(match, chr) {

      return chr ? chr.toUpperCase() : '';

    });

  }

  function capitalize() {

  }

  function underscore() {

    return this.replace(/::/g, '/')

               .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')

               .replace(/([a-z\d])([A-Z])/g, '$1_$2')

               .replace(/-/g, '_')

               .toLowerCase();

  }

  function dasherize() {

    return this.replace(/_/g, '-');

  }

  function inspect(useDoubleQuotes) {

    var escapedString = this.replace(/[\x00-\x1f\\]/g, function(character) {

      if (character in String.specialChar) {

        return String.specialChar[character];

      }

      return '\\u00' + character.charCodeAt().toPaddedString(2, 16);

  }

  function unfilterJSON(filter) {

    return this.replace(filter || Prototype.JSONFilter, '$1');

  }

  function isJSON() {

    str = str.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@');

    str = str.replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']');

    str = str.replace(/(?:^|:|,)(?:\s*\[)+/g, '');

    return (/^[\],:{}\s]*$/).test(str);

  }

  function evalJSON(sanitize) {

    var json = this.unfilterJSON(),

        cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g;

    if (cx.test(json)) {

      json = json.replace(cx, function (a) {

        return '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);

      });

    }

  }

  function parseJSON() {

    var json = this.unfilterJSON();

    return JSON.parse(json);

  }

  function include(pattern) {

  }

  function startsWith(pattern) {

    return this.lastIndexOf(pattern, 0) === 0;

  }

  function endsWith(pattern) {

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

  }

  function empty() {

  }

  function blank() {

  }

  function interpolate(object, pattern) {

  return {

    gsub:           gsub,

    sub:            sub,

    scan:           scan,

    truncate:       truncate,

    strip:          String.prototype.trim || strip,

    stripTags:      stripTags,

    stripScripts:   stripScripts,

    extractScripts: extractScripts,

    evalScripts:    evalScripts,

    escapeHTML:     escapeHTML,

    unescapeHTML:   unescapeHTML,

    toQueryParams:  toQueryParams,

    parseQuery:     toQueryParams,

    toArray:        toArray,

    succ:           succ,

    times:          times,

    camelize:       camelize,

    capitalize:     capitalize,

    underscore:     underscore,

    dasherize:      dasherize,

    inspect:        inspect,

    unfilterJSON:   unfilterJSON,

    isJSON:         isJSON,

    evalJSON:       NATIVE_JSON_PARSE_SUPPORT ? parseJSON : evalJSON,

    include:        include,

    startsWith:     startsWith,

    endsWith:       endsWith,

    empty:          empty,

    blank:          blank,

    interpolate:    interpolate

  };

})());

    if (object && Object.isFunction(object.toTemplateReplacements))

      if (object == null) return (match[1] + '');

      var ctx = object, expr = match[3],

          pattern = /^([^.[]+|\[((?:.*?[^\\])?)\])(\.|\[|$)/;

        var comp = match[1].startsWith('[') ? match[2].replace(/\\\\]/g, ']') : match[1];

var Enumerable = (function() {

  function each(iterator, context) {

  }

  function eachSlice(number, iterator, context) {

  }

  function all(iterator, context) {

  }

  function any(iterator, context) {

  }

  function collect(iterator, context) {

  }

  function detect(iterator, context) {

  }

  function findAll(iterator, context) {

  }

  function grep(filter, iterator, context) {

      filter = new RegExp(RegExp.escape(filter));

  }

  function include(object) {

  }

  function inGroupsOf(number, fillWith) {

  }

  function inject(memo, iterator, context) {

  }

  function invoke(method) {

  }

  function max(iterator, context) {

  }

  function min(iterator, context) {

  }

  function partition(iterator, context) {

  }

  function pluck(property) {

  }

  function reject(iterator, context) {

  }

  function sortBy(iterator, context) {

  }

  function toArray() {

  }

  function zip() {