sproutcore 1.4.0-java

data/lib/sproutcore/vendor/jsdoc/app/test/addon.js

@@ -0,0 +1,24 @@
+String.prototype.reverse = function() {
+}
+
+String.prototype.reverse.utf8 = function() {
+}
+
+Function.count = function() {
+}
+
+/** @memberOf Function */
+Function.count.reset = function() {
+}
+
+/** @memberOf Function */
+count.getValue = function() {
+}
+
+/** @memberOf Function.prototype */
+getSig = function() {
+}
+
+/** @memberOf Function.prototype */
+Function.prototype.getProps = function() {
+}

data/lib/sproutcore/vendor/jsdoc/app/test/anon_inner.js

@@ -0,0 +1,14 @@
+/**
+ * @name bar
+ * @namespace
+ */
+ 
+new function() {
+    /**
+     * @name bar-foo
+     * @function
+     * @param {number} x
+     */
+    function foo(x) {
+    }
+}

data/lib/sproutcore/vendor/jsdoc/app/test/augments.js

@@ -0,0 +1,31 @@
+/**
+@constructor
+*/
+function Layout(p) {
+	this.init = function(p) {
+	}
+	
+	this.getId = function() {
+	}
+	
+	/** @type Page */
+	this.orientation = "landscape";
+}
+
+/**
+@constructor
+@augments Layout
+*/
+function Page() {
+	this.reset = function(b) {
+	}
+}
+
+/**
+@extends Page
+@constructor
+*/
+function ThreeColumnPage() {
+	this.init = function(resetCode) {
+	}
+}

data/lib/sproutcore/vendor/jsdoc/app/test/augments2.js

@@ -0,0 +1,26 @@
+/**
+@constructor
+*/
+function LibraryItem() {
+	this.reserve = function() {
+	}
+}
+
+/**
+@constructor
+*/
+function Junkmail() {
+	this.annoy = function() {
+	}
+}
+
+/**
+@inherits Junkmail.prototype.annoy as pester
+@augments ThreeColumnPage
+@augments LibraryItem
+@constructor
+*/
+function NewsletterPage() {
+	this.getHeadline = function() {
+	}
+}

data/lib/sproutcore/vendor/jsdoc/app/test/borrows.js

@@ -0,0 +1,41 @@
+/**
+@constructor
+*/
+function Layout(p) {
+	/** initilize 1 */
+	this.init = function(p) {
+	}
+	
+	/** get the id */
+	this.getId = function() {
+	}
+	
+	/** @type string */
+	this.orientation = "landscape";
+	
+	function getInnerElements(elementSecretId){
+	}
+}
+
+/**
+@constructor
+@borrows Layout#orientation as #orientation
+@borrows Layout-getInnerElements as myGetInnerElements
+*/
+function Page() {
+	/** reset the page */
+	this.reset = function(b) {
+	}
+}
+
+/**
+@constructor
+@borrows Layout.prototype.orientation as this.orientation
+@borrows Layout.prototype.init as #init
+@inherits Page.prototype.reset as #reset
+*/
+function ThreeColumnPage() {
+	/** initilize 2 */
+	this.init = function(p) {
+	}
+}

data/lib/sproutcore/vendor/jsdoc/app/test/borrows2.js

@@ -0,0 +1,23 @@
+// testing circular borrows
+
+/**
+	@class
+	@borrows Bar#zop as this.my_zop
+*/
+function Foo() {
+	/** this is a zip. */
+	this.zip = function() {}
+	
+	this.my_zop = new Bar().zop;
+}
+
+/**
+	@class
+	@borrows Foo#zip as this.my_zip
+*/
+function Bar() {
+	/** this is a zop. */
+	this.zop = function() {}
+	
+	this.my_zip = new Foo().zip;
+}

data/lib/sproutcore/vendor/jsdoc/app/test/config.js

@@ -0,0 +1,22 @@
+/**
+ * @constructor
+ * @param person The person.
+ * @param {string} person.name The person's name.
+ * @config {integer} age The person's age.
+ * @config [id=1] Optional id number to use.
+ * @param connection
+ */
+function Contact(person, connection) {
+
+}
+
+/**
+ * @constructor
+ * @param persons
+ * @config {string} Father The paternal person.
+ * @config {string} Mother The maternal person.
+ * @config {string[]} Children And the rest.
+ */
+function Family(/**Object*/persons) {
+
+}

data/lib/sproutcore/vendor/jsdoc/app/test/constructs.js

@@ -0,0 +1,18 @@
+var Person = makeClass(
+    /**
+      @scope Person
+    */
+    {
+        /**
+        	This is just another way to define a constructor.
+        	@constructs
+        	@param {string} name The name of the person.
+         */
+        initialize: function(name) {
+            this.name = name;
+        },
+        say: function(message) {
+            return this.name + " says: " + message;
+        }
+    }
+);

data/lib/sproutcore/vendor/jsdoc/app/test/encoding.js

@@ -0,0 +1,10 @@
+
+/**
+ * @Constructor
+ * @desc 配置文件
+ * @class 什么也不返回
+ */
+function Test(conf) {
+    // do something;
+}
+

data/lib/sproutcore/vendor/jsdoc/app/test/encoding_other.js

@@ -0,0 +1,12 @@
+
+/**
+ * @Constructor
+ * @desc ����
+ * @class ����������������� �����������
+ */
+function Test(conf) {
+    // do something;
+}
+
+// run with commanline option -e=iso-8859-5
+

data/lib/sproutcore/vendor/jsdoc/app/test/functions_anon.js

@@ -0,0 +1,39 @@
+/** an anonymous constructor executed inline */
+a = new function() {
+	/** a.b*/
+    this.b = 1;
+    /** a.f */
+    this.f = function() {
+    	/** a.c */
+    	this.c = 2;
+    }
+}
+
+
+/**
+	named function executed inline
+*/
+bar1 = function Zoola1() {
+	/** property of global */
+	this.g = 1;
+}();
+
+/**
+	named constructor executed inline
+*/
+bar2 = new function Zoola2() {
+	/** property of bar */
+	this.p = 1;
+};
+
+/** module pattern */
+module = (function () {
+	/** won't appear in documentation */
+	var priv = 1;
+	
+	/** @scope module */
+	return {
+		/** will appear as a property of module */
+		pub: 1
+	}
+})();

data/lib/sproutcore/vendor/jsdoc/app/test/functions_nested.js

@@ -0,0 +1,33 @@
+/** @constructor */
+function Zop() {
+}
+
+/**
+ @class
+*/
+Foo = function(id) {
+	// this is a bit twisted, but if you call Foo() you will then
+	// modify Foo(). This is kinda, sorta non-insane, because you
+	// would have to call Foo() 100% of the time to use Foo's methods
+	Foo.prototype.methodOne = function(bar) {
+	  alert(bar);
+	};
+	
+	// same again
+	Foo.prototype.methodTwo = function(bar2) {
+	  alert(bar2);
+	};
+	
+	// and these are only executed if the enclosing function is actually called
+	// and who knows if that will ever happen?
+	Bar = function(pez) {
+	  alert(pez);
+	};
+	Zop.prototype.zap = function(p){
+		alert(p);
+	};
+	
+	// but this is only visible inside Foo
+	function inner() {
+	}
+};

data/lib/sproutcore/vendor/jsdoc/app/test/global.js

@@ -0,0 +1,13 @@
+/** ecks */
+var x = [1, 2, 4];
+
+var y = {
+	foo: function(){
+	}
+}
+
+bar = function() {
+}
+
+function zop() {
+}

data/lib/sproutcore/vendor/jsdoc/app/test/globals.js

@@ -0,0 +1,25 @@
+function example(/**Circle*/a, b) {
+	/** a global defined in function  */
+	var number = a;
+	
+	var hideNumber = function(){
+	}
+	
+	setNumber = function(){
+	}
+	alert('You have chosen: ' + b);
+}
+
+function initPage() {
+	var supported = document.createElement && document.getElementsByTagName;
+	if (!supported) return;
+	// start of DOM script
+	var x = document.getElementById('writeroot');
+	// etc.
+}
+
+/** an example var */
+var document = new Document(x, y);
+
+var getNumber = function(){
+}

data/lib/sproutcore/vendor/jsdoc/app/test/ignore.js

@@ -0,0 +1,10 @@
+/**
+ * A test constructor.
+ * @constructor
+ * @ignore
+ */
+function Ignored() {
+	/** a method */
+    this.bar = function() {
+    }
+}

data/lib/sproutcore/vendor/jsdoc/app/test/inner.js

@@ -0,0 +1,16 @@
+/**
+ * @constructor
+ */
+function Outer() {
+  /**
+   * @constructor
+   */
+  function Inner(name) {
+    /** The name of this. */
+    this.name = name;
+  }
+
+  this.open = function(name) {
+    return (new Inner(name));
+  }
+}

data/lib/sproutcore/vendor/jsdoc/app/test/jsdoc_test.js

@@ -0,0 +1,477 @@
+/** 
+ * @fileoverview This file is to be used for testing the JSDoc parser
+ * It is not intended to be an example of good JavaScript OO-programming,
+ * nor is it intended to fulfill any specific purpose apart from 
+ * demonstrating the functionality of the 
+ * <a href='http://sourceforge.net/projects/jsdoc'>JSDoc</a> parser
+ *
+ * @author Gabriel Reid gab_reid@users.sourceforge.net
+ * @version 0.1 
+ */
+
+
+/**
+ * Construct a new Shape object.
+ * @class This is the basic Shape class.  
+ * It can be considered an abstract class, even though no such thing
+ * really existing in JavaScript
+ * @constructor
+ * @throws MemoryException if there is no more memory 
+ * @throws GeneralShapeException rarely (if ever)
+ * @return {Shape|Coordinate} A new shape.
+ */
+function Shape(){
+  
+   /**
+    * This is an example of a function that is not given as a property
+    * of a prototype, but instead it is assigned within a constructor.
+    * For inner functions like this to be picked up by the parser, the
+    * function that acts as a constructor <b>must</b> be denoted with
+    * the <b>&#64;constructor</b> tag in its comment.
+    * @type String
+    */
+   this.getClassName = function(){
+      return "Shape";
+   }
+
+   /** 
+    * This is an inner method, just used here as an example
+    * @since version 0.5
+    * @author Sue Smart
+    */
+   function addReference(){
+       // Do nothing...
+   }
+   
+}
+
+/**
+ * Create a new Hexagon instance.
+ * @extends Shape
+ * @class Hexagon is a class that is a <i>logical</i> sublcass of 
+ * {@link Shape} (thanks to the <code>&#64;extends</code> tag), but in 
+ * reality it is completely unrelated to Shape.
+ * @param {int} sideLength The length of one side for the new Hexagon
+ * @example
+ * var h = new Hexagon(2);
+ * @example
+ * if (hasHex) {
+ *     hex   = new Hexagon(5);
+ *     color = hex.getColor();
+ * }
+ */
+function Hexagon(sideLength) {
+}
+
+
+/**
+ * This is an unattached (static) function that adds two integers together.
+ * @param {int} One The first number to add 
+ * @param {int} Two The second number to add 
+ * @author Gabriel Reid
+ * @deprecated So you shouldn't use it anymore!
+ */
+function Add(One, Two){
+    return One + Two;
+}
+
+
+/**
+ * The color of this shape
+ * @type Color
+ */
+Shape.prototype.color = null;
+
+/**
+ * The border of this shape. 
+ * @field
+ * @type int
+ */
+Shape.prototype.border = function(){return border;};
+
+/*
+ * These are all the instance method implementations for Shape
+ */
+
+/**
+ * Get the coordinates of this shape. It is assumed that we're always talking
+ * about shapes in a 2D location here.
+ * @requires The {@link Shape} class
+ * @returns A Coordinate object representing the location of this Shape
+ * @type Coordinate[]
+ */
+Shape.prototype.getCoords = function(){
+   return this.coords;
+}
+
+/**
+ * Get the color of this shape.
+ * @see #setColor
+ * @see The <a href="http://example.com">Color</a> library.
+ * @link Shape
+ * @type Color
+ */
+Shape.prototype.getColor = function(){
+   return this.color;
+}
+
+/**
+ * Set the coordinates for this Shape
+ * @param {Coordinate} coordinates The coordinates to set for this Shape
+ */
+Shape.prototype.setCoords = function(coordinates){
+   this.coords = coordinates;
+}
+
+/**
+ * Set the color for this Shape
+ * @param {Color} color The color to set for this Shape
+ * @param other There is no other param, but it can still be documented if
+ *              optional parameters are used
+ * @throws NonExistantColorException (no, not really!)
+ * @see #getColor
+ */
+Shape.prototype.setColor = function(color){
+   this.color = color;
+}
+
+/**
+ * Clone this shape
+ * @returns A copy of this shape
+ * @type Shape
+ * @author Gabriel Reid
+ */
+Shape.prototype.clone = function(){
+   return new Shape();
+}
+
+/**
+ * Create a new Rectangle instance. 
+ * @class A basic rectangle class, inherits from Shape.
+ * This class could be considered a concrete implementation class
+ * @constructor
+ * @param {int} width The optional width for this Rectangle
+ * @param {int} height Thie optional height for this Rectangle
+ * @author Gabriel Reid
+ * @see Shape is the base class for this
+ * @augments Shape
+ * @hilited
+ */
+function Rectangle(width, // This is the width 
+                  height // This is the height
+                  ){
+   if (width){
+      this.width = width;
+      if (height){
+	 this.height = height;
+      }
+   }
+}
+
+
+/* Inherit from Shape */
+Rectangle.prototype = new Shape();
+
+/**
+ * Value to represent the width of the Rectangle.
+ * <br>Text in <b>bold</b> and <i>italic</i> and a 
+ * link to <a href="http://sf.net">SourceForge</a>
+ * @private
+ * @type int
+ */
+Rectangle.prototype.width = 0;
+
+/**
+ * Value to represent the height of the Rectangle
+ * @private
+ * @type int
+ */
+Rectangle.prototype.height = 0;
+
+/**
+ * Get the type of this object. 
+ * @type String
+ */
+Rectangle.prototype.getClassName= function(){
+    return "Rectangle";
+}
+
+/**
+ * Get the value of the width for the Rectangle
+ * @type int
+ * @see Rectangle#setWidth
+ */
+Rectangle.prototype.getWidth = function(){
+   return this.width;
+}
+
+/**
+ * Get the value of the height for the Rectangle.
+ * Another getter is the {@link Shape#getColor} method in the 
+ * {@link Shape} base class.  
+ * @return The height of this Rectangle
+ * @type int
+ * @see Rectangle#setHeight
+ */
+Rectangle.prototype.getHeight = function(){
+    return this.height;
+}
+
+/**
+ * Set the width value for this Rectangle.
+ * @param {int} width The width value to be set
+ * @see #setWidth
+ */
+Rectangle.prototype.setWidth = function(width){
+   this.width = width;
+}
+
+/**
+ * Set the height value for this Rectangle.
+ * @param {int} height The height value to be set
+ * @see #getHeight
+ */
+Rectangle.prototype.setHeight = function(height){
+   this.height = height;
+}
+
+/**
+ * Get the value for the total area of this Rectangle
+ * @return total area of this Rectangle
+ * @type int
+ */
+Rectangle.prototype.getArea = function(){
+   return width * height;
+}
+
+
+/**
+ * Create a new Square instance.
+ * @class A Square is a subclass of {@link Rectangle}
+ * @param {int} width The optional width for this Rectangle
+ * @param {int} height The optional height for this Rectangle
+ * @augments Rectangle
+ */
+function Square(width, height){
+   if (width){
+      this.width = width;
+      if (height){
+	 this.height = height;
+      }
+   } 
+   
+}
+
+/* Square is a subclass of Rectangle */
+Square.prototype = new Rectangle();
+
+/**
+ * Set the width value for this Shape.
+ * @param {int} width The width value to be set
+ * @see #getWidth
+ */
+Square.prototype.setWidth = function(width){
+   this.width = this.height = width;
+}
+
+/**
+ * Set the height value for this Shape 
+ * Sets the {@link Rectangle#height} attribute in the Rectangle.
+ * @param {int} height The height value to be set
+ */
+Square.prototype.setHeight = function(height){
+   this.height = this.width = height;
+}
+
+
+/**
+ * Create a new Circle instance based on a radius.
+ * @class Circle class is another subclass of Shape
+ * @extends Shape
+ * @param {int} radius The optional radius of this {@link Circle }
+ * @mixin Square.prototype.setWidth as this.setDiameter
+ */
+function Circle(radius){
+   if (radius) {
+      /** The radius of the this Circle. */
+      this.radius = radius;
+   }
+}
+
+/* Circle inherits from {@link Shape} */
+Circle.prototype = new Shape();
+
+/** 
+ * The radius value for this Circle 
+ * @private
+ * @type int
+ */
+Circle.prototype.radius = 0;
+
+/** 
+ * A very simple class (static) field that is also a constant
+ * @final
+ * @type float
+ */
+Circle.PI = 3.14;
+
+/**
+ * Get the radius value for this Circle
+ * @type int
+ * @see #setRadius
+ */
+Circle.prototype.getRadius = function(){
+   return this.radius;
+}
+
+/** 
+ * Set the radius value for this Circle
+ * @param {int} radius The {@link Circle#radius} value to set
+ * @see #getRadius
+ */
+Circle.prototype.setRadius = function(radius){
+   this.radius = radius;
+}
+
+/** 
+ * An example of a  class (static) method that acts as a factory for Circle
+ * objects. Given a radius value, this method creates a new Circle.
+ * @param {int} radius The radius value to use for the new Circle.
+ * @type Circle
+ */
+Circle.createCircle = function(radius){
+    return new Circle(radius);
+}
+
+
+/**
+ * Create a new Coordinate instance based on x and y grid data.
+ * @class Coordinate is a class that can encapsulate location information.
+ * @param {int} [x=0] The optional x portion of the Coordinate
+ * @param {int} [y=0] The optinal y portion of the Coordinate
+ */
+function Coordinate(x, y){
+   if (x){
+      this.x = x;
+      if (y){
+	 this.y = y;
+      }
+   }
+}
+
+/** 
+ * The x portion of the Coordinate 
+ * @type int
+ * @see #getX
+ * @see #setX
+ */
+Coordinate.prototype.x = 0;
+
+/** 
+ * The y portion of the Coordinate 
+ * @type int
+ * @see #getY
+ * @see #setY
+ */
+Coordinate.prototype.y = 0;
+
+/**
+ * Gets the x portion of the Coordinate.
+ * @type int
+ * @see #setX
+ */
+Coordinate.prototype.getX = function(){
+   return this.x;
+}
+
+/** 
+ * Get the y portion of the Coordinate.
+ * @type int
+ * @see #setY
+ */
+Coordinate.prototype.getY = function(){
+   return this.y;
+}
+
+/**
+ * Sets the x portion of the Coordinate.
+ * @param {int} x The x value to set
+ * @see #getX
+ */
+Coordinate.prototype.setX = function(x){
+   this.x = x;
+}
+
+/** 
+ * Sets the y portion of the Coordinate.
+ * @param {int} y The y value to set
+ * @see #getY
+ */
+Coordinate.prototype.setY = function(y){
+   this.y = y;
+}
+
+/**
+ * @class This class exists to demonstrate the assignment of a class prototype
+ * as an anonymous block.
+ */
+function ShapeFactory(){
+}
+
+ShapeFactory.prototype = {
+   /** 
+    * Creates a new {@link Shape} instance.
+    * @return A new {@link Shape}
+    * @type Shape
+    */
+   createShape: function(){
+      return new Shape();
+   }
+}
+
+/**
+ * An example of a singleton class
+ * @param ... Arguments represent {@link coordinate}s in the shape.
+ * @constructor
+ */
+MySingletonShapeFactory = function(){
+
+   /**
+    * Get the next {@link Shape}
+    * @type Shape
+    * @return A new {@link Shape}
+    */
+   this.getShape = function(){ 
+      return null; 
+   }
+
+}
+
+
+/** 
+ * Create a new Foo instance.
+ * @class This is the Foo class. It exists to demonstrate 'nested' classes.
+ * @constructor 
+ * @see Foo.Bar
+ */
+function Foo(){}
+
+/** 
+ * Creates a new instance of Bar.
+ * @class This class exists to demonstrate 'nested' classes.
+ * @constructor 
+ * @see Foo.Bar
+ */
+function Bar(){}
+
+/** 
+ * Nested class
+ * @constructor 
+ */
+Foo.Bar = function(){
+	/** The x. */ this.x = 2;
+}
+
+Foo.Bar.prototype = new Bar();
+/** The y. */ 
+Foo.Bar.prototype.y = '3';