//---------------------new object----------------------------------------
/*
    Base Start here
*/
    var Prototype = {
      Version: '1.4.0',
      ScriptFragment: '(?:<script.*?>)((\n|\r|.)*?)(?:<\/script>)',

      emptyFunction: function() {},
      K: function(x) {return x}
    }

    var Class = {
	    create: function() {
		    return function() {
			    if(typeof this.initialize == "function")
				    this.initialize.apply(this, arguments);
		    }
	    }
    }

    var Abstract = new Object();

    var Try = {
      these: function() {
        var returnValue;

        for (var i = 0; i < arguments.length; i++) {
          var lambda = arguments[i];
          try {
            returnValue = lambda();
            break;
          } catch (e) {}
        }

        return returnValue;
      }
    }

    //
    function $() {
      var elements = new Array();

      for (var i = 0; i < arguments.length; i++) {
        var element = arguments[i];
        if (typeof element == 'string')
          element = document.getElementById(element);

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

        elements.push(element);
      }

      return elements;
    }
    
/*
    Base End here
*/


/*
    Function Start here
*/

    Function.prototype.bind = function() {
      var __method = this, args = $A(arguments), object = args.shift();
      return function() {
        return __method.apply(object, args.concat($A(arguments)));
      }
    }

    Function.prototype.bindAsEventListener = function(object) {
      var __method = this;
      return function(event) {
        return __method.call(object, event || window.event);
      }
    }
/*
    Function End here
*/





/*
    Object Start here
*/
    Object.extend = function(destination, source) {
      for (property in source) {
        destination[property] = source[property];
      }
      return destination;
    }

    //Object.prototype.extend = function(o) {
    //	return Object.extend.apply(this, [this, o]);
    //}

    Object.inspect = function(object) {
      try {
        if (object == undefined) return 'undefined';
        if (object == null) return 'null';
        return object.inspect ? object.inspect() : object.toString();
      } catch (e) {
        if (e instanceof RangeError) return '...';
        throw e;
      }
    }


    Object.prototype.Clone=function(){
     function CloneModel(){
      
     }
     CloneModel.prototype=this;
     var objClone=new  CloneModel();
     
     var strMsg="";
     for( v in objClone){ 
      switch (typeof objClone[v]){
       case "function":
        //如果是方法，不需要進行clone
        break;
       case "object":
      
        objClone[v]=objClone[v].Clone();
        break;
       default:
      
        objClone[v]=objClone[v];
      }   
     }
     return objClone;
    }
/*
    Object End here
*/



/*
    Array Start here
*/
    Object.extend(Array.prototype, Enumerable);


    Object.extend(Array.prototype, {
      _each: function(iterator) {
        for (var i = 0; i < this.length; i++)
          iterator(this[i]);
      },

      clear: function() {
        this.length = 0;
        return this;
      },

      first: function() {
        return this[0];
      },

      last: function() {
        return this[this.length - 1];
      },

      compact: function() {
        return this.select(function(value) {
          return value != undefined || value != null;
        });
      },

      flatten: function() {
        return this.inject([], function(array, value) {
          return array.concat(value.constructor == Array ?
            value.flatten() : [value]);
        });
      },

      without: function() {
        var values = $A(arguments);
        return this.select(function(value) {
          return !values.include(value);
        });
      },

      indexOf: function(object) {
        for (var i = 0; i < this.length; i++)
          if (this[i] == object) return i;
        return -1;
      },

      reverse: function(inline) {
        return (inline !== false ? this : this.toArray())._reverse();
      },

      shift: function() {
        var result = this[0];
        for (var i = 0; i < this.length - 1; i++)
          this[i] = this[i + 1];
        this.length--;
        return result;
      },

      inspect: function() {
        return '[' + this.map(Object.inspect).join(', ') + ']';
      }
    });

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

    var $A = Array.from = function(iterable) {
      if (!iterable) return [];
      if (iterable.toArray) {
        return iterable.toArray();
      } else {
        var results = [];
        for (var i = 0; i < iterable.length; i++)
          results.push(iterable[i]);
        return results;
      }
    }


/*
    Array End here
*/




/*
    Enumerable Start here
*/
    var $break    = new Object();
    var $continue = new Object();

    var Enumerable = {
      each: function(iterator) {
        var index = 0;
        try {
          this._each(function(value) {
            try {
              iterator(value, index++);
            } catch (e) {
              if (e != $continue) throw e;
            }
          });
        } catch (e) {
          if (e != $break) throw e;
        }
      },

      all: function(iterator) {
        var result = true;
        this.each(function(value, index) {
          result = result && !!(iterator || Prototype.K)(value, index);
          if (!result) throw $break;
        });
        return result;
      },

      any: function(iterator) {
        var result = true;
        this.each(function(value, index) {
          if (result = !!(iterator || Prototype.K)(value, index))
            throw $break;
        });
        return result;
      },

      collect: function(iterator) {
        var results = [];
        this.each(function(value, index) {
          results.push(iterator(value, index));
        });
        return results;
      },

      detect: function (iterator) {
        var result;
        this.each(function(value, index) {
          if (iterator(value, index)) {
            result = value;
            throw $break;
          }
        });
        return result;
      },

      findAll: function(iterator) {
        var results = [];
        this.each(function(value, index) {
          if (iterator(value, index))
            results.push(value);
        });
        return results;
      },

      grep: function(pattern, iterator) {
        var results = [];
        this.each(function(value, index) {
          var stringValue = value.toString();
          if (stringValue.match(pattern))
            results.push((iterator || Prototype.K)(value, index));
        })
        return results;
      },

      include: function(object) {
        var found = false;
        this.each(function(value) {
          if (value == object) {
            found = true;
            throw $break;
          }
        });
        return found;
      },

      inject: function(memo, iterator) {
        this.each(function(value, index) {
          memo = iterator(memo, value, index);
        });
        return memo;
      },

      invoke: function(method) {
        var args = $A(arguments).slice(1);
        return this.collect(function(value) {
          return value[method].apply(value, args);
        });
      },

      max: function(iterator) {
        var result;
        this.each(function(value, index) {
          value = (iterator || Prototype.K)(value, index);
          if (value >= (result || value))
            result = value;
        });
        return result;
      },

      min: function(iterator) {
        var result;
        this.each(function(value, index) {
          value = (iterator || Prototype.K)(value, index);
          if (value <= (result || value))
            result = value;
        });
        return result;
      },

      partition: function(iterator) {
        var trues = [], falses = [];
        this.each(function(value, index) {
          ((iterator || Prototype.K)(value, index) ?
            trues : falses).push(value);
        });
        return [trues, falses];
      },

      pluck: function(property) {
        var results = [];
        this.each(function(value, index) {
          results.push(value[property]);
        });
        return results;
      },

      reject: function(iterator) {
        var results = [];
        this.each(function(value, index) {
          if (!iterator(value, index))
            results.push(value);
        });
        return results;
      },

      sortBy: function(iterator) {
        return this.collect(function(value, index) {
          return {value: value, criteria: iterator(value, index)};
        }).sort(function(left, right) {
          var a = left.criteria, b = right.criteria;
          return a < b ? -1 : a > b ? 1 : 0;
        }).pluck('value');
      },

      toArray: function() {
        return this.collect(Prototype.K);
      },

      zip: function() {
        var iterator = Prototype.K, args = $A(arguments);
        if (typeof args.last() == 'function')
          iterator = args.pop();

        var collections = [this].concat(args).map($A);
        return this.map(function(value, index) {
          iterator(value = collections.pluck(index));
          return value;
        });
      },

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



    Object.extend(Enumerable, {