You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@flex.apache.org by ft...@apache.org on 2015/09/17 17:28:26 UTC
[11/51] [abbrv] [partial] git commit: [flex-falcon]
[refs/heads/JsToAs] - Added GCL extern.
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/graphics/element.js
----------------------------------------------------------------------
diff --git a/externs/GCL/externs/goog/graphics/element.js b/externs/GCL/externs/goog/graphics/element.js
new file mode 100644
index 0000000..5a7bc8f
--- /dev/null
+++ b/externs/GCL/externs/goog/graphics/element.js
@@ -0,0 +1,164 @@
+// Copyright 2007 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+
+/**
+ * @fileoverview A thin wrapper around the DOM element returned from
+ * the different draw methods of the graphics implementation, and
+ * all interfaces that the various element types support.
+ * @author arv@google.com (Erik Arvidsson)
+ */
+
+
+goog.provide('goog.graphics.Element');
+
+goog.require('goog.asserts');
+goog.require('goog.events');
+goog.require('goog.events.EventTarget');
+goog.require('goog.events.Listenable');
+goog.require('goog.graphics.AffineTransform');
+goog.require('goog.math');
+
+
+
+/**
+ * Base class for a thin wrapper around the DOM element returned from
+ * the different draw methods of the graphics.
+ * You should not construct objects from this constructor. The graphics
+ * will return the object for you.
+ * @param {Element} element The DOM element to wrap.
+ * @param {goog.graphics.AbstractGraphics} graphics The graphics creating
+ * this element.
+ * @constructor
+ * @extends {goog.events.EventTarget}
+ * @deprecated goog.graphics is deprecated. It existed to abstract over browser
+ * differences before the canvas tag was widely supported. See
+ * http://en.wikipedia.org/wiki/Canvas_element for details.
+ */
+goog.graphics.Element = function(element, graphics) {
+ goog.events.EventTarget.call(this);
+ this.element_ = element;
+ this.graphics_ = graphics;
+ // Overloading EventTarget field to state that this is not a custom event.
+ // TODO(user) Should be handled in EventTarget.js (see bug 846824).
+ this[goog.events.Listenable.IMPLEMENTED_BY_PROP] = false;
+};
+goog.inherits(goog.graphics.Element, goog.events.EventTarget);
+
+
+/**
+ * The graphics object that contains this element.
+ * @type {goog.graphics.AbstractGraphics?}
+ * @private
+ */
+goog.graphics.Element.prototype.graphics_ = null;
+
+
+/**
+ * The native browser element this class wraps.
+ * @type {Element}
+ * @private
+ */
+goog.graphics.Element.prototype.element_ = null;
+
+
+/**
+ * The transformation applied to this element.
+ * @type {goog.graphics.AffineTransform?}
+ * @private
+ */
+goog.graphics.Element.prototype.transform_ = null;
+
+
+/**
+ * Returns the underlying object.
+ * @return {Element} The underlying element.
+ */
+goog.graphics.Element.prototype.getElement = function() {
+ return this.element_;
+};
+
+
+/**
+ * Returns the graphics.
+ * @return {goog.graphics.AbstractGraphics} The graphics that created the
+ * element.
+ */
+goog.graphics.Element.prototype.getGraphics = function() {
+ return this.graphics_;
+};
+
+
+/**
+ * Set the translation and rotation of the element.
+ *
+ * If a more general affine transform is needed than this provides
+ * (e.g. skew and scale) then use setTransform.
+ * @param {number} x The x coordinate of the translation transform.
+ * @param {number} y The y coordinate of the translation transform.
+ * @param {number} rotate The angle of the rotation transform.
+ * @param {number} centerX The horizontal center of the rotation transform.
+ * @param {number} centerY The vertical center of the rotation transform.
+ */
+goog.graphics.Element.prototype.setTransformation = function(x, y, rotate,
+ centerX, centerY) {
+ this.transform_ = goog.graphics.AffineTransform.getRotateInstance(
+ goog.math.toRadians(rotate), centerX, centerY).translate(x, y);
+ this.getGraphics().setElementTransform(this, x, y, rotate, centerX, centerY);
+};
+
+
+/**
+ * @return {!goog.graphics.AffineTransform} The transformation applied to
+ * this element.
+ */
+goog.graphics.Element.prototype.getTransform = function() {
+ return this.transform_ ? this.transform_.clone() :
+ new goog.graphics.AffineTransform();
+};
+
+
+/**
+ * Set the affine transform of the element.
+ * @param {!goog.graphics.AffineTransform} affineTransform The
+ * transformation applied to this element.
+ */
+goog.graphics.Element.prototype.setTransform = function(affineTransform) {
+ this.transform_ = affineTransform.clone();
+ this.getGraphics().setElementAffineTransform(this, affineTransform);
+};
+
+
+/** @override */
+goog.graphics.Element.prototype.addEventListener = function(
+ type, handler, opt_capture, opt_handlerScope) {
+ goog.events.listen(this.element_, type, handler, opt_capture,
+ opt_handlerScope);
+};
+
+
+/** @override */
+goog.graphics.Element.prototype.removeEventListener = function(
+ type, handler, opt_capture, opt_handlerScope) {
+ goog.events.unlisten(this.element_, type, handler, opt_capture,
+ opt_handlerScope);
+};
+
+
+/** @override */
+goog.graphics.Element.prototype.disposeInternal = function() {
+ goog.graphics.Element.superClass_.disposeInternal.call(this);
+ goog.asserts.assert(this.element_);
+ goog.events.removeAll(this.element_);
+};
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/graphics/ellipseelement.js
----------------------------------------------------------------------
diff --git a/externs/GCL/externs/goog/graphics/ellipseelement.js b/externs/GCL/externs/goog/graphics/ellipseelement.js
new file mode 100644
index 0000000..975b462
--- /dev/null
+++ b/externs/GCL/externs/goog/graphics/ellipseelement.js
@@ -0,0 +1,63 @@
+// Copyright 2007 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+
+/**
+ * @fileoverview A thin wrapper around the DOM element for ellipses.
+ * @author arv@google.com (Erik Arvidsson)
+ */
+
+
+goog.provide('goog.graphics.EllipseElement');
+
+goog.require('goog.graphics.StrokeAndFillElement');
+
+
+
+/**
+ * Interface for a graphics ellipse element.
+ * You should not construct objects from this constructor. The graphics
+ * will return an implementation of this interface for you.
+ * @param {Element} element The DOM element to wrap.
+ * @param {goog.graphics.AbstractGraphics} graphics The graphics creating
+ * this element.
+ * @param {goog.graphics.Stroke?} stroke The stroke to use for this element.
+ * @param {goog.graphics.Fill?} fill The fill to use for this element.
+ * @constructor
+ * @extends {goog.graphics.StrokeAndFillElement}
+ * @deprecated goog.graphics is deprecated. It existed to abstract over browser
+ * differences before the canvas tag was widely supported. See
+ * http://en.wikipedia.org/wiki/Canvas_element for details.
+ */
+goog.graphics.EllipseElement = function(element, graphics, stroke, fill) {
+ goog.graphics.StrokeAndFillElement.call(this, element, graphics, stroke,
+ fill);
+};
+goog.inherits(goog.graphics.EllipseElement, goog.graphics.StrokeAndFillElement);
+
+
+/**
+ * Update the center point of the ellipse.
+ * @param {number} cx Center X coordinate.
+ * @param {number} cy Center Y coordinate.
+ */
+goog.graphics.EllipseElement.prototype.setCenter = goog.abstractMethod;
+
+
+/**
+ * Update the radius of the ellipse.
+ * @param {number} rx Radius length for the x-axis.
+ * @param {number} ry Radius length for the y-axis.
+ */
+goog.graphics.EllipseElement.prototype.setRadius = goog.abstractMethod;
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/graphics/ext/coordinates.js
----------------------------------------------------------------------
diff --git a/externs/GCL/externs/goog/graphics/ext/coordinates.js b/externs/GCL/externs/goog/graphics/ext/coordinates.js
new file mode 100644
index 0000000..42385fe
--- /dev/null
+++ b/externs/GCL/externs/goog/graphics/ext/coordinates.js
@@ -0,0 +1,159 @@
+// Copyright 2007 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+
+/**
+ * @fileoverview Graphics utility functions for advanced coordinates.
+ *
+ * This file assists the use of advanced coordinates in goog.graphics. Coords
+ * can be specified as simple numbers which will correspond to units in the
+ * graphics element's coordinate space. Alternately, coords can be expressed
+ * in pixels, meaning no matter what tranformations or coordinate system changes
+ * are present, the number of pixel changes will remain constant. Coords can
+ * also be expressed as percentages of their parent's size.
+ *
+ * This file also allows for elements to have margins, expressable in any of
+ * the ways described above.
+ *
+ * Additional pieces of advanced coordinate functionality can (soon) be found in
+ * element.js and groupelement.js.
+ *
+ * @author robbyw@google.com (Robby Walker)
+ */
+
+goog.provide('goog.graphics.ext.coordinates');
+
+goog.require('goog.string');
+
+
+/**
+ * Cache of boolean values. For a given string (key), is it special? (value)
+ * @type {Object}
+ * @private
+ */
+goog.graphics.ext.coordinates.specialCoordinateCache_ = {};
+
+
+/**
+ * Determines if the given coordinate is a percent based coordinate or an
+ * expression with a percent based component.
+ * @param {string} coord The coordinate to test.
+ * @return {boolean} Whether the coordinate contains the string '%'.
+ * @private
+ */
+goog.graphics.ext.coordinates.isPercent_ = function(coord) {
+ return goog.string.contains(coord, '%');
+};
+
+
+/**
+ * Determines if the given coordinate is a pixel based coordinate or an
+ * expression with a pixel based component.
+ * @param {string} coord The coordinate to test.
+ * @return {boolean} Whether the coordinate contains the string 'px'.
+ * @private
+ */
+goog.graphics.ext.coordinates.isPixels_ = function(coord) {
+ return goog.string.contains(coord, 'px');
+};
+
+
+/**
+ * Determines if the given coordinate is special - i.e. not just a number.
+ * @param {string|number|null} coord The coordinate to test.
+ * @return {boolean} Whether the coordinate is special.
+ */
+goog.graphics.ext.coordinates.isSpecial = function(coord) {
+ var cache = goog.graphics.ext.coordinates.specialCoordinateCache_;
+
+ if (!(coord in cache)) {
+ cache[coord] = goog.isString(coord) && (
+ goog.graphics.ext.coordinates.isPercent_(coord) ||
+ goog.graphics.ext.coordinates.isPixels_(coord));
+ }
+
+ return cache[coord];
+};
+
+
+/**
+ * Returns the value of the given expression in the given context.
+ *
+ * Should be treated as package scope.
+ *
+ * @param {string|number} coord The coordinate to convert.
+ * @param {number} size The size of the parent element.
+ * @param {number} scale The ratio of pixels to units.
+ * @return {number} The number of coordinate space units that corresponds to
+ * this coordinate.
+ */
+goog.graphics.ext.coordinates.computeValue = function(coord, size, scale) {
+ var number = parseFloat(String(coord));
+ if (goog.isString(coord)) {
+ if (goog.graphics.ext.coordinates.isPercent_(coord)) {
+ return number * size / 100;
+ } else if (goog.graphics.ext.coordinates.isPixels_(coord)) {
+ return number / scale;
+ }
+ }
+
+ return number;
+};
+
+
+/**
+ * Converts the given coordinate to a number value in units.
+ *
+ * Should be treated as package scope.
+ *
+ * @param {string|number} coord The coordinate to retrieve the value for.
+ * @param {boolean|undefined} forMaximum Whether we are computing the largest
+ * value this coordinate would be in a parent of no size. The container
+ * size in this case should be set to the size of the current element.
+ * @param {number} containerSize The unit value of the size of the container of
+ * this element. Should be set to the minimum width of this element if
+ * forMaximum is true.
+ * @param {number} scale The ratio of pixels to units.
+ * @param {Object=} opt_cache Optional (but highly recommend) object to store
+ * cached computations in. The calling class should manage clearing out
+ * the cache when the scale or containerSize changes.
+ * @return {number} The correct number of coordinate space units.
+ */
+goog.graphics.ext.coordinates.getValue = function(coord, forMaximum,
+ containerSize, scale, opt_cache) {
+ if (!goog.isNumber(coord)) {
+ var cacheString = opt_cache && ((forMaximum ? 'X' : '') + coord);
+
+ if (opt_cache && cacheString in opt_cache) {
+ coord = opt_cache[cacheString];
+ } else {
+ if (goog.graphics.ext.coordinates.isSpecial(
+ /** @type {string} */ (coord))) {
+ coord = goog.graphics.ext.coordinates.computeValue(coord,
+ containerSize, scale);
+ } else {
+ // Simple coordinates just need to be converted from a string to a
+ // number.
+ coord = parseFloat(/** @type {string} */ (coord));
+ }
+
+ // Cache the result.
+ if (opt_cache) {
+ opt_cache[cacheString] = coord;
+ }
+ }
+ }
+
+ return coord;
+};
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/graphics/ext/element.js
----------------------------------------------------------------------
diff --git a/externs/GCL/externs/goog/graphics/ext/element.js b/externs/GCL/externs/goog/graphics/ext/element.js
new file mode 100644
index 0000000..546c8c3
--- /dev/null
+++ b/externs/GCL/externs/goog/graphics/ext/element.js
@@ -0,0 +1,963 @@
+// Copyright 2007 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/**
+ * @fileoverview A thicker wrapper around the DOM element returned from
+ * the different draw methods of the graphics implementation, and
+ * all interfaces that the various element types support.
+ * @author robbyw@google.com (Robby Walker)
+ */
+
+goog.provide('goog.graphics.ext.Element');
+
+goog.require('goog.events.EventTarget');
+goog.require('goog.functions');
+goog.require('goog.graphics.ext.coordinates');
+
+
+
+/**
+ * Base class for a wrapper around the goog.graphics wrapper that enables
+ * more advanced functionality.
+ * @param {goog.graphics.ext.Group?} group Parent for this element.
+ * @param {goog.graphics.Element} wrapper The thin wrapper to wrap.
+ * @constructor
+ * @extends {goog.events.EventTarget}
+ */
+goog.graphics.ext.Element = function(group, wrapper) {
+ goog.events.EventTarget.call(this);
+ this.wrapper_ = wrapper;
+ this.graphics_ = group ? group.getGraphics() : this;
+
+ this.xPosition_ = new goog.graphics.ext.Element.Position_(this, true);
+ this.yPosition_ = new goog.graphics.ext.Element.Position_(this, false);
+
+ // Handle parent / child relationships.
+ if (group) {
+ this.parent_ = group;
+ this.parent_.addChild(this);
+ }
+};
+goog.inherits(goog.graphics.ext.Element, goog.events.EventTarget);
+
+
+/**
+ * The graphics object that contains this element.
+ * @type {goog.graphics.ext.Graphics|goog.graphics.ext.Element}
+ * @private
+ */
+goog.graphics.ext.Element.prototype.graphics_;
+
+
+/**
+ * The goog.graphics wrapper this class wraps.
+ * @type {goog.graphics.Element}
+ * @private
+ */
+goog.graphics.ext.Element.prototype.wrapper_;
+
+
+/**
+ * The group or surface containing this element.
+ * @type {goog.graphics.ext.Group|undefined}
+ * @private
+ */
+goog.graphics.ext.Element.prototype.parent_;
+
+
+/**
+ * Whether or not computation of this element's position or size depends on its
+ * parent's size.
+ * @type {boolean}
+ * @private
+ */
+goog.graphics.ext.Element.prototype.parentDependent_ = false;
+
+
+/**
+ * Whether the element has pending transformations.
+ * @type {boolean}
+ * @private
+ */
+goog.graphics.ext.Element.prototype.needsTransform_ = false;
+
+
+/**
+ * The current angle of rotation, expressed in degrees.
+ * @type {number}
+ * @private
+ */
+goog.graphics.ext.Element.prototype.rotation_ = 0;
+
+
+/**
+ * Object representing the x position and size of the element.
+ * @type {goog.graphics.ext.Element.Position_}
+ * @private
+ */
+goog.graphics.ext.Element.prototype.xPosition_;
+
+
+/**
+ * Object representing the y position and size of the element.
+ * @type {goog.graphics.ext.Element.Position_}
+ * @private
+ */
+goog.graphics.ext.Element.prototype.yPosition_;
+
+
+/** @return {goog.graphics.Element} The underlying thin wrapper. */
+goog.graphics.ext.Element.prototype.getWrapper = function() {
+ return this.wrapper_;
+};
+
+
+/**
+ * @return {goog.graphics.ext.Element|goog.graphics.ext.Graphics} The graphics
+ * surface the element is a part of.
+ */
+goog.graphics.ext.Element.prototype.getGraphics = function() {
+ return this.graphics_;
+};
+
+
+/**
+ * Returns the graphics implementation.
+ * @return {goog.graphics.AbstractGraphics} The underlying graphics
+ * implementation drawing this element's wrapper.
+ * @protected
+ */
+goog.graphics.ext.Element.prototype.getGraphicsImplementation = function() {
+ return this.graphics_.getImplementation();
+};
+
+
+/**
+ * @return {goog.graphics.ext.Group|undefined} The parent of this element.
+ */
+goog.graphics.ext.Element.prototype.getParent = function() {
+ return this.parent_;
+};
+
+
+// GENERAL POSITIONING
+
+
+/**
+ * Internal convenience method for setting position - either as a left/top,
+ * center/middle, or right/bottom value. Only one should be specified.
+ * @param {goog.graphics.ext.Element.Position_} position The position object to
+ * set the value on.
+ * @param {number|string} value The value of the coordinate.
+ * @param {goog.graphics.ext.Element.PositionType_} type The type of the
+ * coordinate.
+ * @param {boolean=} opt_chain Optional flag to specify this function is part
+ * of a chain of calls and therefore transformations should be set as
+ * pending but not yet performed.
+ * @private
+ */
+goog.graphics.ext.Element.prototype.setPosition_ = function(position, value,
+ type, opt_chain) {
+ position.setPosition(value, type);
+ this.computeIsParentDependent_(position);
+
+ this.needsTransform_ = true;
+ if (!opt_chain) {
+ this.transform();
+ }
+};
+
+
+/**
+ * Sets the width/height of the element.
+ * @param {goog.graphics.ext.Element.Position_} position The position object to
+ * set the value on.
+ * @param {string|number} size The new width/height value.
+ * @param {boolean=} opt_chain Optional flag to specify this function is part
+ * of a chain of calls and therefore transformations should be set as
+ * pending but not yet performed.
+ * @private
+ */
+goog.graphics.ext.Element.prototype.setSize_ = function(position, size,
+ opt_chain) {
+ if (position.setSize(size)) {
+ this.needsTransform_ = true;
+
+ this.computeIsParentDependent_(position);
+
+ if (!opt_chain) {
+ this.reset();
+ }
+ } else if (!opt_chain && this.isPendingTransform()) {
+ this.reset();
+ }
+};
+
+
+/**
+ * Sets the minimum width/height of the element.
+ * @param {goog.graphics.ext.Element.Position_} position The position object to
+ * set the value on.
+ * @param {string|number} minSize The minimum width/height of the element.
+ * @private
+ */
+goog.graphics.ext.Element.prototype.setMinSize_ = function(position, minSize) {
+ position.setMinSize(minSize);
+ this.needsTransform_ = true;
+ this.computeIsParentDependent_(position);
+};
+
+
+// HORIZONTAL POSITIONING
+
+
+/**
+ * @return {number} The distance from the left edge of this element to the left
+ * edge of its parent, specified in units of the parent's coordinate system.
+ */
+goog.graphics.ext.Element.prototype.getLeft = function() {
+ return this.xPosition_.getStart();
+};
+
+
+/**
+ * Sets the left coordinate of the element. Overwrites any previous value of
+ * left, center, or right for this element.
+ * @param {string|number} left The left coordinate.
+ * @param {boolean=} opt_chain Optional flag to specify this function is part
+ * of a chain of calls and therefore transformations should be set as
+ * pending but not yet performed.
+ */
+goog.graphics.ext.Element.prototype.setLeft = function(left, opt_chain) {
+ this.setPosition_(this.xPosition_,
+ left,
+ goog.graphics.ext.Element.PositionType_.START,
+ opt_chain);
+};
+
+
+/**
+ * @return {number} The right coordinate of the element, in units of the
+ * parent's coordinate system.
+ */
+goog.graphics.ext.Element.prototype.getRight = function() {
+ return this.xPosition_.getEnd();
+};
+
+
+/**
+ * Sets the right coordinate of the element. Overwrites any previous value of
+ * left, center, or right for this element.
+ * @param {string|number} right The right coordinate.
+ * @param {boolean=} opt_chain Optional flag to specify this function is part
+ * of a chain of calls and therefore transformations should be set as
+ * pending but not yet performed.
+ */
+goog.graphics.ext.Element.prototype.setRight = function(right, opt_chain) {
+ this.setPosition_(this.xPosition_,
+ right,
+ goog.graphics.ext.Element.PositionType_.END,
+ opt_chain);
+};
+
+
+/**
+ * @return {number} The center coordinate of the element, in units of the
+ * parent's coordinate system.
+ */
+goog.graphics.ext.Element.prototype.getCenter = function() {
+ return this.xPosition_.getMiddle();
+};
+
+
+/**
+ * Sets the center coordinate of the element. Overwrites any previous value of
+ * left, center, or right for this element.
+ * @param {string|number} center The center coordinate.
+ * @param {boolean=} opt_chain Optional flag to specify this function is part
+ * of a chain of calls and therefore transformations should be set as
+ * pending but not yet performed.
+ */
+goog.graphics.ext.Element.prototype.setCenter = function(center, opt_chain) {
+ this.setPosition_(this.xPosition_,
+ center,
+ goog.graphics.ext.Element.PositionType_.MIDDLE,
+ opt_chain);
+};
+
+
+// VERTICAL POSITIONING
+
+
+/**
+ * @return {number} The distance from the top edge of this element to the top
+ * edge of its parent, specified in units of the parent's coordinate system.
+ */
+goog.graphics.ext.Element.prototype.getTop = function() {
+ return this.yPosition_.getStart();
+};
+
+
+/**
+ * Sets the top coordinate of the element. Overwrites any previous value of
+ * top, middle, or bottom for this element.
+ * @param {string|number} top The top coordinate.
+ * @param {boolean=} opt_chain Optional flag to specify this function is part
+ * of a chain of calls and therefore transformations should be set as
+ * pending but not yet performed.
+ */
+goog.graphics.ext.Element.prototype.setTop = function(top, opt_chain) {
+ this.setPosition_(this.yPosition_,
+ top,
+ goog.graphics.ext.Element.PositionType_.START,
+ opt_chain);
+};
+
+
+/**
+ * @return {number} The bottom coordinate of the element, in units of the
+ * parent's coordinate system.
+ */
+goog.graphics.ext.Element.prototype.getBottom = function() {
+ return this.yPosition_.getEnd();
+};
+
+
+/**
+ * Sets the bottom coordinate of the element. Overwrites any previous value of
+ * top, middle, or bottom for this element.
+ * @param {string|number} bottom The bottom coordinate.
+ * @param {boolean=} opt_chain Optional flag to specify this function is part
+ * of a chain of calls and therefore transformations should be set as
+ * pending but not yet performed.
+ */
+goog.graphics.ext.Element.prototype.setBottom = function(bottom, opt_chain) {
+ this.setPosition_(this.yPosition_,
+ bottom,
+ goog.graphics.ext.Element.PositionType_.END,
+ opt_chain);
+};
+
+
+/**
+ * @return {number} The middle coordinate of the element, in units of the
+ * parent's coordinate system.
+ */
+goog.graphics.ext.Element.prototype.getMiddle = function() {
+ return this.yPosition_.getMiddle();
+};
+
+
+/**
+ * Sets the middle coordinate of the element. Overwrites any previous value of
+ * top, middle, or bottom for this element
+ * @param {string|number} middle The middle coordinate.
+ * @param {boolean=} opt_chain Optional flag to specify this function is part
+ * of a chain of calls and therefore transformations should be set as
+ * pending but not yet performed.
+ */
+goog.graphics.ext.Element.prototype.setMiddle = function(middle, opt_chain) {
+ this.setPosition_(this.yPosition_,
+ middle,
+ goog.graphics.ext.Element.PositionType_.MIDDLE,
+ opt_chain);
+};
+
+
+// DIMENSIONS
+
+
+/**
+ * @return {number} The width of the element, in units of the parent's
+ * coordinate system.
+ */
+goog.graphics.ext.Element.prototype.getWidth = function() {
+ return this.xPosition_.getSize();
+};
+
+
+/**
+ * Sets the width of the element.
+ * @param {string|number} width The new width value.
+ * @param {boolean=} opt_chain Optional flag to specify this function is part
+ * of a chain of calls and therefore transformations should be set as
+ * pending but not yet performed.
+ */
+goog.graphics.ext.Element.prototype.setWidth = function(width, opt_chain) {
+ this.setSize_(this.xPosition_, width, opt_chain);
+};
+
+
+/**
+ * @return {number} The minimum width of the element, in units of the parent's
+ * coordinate system.
+ */
+goog.graphics.ext.Element.prototype.getMinWidth = function() {
+ return this.xPosition_.getMinSize();
+};
+
+
+/**
+ * Sets the minimum width of the element.
+ * @param {string|number} minWidth The minimum width of the element.
+ */
+goog.graphics.ext.Element.prototype.setMinWidth = function(minWidth) {
+ this.setMinSize_(this.xPosition_, minWidth);
+};
+
+
+/**
+ * @return {number} The height of the element, in units of the parent's
+ * coordinate system.
+ */
+goog.graphics.ext.Element.prototype.getHeight = function() {
+ return this.yPosition_.getSize();
+};
+
+
+/**
+ * Sets the height of the element.
+ * @param {string|number} height The new height value.
+ * @param {boolean=} opt_chain Optional flag to specify this function is part
+ * of a chain of calls and therefore transformations should be set as
+ * pending but not yet performed.
+ */
+goog.graphics.ext.Element.prototype.setHeight = function(height, opt_chain) {
+ this.setSize_(this.yPosition_, height, opt_chain);
+};
+
+
+/**
+ * @return {number} The minimum height of the element, in units of the parent's
+ * coordinate system.
+ */
+goog.graphics.ext.Element.prototype.getMinHeight = function() {
+ return this.yPosition_.getMinSize();
+};
+
+
+/**
+ * Sets the minimum height of the element.
+ * @param {string|number} minHeight The minimum height of the element.
+ */
+goog.graphics.ext.Element.prototype.setMinHeight = function(minHeight) {
+ this.setMinSize_(this.yPosition_, minHeight);
+};
+
+
+// BOUNDS SHORTCUTS
+
+
+/**
+ * Shortcut for setting the left and top position.
+ * @param {string|number} left The left coordinate.
+ * @param {string|number} top The top coordinate.
+ * @param {boolean=} opt_chain Optional flag to specify this function is part
+ * of a chain of calls and therefore transformations should be set as
+ * pending but not yet performed.
+ */
+goog.graphics.ext.Element.prototype.setPosition = function(left, top,
+ opt_chain) {
+ this.setLeft(left, true);
+ this.setTop(top, opt_chain);
+};
+
+
+/**
+ * Shortcut for setting the width and height.
+ * @param {string|number} width The new width value.
+ * @param {string|number} height The new height value.
+ * @param {boolean=} opt_chain Optional flag to specify this function is part
+ * of a chain of calls and therefore transformations should be set as
+ * pending but not yet performed.
+ */
+goog.graphics.ext.Element.prototype.setSize = function(width, height,
+ opt_chain) {
+ this.setWidth(width, true);
+ this.setHeight(height, opt_chain);
+};
+
+
+/**
+ * Shortcut for setting the left, top, width, and height.
+ * @param {string|number} left The left coordinate.
+ * @param {string|number} top The top coordinate.
+ * @param {string|number} width The new width value.
+ * @param {string|number} height The new height value.
+ * @param {boolean=} opt_chain Optional flag to specify this function is part
+ * of a chain of calls and therefore transformations should be set as
+ * pending but not yet performed.
+ */
+goog.graphics.ext.Element.prototype.setBounds = function(left, top, width,
+ height, opt_chain) {
+ this.setLeft(left, true);
+ this.setTop(top, true);
+ this.setWidth(width, true);
+ this.setHeight(height, opt_chain);
+};
+
+
+// MAXIMUM BOUNDS
+
+
+/**
+ * @return {number} An estimate of the maximum x extent this element would have
+ * in a parent of no width.
+ */
+goog.graphics.ext.Element.prototype.getMaxX = function() {
+ return this.xPosition_.getMaxPosition();
+};
+
+
+/**
+ * @return {number} An estimate of the maximum y extent this element would have
+ * in a parent of no height.
+ */
+goog.graphics.ext.Element.prototype.getMaxY = function() {
+ return this.yPosition_.getMaxPosition();
+};
+
+
+// RESET
+
+
+/**
+ * Reset the element. This is called when the element changes size, or when
+ * the coordinate system changes in a way that would affect pixel based
+ * rendering
+ */
+goog.graphics.ext.Element.prototype.reset = function() {
+ this.xPosition_.resetCache();
+ this.yPosition_.resetCache();
+
+ this.redraw();
+
+ this.needsTransform_ = true;
+ this.transform();
+};
+
+
+/**
+ * Overridable function for subclass specific reset.
+ * @protected
+ */
+goog.graphics.ext.Element.prototype.redraw = goog.nullFunction;
+
+
+// PARENT DEPENDENCY
+
+
+/**
+ * Computes whether the element is still parent dependent.
+ * @param {goog.graphics.ext.Element.Position_} position The recently changed
+ * position object.
+ * @private
+ */
+goog.graphics.ext.Element.prototype.computeIsParentDependent_ = function(
+ position) {
+ this.parentDependent_ = position.isParentDependent() ||
+ this.xPosition_.isParentDependent() ||
+ this.yPosition_.isParentDependent() ||
+ this.checkParentDependent();
+};
+
+
+/**
+ * Returns whether this element's bounds depend on its parents.
+ *
+ * This function should be treated as if it has package scope.
+ * @return {boolean} Whether this element's bounds depend on its parents.
+ */
+goog.graphics.ext.Element.prototype.isParentDependent = function() {
+ return this.parentDependent_;
+};
+
+
+/**
+ * Overridable function for subclass specific parent dependency.
+ * @return {boolean} Whether this shape's bounds depends on its parent's.
+ * @protected
+ */
+goog.graphics.ext.Element.prototype.checkParentDependent =
+ goog.functions.FALSE;
+
+
+// ROTATION
+
+
+/**
+ * Set the rotation of this element.
+ * @param {number} angle The angle of rotation, in degrees.
+ */
+goog.graphics.ext.Element.prototype.setRotation = function(angle) {
+ if (this.rotation_ != angle) {
+ this.rotation_ = angle;
+
+ this.needsTransform_ = true;
+ this.transform();
+ }
+};
+
+
+/**
+ * @return {number} The angle of rotation of this element, in degrees.
+ */
+goog.graphics.ext.Element.prototype.getRotation = function() {
+ return this.rotation_;
+};
+
+
+// TRANSFORMS
+
+
+/**
+ * Called by the parent when the parent has transformed.
+ *
+ * Should be treated as package scope.
+ */
+goog.graphics.ext.Element.prototype.parentTransform = function() {
+ this.needsTransform_ = this.needsTransform_ || this.parentDependent_;
+};
+
+
+/**
+ * @return {boolean} Whether this element has pending transforms.
+ */
+goog.graphics.ext.Element.prototype.isPendingTransform = function() {
+ return this.needsTransform_;
+};
+
+
+/**
+ * Performs a pending transform.
+ * @protected
+ */
+goog.graphics.ext.Element.prototype.transform = function() {
+ if (this.isPendingTransform()) {
+ this.needsTransform_ = false;
+
+ this.wrapper_.setTransformation(
+ this.getLeft(),
+ this.getTop(),
+ this.rotation_,
+ (this.getWidth() || 1) / 2,
+ (this.getHeight() || 1) / 2);
+
+ // TODO(robbyw): this._fireEvent('transform', [ this ]);
+ }
+};
+
+
+// PIXEL SCALE
+
+
+/**
+ * @return {number} Returns the number of pixels per unit in the x direction.
+ */
+goog.graphics.ext.Element.prototype.getPixelScaleX = function() {
+ return this.getGraphics().getPixelScaleX();
+};
+
+
+/**
+ * @return {number} Returns the number of pixels per unit in the y direction.
+ */
+goog.graphics.ext.Element.prototype.getPixelScaleY = function() {
+ return this.getGraphics().getPixelScaleY();
+};
+
+
+// EVENT HANDLING
+
+
+/** @override */
+goog.graphics.ext.Element.prototype.disposeInternal = function() {
+ goog.graphics.ext.Element.superClass_.disposeInternal.call();
+ this.wrapper_.dispose();
+};
+
+
+// INTERNAL POSITION OBJECT
+
+
+/**
+ * Position specification types. Start corresponds to left/top, middle to
+ * center/middle, and end to right/bottom.
+ * @enum {number}
+ * @private
+ */
+goog.graphics.ext.Element.PositionType_ = {
+ START: 0,
+ MIDDLE: 1,
+ END: 2
+};
+
+
+
+/**
+ * Manages a position and size, either horizontal or vertical.
+ * @param {goog.graphics.ext.Element} element The element the position applies
+ * to.
+ * @param {boolean} horizontal Whether the position is horizontal or vertical.
+ * @constructor
+ * @private
+ */
+goog.graphics.ext.Element.Position_ = function(element, horizontal) {
+ this.element_ = element;
+ this.horizontal_ = horizontal;
+};
+
+
+/**
+ * @return {!Object} The coordinate value computation cache.
+ * @private
+ */
+goog.graphics.ext.Element.Position_.prototype.getCoordinateCache_ = function() {
+ return this.coordinateCache_ || (this.coordinateCache_ = {});
+};
+
+
+/**
+ * @return {number} The size of the parent's coordinate space.
+ * @private
+ */
+goog.graphics.ext.Element.Position_.prototype.getParentSize_ = function() {
+ var parent = this.element_.getParent();
+ return this.horizontal_ ?
+ parent.getCoordinateWidth() :
+ parent.getCoordinateHeight();
+};
+
+
+/**
+ * @return {number} The minimum width/height of the element.
+ */
+goog.graphics.ext.Element.Position_.prototype.getMinSize = function() {
+ return this.getValue_(this.minSize_);
+};
+
+
+/**
+ * Sets the minimum width/height of the element.
+ * @param {string|number} minSize The minimum width/height of the element.
+ */
+goog.graphics.ext.Element.Position_.prototype.setMinSize = function(minSize) {
+ this.minSize_ = minSize;
+ this.resetCache();
+};
+
+
+/**
+ * @return {number} The width/height of the element.
+ */
+goog.graphics.ext.Element.Position_.prototype.getSize = function() {
+ return Math.max(this.getValue_(this.size_), this.getMinSize());
+};
+
+
+/**
+ * Sets the width/height of the element.
+ * @param {string|number} size The width/height of the element.
+ * @return {boolean} Whether the value was changed.
+ */
+goog.graphics.ext.Element.Position_.prototype.setSize = function(size) {
+ if (size != this.size_) {
+ this.size_ = size;
+ this.resetCache();
+ return true;
+ }
+ return false;
+};
+
+
+/**
+ * Converts the given x coordinate to a number value in units.
+ * @param {string|number} v The coordinate to retrieve the value for.
+ * @param {boolean=} opt_forMaximum Whether we are computing the largest value
+ * this coordinate would be in a parent of no size.
+ * @return {number} The correct number of coordinate space units.
+ * @private
+ */
+goog.graphics.ext.Element.Position_.prototype.getValue_ = function(v,
+ opt_forMaximum) {
+ if (!goog.graphics.ext.coordinates.isSpecial(v)) {
+ return parseFloat(String(v));
+ }
+
+ var cache = this.getCoordinateCache_();
+ var scale = this.horizontal_ ?
+ this.element_.getPixelScaleX() :
+ this.element_.getPixelScaleY();
+
+ var containerSize;
+ if (opt_forMaximum) {
+ containerSize = goog.graphics.ext.coordinates.computeValue(
+ this.size_ || 0, 0, scale);
+ } else {
+ var parent = this.element_.getParent();
+ containerSize = this.horizontal_ ? parent.getWidth() : parent.getHeight();
+ }
+
+ return goog.graphics.ext.coordinates.getValue(v, opt_forMaximum,
+ containerSize, scale, cache);
+};
+
+
+/**
+ * @return {number} The distance from the left/top edge of this element to the
+ * left/top edge of its parent, specified in units of the parent's
+ * coordinate system.
+ */
+goog.graphics.ext.Element.Position_.prototype.getStart = function() {
+ if (this.cachedValue_ == null) {
+ var value = this.getValue_(this.distance_);
+ if (this.distanceType_ == goog.graphics.ext.Element.PositionType_.START) {
+ this.cachedValue_ = value;
+ } else if (this.distanceType_ ==
+ goog.graphics.ext.Element.PositionType_.MIDDLE) {
+ this.cachedValue_ = value + (this.getParentSize_() - this.getSize()) / 2;
+ } else {
+ this.cachedValue_ = this.getParentSize_() - value - this.getSize();
+ }
+ }
+
+ return this.cachedValue_;
+};
+
+
+/**
+ * @return {number} The middle coordinate of the element, in units of the
+ * parent's coordinate system.
+ */
+goog.graphics.ext.Element.Position_.prototype.getMiddle = function() {
+ return this.distanceType_ == goog.graphics.ext.Element.PositionType_.MIDDLE ?
+ this.getValue_(this.distance_) :
+ (this.getParentSize_() - this.getSize()) / 2 - this.getStart();
+};
+
+
+/**
+ * @return {number} The end coordinate of the element, in units of the
+ * parent's coordinate system.
+ */
+goog.graphics.ext.Element.Position_.prototype.getEnd = function() {
+ return this.distanceType_ == goog.graphics.ext.Element.PositionType_.END ?
+ this.getValue_(this.distance_) :
+ this.getParentSize_() - this.getStart() - this.getSize();
+};
+
+
+/**
+ * Sets the position, either as a left/top, center/middle, or right/bottom
+ * value.
+ * @param {number|string} value The value of the coordinate.
+ * @param {goog.graphics.ext.Element.PositionType_} type The type of the
+ * coordinate.
+ */
+goog.graphics.ext.Element.Position_.prototype.setPosition = function(value,
+ type) {
+ this.distance_ = value;
+ this.distanceType_ = type;
+
+ // Clear cached value.
+ this.cachedValue_ = null;
+};
+
+
+/**
+ * @return {number} An estimate of the maximum x/y extent this element would
+ * have in a parent of no width/height.
+ */
+goog.graphics.ext.Element.Position_.prototype.getMaxPosition = function() {
+ // TODO(robbyw): Handle transformed or rotated coordinates
+ // TODO(robbyw): Handle pixel based sizes?
+
+ return this.getValue_(this.distance_ || 0) + (
+ goog.graphics.ext.coordinates.isSpecial(this.size_) ? 0 : this.getSize());
+};
+
+
+/**
+ * Resets the caches of position values and coordinate values.
+ */
+goog.graphics.ext.Element.Position_.prototype.resetCache = function() {
+ this.coordinateCache_ = null;
+ this.cachedValue_ = null;
+};
+
+
+/**
+ * @return {boolean} Whether the size or position of this element depends on
+ * the size of the parent element.
+ */
+goog.graphics.ext.Element.Position_.prototype.isParentDependent = function() {
+ return this.distanceType_ != goog.graphics.ext.Element.PositionType_.START ||
+ goog.graphics.ext.coordinates.isSpecial(this.size_) ||
+ goog.graphics.ext.coordinates.isSpecial(this.minSize_) ||
+ goog.graphics.ext.coordinates.isSpecial(this.distance_);
+};
+
+
+/**
+ * The lazy loaded distance from the parent's top/left edge to this element's
+ * top/left edge expressed in the parent's coordinate system. We cache this
+ * because it is most freqeuently requested by the element and it is easy to
+ * compute middle and end values from it.
+ * @type {?number}
+ * @private
+ */
+goog.graphics.ext.Element.Position_.prototype.cachedValue_ = null;
+
+
+/**
+ * A cache of computed x coordinates.
+ * @type {Object}
+ * @private
+ */
+goog.graphics.ext.Element.Position_.prototype.coordinateCache_ = null;
+
+
+/**
+ * The minimum width/height of this element, as specified by the caller.
+ * @type {string|number}
+ * @private
+ */
+goog.graphics.ext.Element.Position_.prototype.minSize_ = 0;
+
+
+/**
+ * The width/height of this object, as specified by the caller.
+ * @type {string|number}
+ * @private
+ */
+goog.graphics.ext.Element.Position_.prototype.size_ = 0;
+
+
+/**
+ * The coordinate of this object, as specified by the caller. The type of
+ * coordinate is specified by distanceType_.
+ * @type {string|number}
+ * @private
+ */
+goog.graphics.ext.Element.Position_.prototype.distance_ = 0;
+
+
+/**
+ * The coordinate type specified by distance_.
+ * @type {goog.graphics.ext.Element.PositionType_}
+ * @private
+ */
+goog.graphics.ext.Element.Position_.prototype.distanceType_ =
+ goog.graphics.ext.Element.PositionType_.START;
+
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/graphics/ext/ellipse.js
----------------------------------------------------------------------
diff --git a/externs/GCL/externs/goog/graphics/ext/ellipse.js b/externs/GCL/externs/goog/graphics/ext/ellipse.js
new file mode 100644
index 0000000..db77524
--- /dev/null
+++ b/externs/GCL/externs/goog/graphics/ext/ellipse.js
@@ -0,0 +1,60 @@
+// Copyright 2007 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+
+/**
+ * @fileoverview A thick wrapper around ellipses.
+ * @author robbyw@google.com (Robby Walker)
+ */
+
+
+goog.provide('goog.graphics.ext.Ellipse');
+
+goog.require('goog.graphics.ext.StrokeAndFillElement');
+
+
+
+/**
+ * Wrapper for a graphics ellipse element.
+ * @param {goog.graphics.ext.Group} group Parent for this element.
+ * @constructor
+ * @extends {goog.graphics.ext.StrokeAndFillElement}
+ * @final
+ */
+goog.graphics.ext.Ellipse = function(group) {
+ // Initialize with some stock values.
+ var wrapper = group.getGraphicsImplementation().drawEllipse(1, 1, 2, 2, null,
+ null, group.getWrapper());
+ goog.graphics.ext.StrokeAndFillElement.call(this, group, wrapper);
+};
+goog.inherits(goog.graphics.ext.Ellipse,
+ goog.graphics.ext.StrokeAndFillElement);
+
+
+/**
+ * Redraw the ellipse. Called when the coordinate system is changed.
+ * @protected
+ * @override
+ */
+goog.graphics.ext.Ellipse.prototype.redraw = function() {
+ goog.graphics.ext.Ellipse.superClass_.redraw.call(this);
+
+ // Our position is already transformed in transform_, but because this is an
+ // ellipse we need to position the center.
+ var xRadius = this.getWidth() / 2;
+ var yRadius = this.getHeight() / 2;
+ var wrapper = this.getWrapper();
+ wrapper.setCenter(xRadius, yRadius);
+ wrapper.setRadius(xRadius, yRadius);
+};
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/graphics/ext/ext.js
----------------------------------------------------------------------
diff --git a/externs/GCL/externs/goog/graphics/ext/ext.js b/externs/GCL/externs/goog/graphics/ext/ext.js
new file mode 100644
index 0000000..b3ff4e3
--- /dev/null
+++ b/externs/GCL/externs/goog/graphics/ext/ext.js
@@ -0,0 +1,31 @@
+// Copyright 2007 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+
+/**
+ * @fileoverview Extended graphics namespace.
+ * @suppress {extraRequire} All the requires in this file are "extra"
+ * because this file is not actually using them.
+ */
+
+
+goog.provide('goog.graphics.ext');
+
+goog.require('goog.graphics.ext.Ellipse');
+goog.require('goog.graphics.ext.Graphics');
+goog.require('goog.graphics.ext.Group');
+goog.require('goog.graphics.ext.Image');
+goog.require('goog.graphics.ext.Rectangle');
+goog.require('goog.graphics.ext.Shape');
+goog.require('goog.graphics.ext.coordinates');
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/graphics/ext/graphics.js
----------------------------------------------------------------------
diff --git a/externs/GCL/externs/goog/graphics/ext/graphics.js b/externs/GCL/externs/goog/graphics/ext/graphics.js
new file mode 100644
index 0000000..a3c1a54
--- /dev/null
+++ b/externs/GCL/externs/goog/graphics/ext/graphics.js
@@ -0,0 +1,218 @@
+// Copyright 2007 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+
+/**
+ * @fileoverview Graphics surface type.
+ * @author robbyw@google.com (Robby Walker)
+ */
+
+
+goog.provide('goog.graphics.ext.Graphics');
+
+goog.require('goog.events');
+goog.require('goog.events.EventType');
+goog.require('goog.graphics');
+goog.require('goog.graphics.ext.Group');
+
+
+
+/**
+ * Wrapper for a graphics surface.
+ * @param {string|number} width The width in pixels. Strings
+ * expressing percentages of parent with (e.g. '80%') are also accepted.
+ * @param {string|number} height The height in pixels. Strings
+ * expressing percentages of parent with (e.g. '80%') are also accepted.
+ * @param {?number=} opt_coordWidth The coordinate width - if
+ * omitted or null, defaults to same as width.
+ * @param {?number=} opt_coordHeight The coordinate height. - if
+ * omitted or null, defaults to same as height.
+ * @param {goog.dom.DomHelper=} opt_domHelper The DOM helper object for the
+ * document we want to render in.
+ * @param {boolean=} opt_isSimple Flag used to indicate the graphics object will
+ * be drawn to in a single pass, and the fastest implementation for this
+ * scenario should be favored. NOTE: Setting to true may result in
+ * degradation of text support.
+ * @constructor
+ * @extends {goog.graphics.ext.Group}
+ * @final
+ */
+goog.graphics.ext.Graphics = function(width, height, opt_coordWidth,
+ opt_coordHeight, opt_domHelper, opt_isSimple) {
+ var surface = opt_isSimple ?
+ goog.graphics.createSimpleGraphics(width, height,
+ opt_coordWidth, opt_coordHeight, opt_domHelper) :
+ goog.graphics.createGraphics(width, height,
+ opt_coordWidth, opt_coordHeight, opt_domHelper);
+ this.implementation_ = surface;
+
+ goog.graphics.ext.Group.call(this, null, surface.getCanvasElement());
+
+ goog.events.listen(surface, goog.events.EventType.RESIZE,
+ this.updateChildren, false, this);
+};
+goog.inherits(goog.graphics.ext.Graphics, goog.graphics.ext.Group);
+
+
+/**
+ * The root level graphics implementation.
+ * @type {goog.graphics.AbstractGraphics}
+ * @private
+ */
+goog.graphics.ext.Graphics.prototype.implementation_;
+
+
+/**
+ * @return {goog.graphics.AbstractGraphics} The graphics implementation layer.
+ */
+goog.graphics.ext.Graphics.prototype.getImplementation = function() {
+ return this.implementation_;
+};
+
+
+/**
+ * Changes the coordinate size.
+ * @param {number} coordWidth The coordinate width.
+ * @param {number} coordHeight The coordinate height.
+ */
+goog.graphics.ext.Graphics.prototype.setCoordSize = function(coordWidth,
+ coordHeight) {
+ this.implementation_.setCoordSize(coordWidth, coordHeight);
+ goog.graphics.ext.Graphics.superClass_.setSize.call(this, coordWidth,
+ coordHeight);
+};
+
+
+/**
+ * @return {goog.math.Size} The coordinate size.
+ */
+goog.graphics.ext.Graphics.prototype.getCoordSize = function() {
+ return this.implementation_.getCoordSize();
+};
+
+
+/**
+ * Changes the coordinate system position.
+ * @param {number} left The coordinate system left bound.
+ * @param {number} top The coordinate system top bound.
+ */
+goog.graphics.ext.Graphics.prototype.setCoordOrigin = function(left, top) {
+ this.implementation_.setCoordOrigin(left, top);
+};
+
+
+/**
+ * @return {!goog.math.Coordinate} The coordinate system position.
+ */
+goog.graphics.ext.Graphics.prototype.getCoordOrigin = function() {
+ return this.implementation_.getCoordOrigin();
+};
+
+
+/**
+ * Change the size of the canvas.
+ * @param {number} pixelWidth The width in pixels.
+ * @param {number} pixelHeight The height in pixels.
+ */
+goog.graphics.ext.Graphics.prototype.setPixelSize = function(pixelWidth,
+ pixelHeight) {
+ this.implementation_.setSize(pixelWidth, pixelHeight);
+
+ var coordSize = this.getCoordSize();
+ goog.graphics.ext.Graphics.superClass_.setSize.call(this, coordSize.width,
+ coordSize.height);
+};
+
+
+/**
+ * @return {goog.math.Size?} Returns the number of pixels spanned by the
+ * surface, or null if the size could not be computed due to the size being
+ * specified in percentage points and the component not being in the
+ * document.
+ */
+goog.graphics.ext.Graphics.prototype.getPixelSize = function() {
+ return this.implementation_.getPixelSize();
+};
+
+
+/**
+ * @return {number} The coordinate width of the canvas.
+ * @override
+ */
+goog.graphics.ext.Graphics.prototype.getWidth = function() {
+ return this.implementation_.getCoordSize().width;
+};
+
+
+/**
+ * @return {number} The coordinate width of the canvas.
+ * @override
+ */
+goog.graphics.ext.Graphics.prototype.getHeight = function() {
+ return this.implementation_.getCoordSize().height;
+};
+
+
+/**
+ * @return {number} Returns the number of pixels per unit in the x direction.
+ * @override
+ */
+goog.graphics.ext.Graphics.prototype.getPixelScaleX = function() {
+ return this.implementation_.getPixelScaleX();
+};
+
+
+/**
+ * @return {number} Returns the number of pixels per unit in the y direction.
+ * @override
+ */
+goog.graphics.ext.Graphics.prototype.getPixelScaleY = function() {
+ return this.implementation_.getPixelScaleY();
+};
+
+
+/**
+ * @return {Element} The root element of the graphics surface.
+ */
+goog.graphics.ext.Graphics.prototype.getElement = function() {
+ return this.implementation_.getElement();
+};
+
+
+/**
+ * Renders the underlying graphics.
+ *
+ * @param {Element} parentElement Parent element to render the component into.
+ */
+goog.graphics.ext.Graphics.prototype.render = function(parentElement) {
+ this.implementation_.render(parentElement);
+};
+
+
+/**
+ * Never transform a surface.
+ * @override
+ */
+goog.graphics.ext.Graphics.prototype.transform = goog.nullFunction;
+
+
+/**
+ * Called from the parent class, this method resets any pre-computed positions
+ * and sizes.
+ * @protected
+ * @override
+ */
+goog.graphics.ext.Graphics.prototype.redraw = function() {
+ this.transformChildren();
+};
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/graphics/ext/group.js
----------------------------------------------------------------------
diff --git a/externs/GCL/externs/goog/graphics/ext/group.js b/externs/GCL/externs/goog/graphics/ext/group.js
new file mode 100644
index 0000000..03479ad
--- /dev/null
+++ b/externs/GCL/externs/goog/graphics/ext/group.js
@@ -0,0 +1,216 @@
+// Copyright 2007 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+
+/**
+ * @fileoverview A thicker wrapper around graphics groups.
+ * @author robbyw@google.com (Robby Walker)
+ */
+
+
+goog.provide('goog.graphics.ext.Group');
+
+goog.require('goog.array');
+goog.require('goog.graphics.ext.Element');
+
+
+
+/**
+ * Wrapper for a graphics group.
+ * @param {goog.graphics.ext.Group} group Parent for this element. Can
+ * be null if this is a Graphics instance.
+ * @param {goog.graphics.GroupElement=} opt_wrapper The thin wrapper
+ * to wrap. If omitted, a new group will be created. Must be included
+ * when group is null.
+ * @constructor
+ * @extends {goog.graphics.ext.Element}
+ */
+goog.graphics.ext.Group = function(group, opt_wrapper) {
+ opt_wrapper = opt_wrapper || group.getGraphicsImplementation().createGroup(
+ group.getWrapper());
+ goog.graphics.ext.Element.call(this, group, opt_wrapper);
+
+ /**
+ * Array of child elements this group contains.
+ * @type {Array<goog.graphics.ext.Element>}
+ * @private
+ */
+ this.children_ = [];
+};
+goog.inherits(goog.graphics.ext.Group, goog.graphics.ext.Element);
+
+
+/**
+ * Add an element to the group. This should be treated as package local, as
+ * it is called by the draw* methods.
+ * @param {!goog.graphics.ext.Element} element The element to add.
+ * @param {boolean=} opt_chain Whether this addition is part of a longer set
+ * of element additions.
+ */
+goog.graphics.ext.Group.prototype.addChild = function(element, opt_chain) {
+ if (!goog.array.contains(this.children_, element)) {
+ this.children_.push(element);
+ }
+
+ var transformed = this.growToFit_(element);
+
+ if (element.isParentDependent()) {
+ element.parentTransform();
+ }
+
+ if (!opt_chain && element.isPendingTransform()) {
+ element.reset();
+ }
+
+ if (transformed) {
+ this.reset();
+ }
+};
+
+
+/**
+ * Remove an element from the group.
+ * @param {goog.graphics.ext.Element} element The element to remove.
+ */
+goog.graphics.ext.Group.prototype.removeChild = function(element) {
+ goog.array.remove(this.children_, element);
+
+ // TODO(robbyw): shape.fireEvent('delete')
+
+ this.getGraphicsImplementation().removeElement(element.getWrapper());
+};
+
+
+/**
+ * Calls the given function on each of this component's children in order. If
+ * {@code opt_obj} is provided, it will be used as the 'this' object in the
+ * function when called. The function should take two arguments: the child
+ * component and its 0-based index. The return value is ignored.
+ * @param {Function} f The function to call for every child component; should
+ * take 2 arguments (the child and its index).
+ * @param {Object=} opt_obj Used as the 'this' object in f when called.
+ */
+goog.graphics.ext.Group.prototype.forEachChild = function(f, opt_obj) {
+ if (this.children_) {
+ goog.array.forEach(this.children_, f, opt_obj);
+ }
+};
+
+
+/**
+ * @return {goog.graphics.GroupElement} The underlying thin wrapper.
+ * @override
+ */
+goog.graphics.ext.Group.prototype.getWrapper;
+
+
+/**
+ * Reset the element.
+ * @override
+ */
+goog.graphics.ext.Group.prototype.reset = function() {
+ goog.graphics.ext.Group.superClass_.reset.call(this);
+
+ this.updateChildren();
+};
+
+
+/**
+ * Called from the parent class, this method resets any pre-computed positions
+ * and sizes.
+ * @protected
+ * @override
+ */
+goog.graphics.ext.Group.prototype.redraw = function() {
+ this.getWrapper().setSize(this.getWidth(), this.getHeight());
+ this.transformChildren();
+};
+
+
+/**
+ * Transform the children that need to be transformed.
+ * @protected
+ */
+goog.graphics.ext.Group.prototype.transformChildren = function() {
+ this.forEachChild(function(child) {
+ if (child.isParentDependent()) {
+ child.parentTransform();
+ }
+ });
+};
+
+
+/**
+ * As part of the reset process, update child elements.
+ */
+goog.graphics.ext.Group.prototype.updateChildren = function() {
+ this.forEachChild(function(child) {
+ if (child.isParentDependent() || child.isPendingTransform()) {
+ child.reset();
+ } else if (child.updateChildren) {
+ child.updateChildren();
+ }
+ });
+};
+
+
+/**
+ * When adding an element, grow this group's bounds to fit it.
+ * @param {!goog.graphics.ext.Element} element The added element.
+ * @return {boolean} Whether the size of this group changed.
+ * @private
+ */
+goog.graphics.ext.Group.prototype.growToFit_ = function(element) {
+ var transformed = false;
+
+ var x = element.getMaxX();
+ if (x > this.getWidth()) {
+ this.setMinWidth(x);
+ transformed = true;
+ }
+
+ var y = element.getMaxY();
+ if (y > this.getHeight()) {
+ this.setMinHeight(y);
+ transformed = true;
+ }
+
+ return transformed;
+};
+
+
+/**
+ * @return {number} The width of the element's coordinate space.
+ */
+goog.graphics.ext.Group.prototype.getCoordinateWidth = function() {
+ return this.getWidth();
+};
+
+
+/**
+ * @return {number} The height of the element's coordinate space.
+ */
+goog.graphics.ext.Group.prototype.getCoordinateHeight = function() {
+ return this.getHeight();
+};
+
+
+/**
+ * Remove all drawing elements from the group.
+ */
+goog.graphics.ext.Group.prototype.clear = function() {
+ while (this.children_.length) {
+ this.removeChild(this.children_[0]);
+ }
+};
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/graphics/ext/image.js
----------------------------------------------------------------------
diff --git a/externs/GCL/externs/goog/graphics/ext/image.js b/externs/GCL/externs/goog/graphics/ext/image.js
new file mode 100644
index 0000000..ec24e1d
--- /dev/null
+++ b/externs/GCL/externs/goog/graphics/ext/image.js
@@ -0,0 +1,64 @@
+// Copyright 2007 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+
+/**
+ * @fileoverview A thick wrapper around images.
+ * @author robbyw@google.com (Robby Walker)
+ */
+
+
+goog.provide('goog.graphics.ext.Image');
+
+goog.require('goog.graphics.ext.Element');
+
+
+
+/**
+ * Wrapper for a graphics image element.
+ * @param {goog.graphics.ext.Group} group Parent for this element.
+ * @param {string} src The path to the image to display.
+ * @constructor
+ * @extends {goog.graphics.ext.Element}
+ * @final
+ */
+goog.graphics.ext.Image = function(group, src) {
+ // Initialize with some stock values.
+ var wrapper = group.getGraphicsImplementation().drawImage(0, 0, 1, 1, src,
+ group.getWrapper());
+ goog.graphics.ext.Element.call(this, group, wrapper);
+};
+goog.inherits(goog.graphics.ext.Image, goog.graphics.ext.Element);
+
+
+/**
+ * Redraw the image. Called when the coordinate system is changed.
+ * @protected
+ * @override
+ */
+goog.graphics.ext.Image.prototype.redraw = function() {
+ goog.graphics.ext.Image.superClass_.redraw.call(this);
+
+ // Our position is already handled bu transform_.
+ this.getWrapper().setSize(this.getWidth(), this.getHeight());
+};
+
+
+/**
+ * Update the source of the image.
+ * @param {string} src Source of the image.
+ */
+goog.graphics.ext.Image.prototype.setSource = function(src) {
+ this.getWrapper().setSource(src);
+};
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/graphics/ext/path.js
----------------------------------------------------------------------
diff --git a/externs/GCL/externs/goog/graphics/ext/path.js b/externs/GCL/externs/goog/graphics/ext/path.js
new file mode 100644
index 0000000..de550aa
--- /dev/null
+++ b/externs/GCL/externs/goog/graphics/ext/path.js
@@ -0,0 +1,142 @@
+// Copyright 2007 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+
+/**
+ * @fileoverview A thick wrapper around paths.
+ * @author robbyw@google.com (Robby Walker)
+ */
+
+
+goog.provide('goog.graphics.ext.Path');
+
+goog.require('goog.graphics.AffineTransform');
+goog.require('goog.graphics.Path');
+goog.require('goog.math.Rect');
+
+
+
+/**
+ * Creates a path object
+ * @constructor
+ * @extends {goog.graphics.Path}
+ * @final
+ */
+goog.graphics.ext.Path = function() {
+ goog.graphics.Path.call(this);
+};
+goog.inherits(goog.graphics.ext.Path, goog.graphics.Path);
+
+
+/**
+ * Optional cached or user specified bounding box. A user may wish to
+ * precompute a bounding box to save time and include more accurate
+ * computations.
+ * @type {goog.math.Rect?}
+ * @private
+ */
+goog.graphics.ext.Path.prototype.bounds_ = null;
+
+
+/**
+ * Clones the path.
+ * @return {!goog.graphics.ext.Path} A clone of this path.
+ * @override
+ */
+goog.graphics.ext.Path.prototype.clone = function() {
+ var output = /** @type {goog.graphics.ext.Path} */
+ (goog.graphics.ext.Path.superClass_.clone.call(this));
+ output.bounds_ = this.bounds_ && this.bounds_.clone();
+ return output;
+};
+
+
+/**
+ * Transforms the path. Only simple paths are transformable. Attempting
+ * to transform a non-simple path will throw an error.
+ * @param {!goog.graphics.AffineTransform} tx The transformation to perform.
+ * @return {!goog.graphics.ext.Path} The path itself.
+ * @override
+ */
+goog.graphics.ext.Path.prototype.transform = function(tx) {
+ goog.graphics.ext.Path.superClass_.transform.call(this, tx);
+
+ // Make sure the precomputed bounds are cleared when the path is transformed.
+ this.bounds_ = null;
+
+ return this;
+};
+
+
+/**
+ * Modify the bounding box of the path. This may cause the path to be
+ * simplified (i.e. arcs converted to curves) as a side-effect.
+ * @param {number} deltaX How far to translate the x coordinates.
+ * @param {number} deltaY How far to translate the y coordinates.
+ * @param {number} xFactor After translation, all x coordinates are multiplied
+ * by this number.
+ * @param {number} yFactor After translation, all y coordinates are multiplied
+ * by this number.
+ * @return {!goog.graphics.ext.Path} The path itself.
+ */
+goog.graphics.ext.Path.prototype.modifyBounds = function(deltaX, deltaY,
+ xFactor, yFactor) {
+ if (!this.isSimple()) {
+ var simple = goog.graphics.Path.createSimplifiedPath(this);
+ this.clear();
+ this.appendPath(simple);
+ }
+
+ return this.transform(goog.graphics.AffineTransform.getScaleInstance(
+ xFactor, yFactor).translate(deltaX, deltaY));
+};
+
+
+/**
+ * Set the precomputed bounds.
+ * @param {goog.math.Rect?} bounds The bounds to use, or set to null to clear
+ * and recompute on the next call to getBoundingBox.
+ */
+goog.graphics.ext.Path.prototype.useBoundingBox = function(bounds) {
+ this.bounds_ = bounds && bounds.clone();
+};
+
+
+/**
+ * @return {goog.math.Rect?} The bounding box of the path, or null if the
+ * path is empty.
+ */
+goog.graphics.ext.Path.prototype.getBoundingBox = function() {
+ if (!this.bounds_ && !this.isEmpty()) {
+ var minY;
+ var minX = minY = Number.POSITIVE_INFINITY;
+ var maxY;
+ var maxX = maxY = Number.NEGATIVE_INFINITY;
+
+ var simplePath = this.isSimple() ? this :
+ goog.graphics.Path.createSimplifiedPath(this);
+ simplePath.forEachSegment(function(type, points) {
+ for (var i = 0, len = points.length; i < len; i += 2) {
+ minX = Math.min(minX, points[i]);
+ maxX = Math.max(maxX, points[i]);
+ minY = Math.min(minY, points[i + 1]);
+ maxY = Math.max(maxY, points[i + 1]);
+ }
+ });
+
+ this.bounds_ = new goog.math.Rect(minX, minY, maxX - minX, maxY - minY);
+ }
+
+ return this.bounds_;
+};
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/graphics/ext/rectangle.js
----------------------------------------------------------------------
diff --git a/externs/GCL/externs/goog/graphics/ext/rectangle.js b/externs/GCL/externs/goog/graphics/ext/rectangle.js
new file mode 100644
index 0000000..d05c8b1
--- /dev/null
+++ b/externs/GCL/externs/goog/graphics/ext/rectangle.js
@@ -0,0 +1,55 @@
+// Copyright 2007 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+
+/**
+ * @fileoverview A thick wrapper around rectangles.
+ * @author robbyw@google.com (Robby Walker)
+ */
+
+
+goog.provide('goog.graphics.ext.Rectangle');
+
+goog.require('goog.graphics.ext.StrokeAndFillElement');
+
+
+
+/**
+ * Wrapper for a graphics rectangle element.
+ * @param {goog.graphics.ext.Group} group Parent for this element.
+ * @constructor
+ * @extends {goog.graphics.ext.StrokeAndFillElement}
+ * @final
+ */
+goog.graphics.ext.Rectangle = function(group) {
+ // Initialize with some stock values.
+ var wrapper = group.getGraphicsImplementation().drawRect(0, 0, 1, 1, null,
+ null, group.getWrapper());
+ goog.graphics.ext.StrokeAndFillElement.call(this, group, wrapper);
+};
+goog.inherits(goog.graphics.ext.Rectangle,
+ goog.graphics.ext.StrokeAndFillElement);
+
+
+/**
+ * Redraw the rectangle. Called when the coordinate system is changed.
+ * @protected
+ * @override
+ */
+goog.graphics.ext.Rectangle.prototype.redraw = function() {
+ goog.graphics.ext.Rectangle.superClass_.redraw.call(this);
+
+ // Our position is already handled by transform_.
+ this.getWrapper().setSize(this.getWidth(), this.getHeight());
+};
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/graphics/ext/shape.js
----------------------------------------------------------------------
diff --git a/externs/GCL/externs/goog/graphics/ext/shape.js b/externs/GCL/externs/goog/graphics/ext/shape.js
new file mode 100644
index 0000000..3f80e82
--- /dev/null
+++ b/externs/GCL/externs/goog/graphics/ext/shape.js
@@ -0,0 +1,145 @@
+// Copyright 2007 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+
+/**
+ * @fileoverview A thick wrapper around shapes with custom paths.
+ * @author robbyw@google.com (Robby Walker)
+ */
+
+
+goog.provide('goog.graphics.ext.Shape');
+
+goog.require('goog.graphics.ext.StrokeAndFillElement');
+
+
+
+/**
+ * Wrapper for a graphics shape element.
+ * @param {goog.graphics.ext.Group} group Parent for this element.
+ * @param {!goog.graphics.ext.Path} path The path to draw.
+ * @param {boolean=} opt_autoSize Optional flag to specify the path should
+ * automatically resize to fit the element. Defaults to false.
+ * @constructor
+ * @extends {goog.graphics.ext.StrokeAndFillElement}
+ * @final
+ */
+goog.graphics.ext.Shape = function(group, path, opt_autoSize) {
+ this.autoSize_ = !!opt_autoSize;
+
+ var graphics = group.getGraphicsImplementation();
+ var wrapper = graphics.drawPath(path, null, null,
+ group.getWrapper());
+ goog.graphics.ext.StrokeAndFillElement.call(this, group, wrapper);
+ this.setPath(path);
+};
+goog.inherits(goog.graphics.ext.Shape, goog.graphics.ext.StrokeAndFillElement);
+
+
+/**
+ * Whether or not to automatically resize the shape's path when the element
+ * itself is resized.
+ * @type {boolean}
+ * @private
+ */
+goog.graphics.ext.Shape.prototype.autoSize_ = false;
+
+
+/**
+ * The original path, specified by the caller.
+ * @type {goog.graphics.Path}
+ * @private
+ */
+goog.graphics.ext.Shape.prototype.path_;
+
+
+/**
+ * The bounding box of the original path.
+ * @type {goog.math.Rect?}
+ * @private
+ */
+goog.graphics.ext.Shape.prototype.boundingBox_ = null;
+
+
+/**
+ * The scaled path.
+ * @type {goog.graphics.Path}
+ * @private
+ */
+goog.graphics.ext.Shape.prototype.scaledPath_;
+
+
+/**
+ * Get the path drawn by this shape.
+ * @return {goog.graphics.Path?} The path drawn by this shape.
+ */
+goog.graphics.ext.Shape.prototype.getPath = function() {
+ return this.path_;
+};
+
+
+/**
+ * Set the path to draw.
+ * @param {goog.graphics.ext.Path} path The path to draw.
+ */
+goog.graphics.ext.Shape.prototype.setPath = function(path) {
+ this.path_ = path;
+
+ if (this.autoSize_) {
+ this.boundingBox_ = path.getBoundingBox();
+ }
+
+ this.scaleAndSetPath_();
+};
+
+
+/**
+ * Scale the internal path to fit.
+ * @private
+ */
+goog.graphics.ext.Shape.prototype.scaleAndSetPath_ = function() {
+ this.scaledPath_ = this.boundingBox_ ? this.path_.clone().modifyBounds(
+ -this.boundingBox_.left, -this.boundingBox_.top,
+ this.getWidth() / (this.boundingBox_.width || 1),
+ this.getHeight() / (this.boundingBox_.height || 1)) : this.path_;
+
+ var wrapper = this.getWrapper();
+ if (wrapper) {
+ wrapper.setPath(this.scaledPath_);
+ }
+};
+
+
+/**
+ * Redraw the ellipse. Called when the coordinate system is changed.
+ * @protected
+ * @override
+ */
+goog.graphics.ext.Shape.prototype.redraw = function() {
+ goog.graphics.ext.Shape.superClass_.redraw.call(this);
+ if (this.autoSize_) {
+ this.scaleAndSetPath_();
+ }
+};
+
+
+/**
+ * @return {boolean} Whether the shape is parent dependent.
+ * @protected
+ * @override
+ */
+goog.graphics.ext.Shape.prototype.checkParentDependent = function() {
+ return this.autoSize_ ||
+ goog.graphics.ext.Shape.superClass_.checkParentDependent.call(this);
+};
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/graphics/ext/strokeandfillelement.js
----------------------------------------------------------------------
diff --git a/externs/GCL/externs/goog/graphics/ext/strokeandfillelement.js b/externs/GCL/externs/goog/graphics/ext/strokeandfillelement.js
new file mode 100644
index 0000000..4ad69f3
--- /dev/null
+++ b/externs/GCL/externs/goog/graphics/ext/strokeandfillelement.js
@@ -0,0 +1,70 @@
+// Copyright 2007 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+
+/**
+ * @fileoverview A thick wrapper around elements with stroke and fill.
+ * @author robbyw@google.com (Robby Walker)
+ */
+
+
+goog.provide('goog.graphics.ext.StrokeAndFillElement');
+
+goog.require('goog.graphics.ext.Element');
+
+
+
+/**
+ * Interface for a graphics element that has a stroke and fill.
+ * This is the base interface for ellipse, rectangle and other
+ * shape interfaces.
+ * You should not construct objects from this constructor. Use a subclass.
+ * @param {goog.graphics.ext.Group} group Parent for this element.
+ * @param {goog.graphics.StrokeAndFillElement} wrapper The thin wrapper to wrap.
+ * @constructor
+ * @extends {goog.graphics.ext.Element}
+ */
+goog.graphics.ext.StrokeAndFillElement = function(group, wrapper) {
+ goog.graphics.ext.Element.call(this, group, wrapper);
+};
+goog.inherits(goog.graphics.ext.StrokeAndFillElement,
+ goog.graphics.ext.Element);
+
+
+/**
+ * Sets the fill for this element.
+ * @param {goog.graphics.Fill?} fill The fill object.
+ */
+goog.graphics.ext.StrokeAndFillElement.prototype.setFill = function(fill) {
+ this.getWrapper().setFill(fill);
+};
+
+
+/**
+ * Sets the stroke for this element.
+ * @param {goog.graphics.Stroke?} stroke The stroke object.
+ */
+goog.graphics.ext.StrokeAndFillElement.prototype.setStroke = function(stroke) {
+ this.getWrapper().setStroke(stroke);
+};
+
+
+/**
+ * Redraw the rectangle. Called when the coordinate system is changed.
+ * @protected
+ * @override
+ */
+goog.graphics.ext.StrokeAndFillElement.prototype.redraw = function() {
+ this.getWrapper().reapplyStroke();
+};
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/graphics/fill.js
----------------------------------------------------------------------
diff --git a/externs/GCL/externs/goog/graphics/fill.js b/externs/GCL/externs/goog/graphics/fill.js
new file mode 100644
index 0000000..92e460e
--- /dev/null
+++ b/externs/GCL/externs/goog/graphics/fill.js
@@ -0,0 +1,46 @@
+// Copyright 2007 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+
+/**
+ * @fileoverview Represents a fill goog.graphics.
+ * @author arv@google.com (Erik Arvidsson)
+ */
+
+
+goog.provide('goog.graphics.Fill');
+
+
+
+/**
+ * Creates a fill object
+ * @constructor
+ * @deprecated goog.graphics is deprecated. It existed to abstract over browser
+ * differences before the canvas tag was widely supported. See
+ * http://en.wikipedia.org/wiki/Canvas_element for details.
+ */
+goog.graphics.Fill = function() {};
+
+
+/**
+ * @return {string} The start color of a gradient fill.
+ */
+goog.graphics.Fill.prototype.getColor1 = goog.abstractMethod;
+
+
+/**
+ * @return {string} The end color of a gradient fill.
+ */
+goog.graphics.Fill.prototype.getColor2 = goog.abstractMethod;
+
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/graphics/font.js
----------------------------------------------------------------------
diff --git a/externs/GCL/externs/goog/graphics/font.js b/externs/GCL/externs/goog/graphics/font.js
new file mode 100644
index 0000000..f58bf41
--- /dev/null
+++ b/externs/GCL/externs/goog/graphics/font.js
@@ -0,0 +1,64 @@
+// Copyright 2007 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+
+/**
+ * @fileoverview Represents a font to be used with a Renderer.
+ * @author arv@google.com (Erik Arvidsson)
+ * @see ../demos/graphics/basicelements.html
+ */
+
+
+goog.provide('goog.graphics.Font');
+
+
+
+/**
+ * This class represents a font to be used with a renderer.
+ * @param {number} size The font size.
+ * @param {string} family The font family.
+ * @constructor
+ * @deprecated goog.graphics is deprecated. It existed to abstract over browser
+ * differences before the canvas tag was widely supported. See
+ * http://en.wikipedia.org/wiki/Canvas_element for details.
+ * @final
+ */
+goog.graphics.Font = function(size, family) {
+ /**
+ * Font size.
+ * @type {number}
+ */
+ this.size = size;
+ // TODO(arv): Is this in pixels or drawing units based on the coord size?
+
+ /**
+ * The name of the font family to use, can be a comma separated string.
+ * @type {string}
+ */
+ this.family = family;
+};
+
+
+/**
+ * Indication if text should be bolded
+ * @type {boolean}
+ */
+goog.graphics.Font.prototype.bold = false;
+
+
+/**
+ * Indication if text should be in italics
+ * @type {boolean}
+ */
+goog.graphics.Font.prototype.italic = false;
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/graphics/graphics.js
----------------------------------------------------------------------
diff --git a/externs/GCL/externs/goog/graphics/graphics.js b/externs/GCL/externs/goog/graphics/graphics.js
new file mode 100644
index 0000000..0bde5b5
--- /dev/null
+++ b/externs/GCL/externs/goog/graphics/graphics.js
@@ -0,0 +1,142 @@
+// Copyright 2007 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+
+/**
+ * @fileoverview Graphics utility functions and factory methods.
+ * @author arv@google.com (Erik Arvidsson)
+ * @see ../demos/graphics/advancedcoordinates.html
+ * @see ../demos/graphics/advancedcoordinates2.html
+ * @see ../demos/graphics/basicelements.html
+ * @see ../demos/graphics/events.html
+ * @see ../demos/graphics/modifyelements.html
+ * @see ../demos/graphics/tiger.html
+ */
+
+
+goog.provide('goog.graphics');
+
+goog.require('goog.dom');
+goog.require('goog.graphics.CanvasGraphics');
+goog.require('goog.graphics.SvgGraphics');
+goog.require('goog.graphics.VmlGraphics');
+goog.require('goog.userAgent');
+
+
+/**
+ * Returns an instance of goog.graphics.AbstractGraphics that knows how to draw
+ * for the current platform (A factory for the proper Graphics implementation)
+ * @param {string|number} width The width in pixels. Strings
+ * expressing percentages of parent with (e.g. '80%') are also accepted.
+ * @param {string|number} height The height in pixels. Strings
+ * expressing percentages of parent with (e.g. '80%') are also accepted.
+ * @param {?number=} opt_coordWidth The optional coordinate width - if
+ * omitted or null, defaults to same as width.
+ * @param {?number=} opt_coordHeight The optional coordinate height - if
+ * omitted or null, defaults to same as height.
+ * @param {goog.dom.DomHelper=} opt_domHelper The DOM helper object for the
+ * document we want to render in.
+ * @return {!goog.graphics.AbstractGraphics} The created instance.
+ * @deprecated goog.graphics is deprecated. It existed to abstract over browser
+ * differences before the canvas tag was widely supported. See
+ * http://en.wikipedia.org/wiki/Canvas_element for details.
+ */
+goog.graphics.createGraphics = function(width, height, opt_coordWidth,
+ opt_coordHeight, opt_domHelper) {
+ var graphics;
+ // On IE9 and above, SVG is available, except in compatibility mode.
+ // We check createElementNS on document object that is not exist in
+ // compatibility mode.
+ if (goog.userAgent.IE &&
+ (!goog.userAgent.isVersionOrHigher('9') ||
+ !(opt_domHelper || goog.dom.getDomHelper()).
+ getDocument().createElementNS)) {
+ graphics = new goog.graphics.VmlGraphics(width, height,
+ opt_coordWidth, opt_coordHeight, opt_domHelper);
+ } else if (goog.userAgent.WEBKIT &&
+ (!goog.userAgent.isVersionOrHigher('420') ||
+ goog.userAgent.MOBILE)) {
+ graphics = new goog.graphics.CanvasGraphics(width, height,
+ opt_coordWidth, opt_coordHeight, opt_domHelper);
+ } else {
+ graphics = new goog.graphics.SvgGraphics(width, height,
+ opt_coordWidth, opt_coordHeight, opt_domHelper);
+ }
+
+ // Create the dom now, because all drawing methods require that the
+ // main dom element (the canvas) has been already created.
+ graphics.createDom();
+
+ return graphics;
+};
+
+
+/**
+ * Returns an instance of goog.graphics.AbstractGraphics that knows how to draw
+ * for the current platform (A factory for the proper Graphics implementation)
+ * @param {string|number} width The width in pixels. Strings
+ * expressing percentages of parent with (e.g. '80%') are also accepted.
+ * @param {string|number} height The height in pixels. Strings
+ * expressing percentages of parent with (e.g. '80%') are also accepted.
+ * @param {?number=} opt_coordWidth The optional coordinate width, defaults to
+ * same as width.
+ * @param {?number=} opt_coordHeight The optional coordinate height, defaults to
+ * same as height.
+ * @param {goog.dom.DomHelper=} opt_domHelper The DOM helper object for the
+ * document we want to render in.
+ * @return {!goog.graphics.AbstractGraphics} The created instance.
+ * @deprecated goog.graphics is deprecated. It existed to abstract over browser
+ * differences before the canvas tag was widely supported. See
+ * http://en.wikipedia.org/wiki/Canvas_element for details.
+ */
+goog.graphics.createSimpleGraphics = function(width, height,
+ opt_coordWidth, opt_coordHeight, opt_domHelper) {
+ if (goog.userAgent.MAC && goog.userAgent.GECKO &&
+ !goog.userAgent.isVersionOrHigher('1.9a')) {
+ // Canvas is 6x faster than SVG on Mac FF 2.0
+ var graphics = new goog.graphics.CanvasGraphics(
+ width, height, opt_coordWidth, opt_coordHeight,
+ opt_domHelper);
+ graphics.createDom();
+ return graphics;
+ }
+
+ // Otherwise, defer to normal graphics object creation.
+ return goog.graphics.createGraphics(width, height, opt_coordWidth,
+ opt_coordHeight, opt_domHelper);
+};
+
+
+/**
+ * Static function to check if the current browser has Graphics support.
+ * @return {boolean} True if the current browser has Graphics support.
+ * @deprecated goog.graphics is deprecated. It existed to abstract over browser
+ * differences before the canvas tag was widely supported. See
+ * http://en.wikipedia.org/wiki/Canvas_element for details.
+ */
+goog.graphics.isBrowserSupported = function() {
+ if (goog.userAgent.IE) {
+ return goog.userAgent.isVersionOrHigher('5.5');
+ }
+ if (goog.userAgent.GECKO) {
+ return goog.userAgent.isVersionOrHigher('1.8');
+ }
+ if (goog.userAgent.OPERA) {
+ return goog.userAgent.isVersionOrHigher('9.0');
+ }
+ if (goog.userAgent.WEBKIT) {
+ return goog.userAgent.isVersionOrHigher('412');
+ }
+ return false;
+};