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:25 UTC
[10/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/groupelement.js
----------------------------------------------------------------------
diff --git a/externs/GCL/externs/goog/graphics/groupelement.js b/externs/GCL/externs/goog/graphics/groupelement.js
new file mode 100644
index 0000000..9e60cd7
--- /dev/null
+++ b/externs/GCL/externs/goog/graphics/groupelement.js
@@ -0,0 +1,58 @@
+// 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 graphics groups.
+ * @author arv@google.com (Erik Arvidsson)
+ */
+
+
+goog.provide('goog.graphics.GroupElement');
+
+goog.require('goog.graphics.Element');
+
+
+
+/**
+ * Interface for a graphics group element.
+ * 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.graphics.Element}
+ * @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.GroupElement = function(element, graphics) {
+ goog.graphics.Element.call(this, element, graphics);
+};
+goog.inherits(goog.graphics.GroupElement, goog.graphics.Element);
+
+
+/**
+ * Remove all drawing elements from the group.
+ */
+goog.graphics.GroupElement.prototype.clear = goog.abstractMethod;
+
+
+/**
+ * Set the size of the group element.
+ * @param {number|string} width The width of the group element.
+ * @param {number|string} height The height of the group element.
+ */
+goog.graphics.GroupElement.prototype.setSize = goog.abstractMethod;
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/graphics/imageelement.js
----------------------------------------------------------------------
diff --git a/externs/GCL/externs/goog/graphics/imageelement.js b/externs/GCL/externs/goog/graphics/imageelement.js
new file mode 100644
index 0000000..2f2d9b7
--- /dev/null
+++ b/externs/GCL/externs/goog/graphics/imageelement.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 thin wrapper around the DOM element for images.
+ */
+
+
+goog.provide('goog.graphics.ImageElement');
+
+goog.require('goog.graphics.Element');
+
+
+
+/**
+ * Interface for a graphics image element.
+ * You should not construct objects from this constructor. Instead,
+ * you should use {@code goog.graphics.Graphics.drawImage} and it
+ * 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.
+ * @constructor
+ * @extends {goog.graphics.Element}
+ * @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.ImageElement = function(element, graphics) {
+ goog.graphics.Element.call(this, element, graphics);
+};
+goog.inherits(goog.graphics.ImageElement, goog.graphics.Element);
+
+
+/**
+ * Update the position of the image.
+ *
+ * @param {number} x X coordinate (left).
+ * @param {number} y Y coordinate (top).
+ */
+goog.graphics.ImageElement.prototype.setPosition = goog.abstractMethod;
+
+
+/**
+ * Update the size of the image.
+ *
+ * @param {number} width Width of image.
+ * @param {number} height Height of image.
+ */
+goog.graphics.ImageElement.prototype.setSize = goog.abstractMethod;
+
+
+/**
+ * Update the source of the image.
+ * @param {string} src Source of the image.
+ */
+goog.graphics.ImageElement.prototype.setSource = goog.abstractMethod;
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/graphics/lineargradient.js
----------------------------------------------------------------------
diff --git a/externs/GCL/externs/goog/graphics/lineargradient.js b/externs/GCL/externs/goog/graphics/lineargradient.js
new file mode 100644
index 0000000..df59cbf
--- /dev/null
+++ b/externs/GCL/externs/goog/graphics/lineargradient.js
@@ -0,0 +1,175 @@
+// 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 gradient to be used with a Graphics implementor.
+ * @author arv@google.com (Erik Arvidsson)
+ */
+
+
+goog.provide('goog.graphics.LinearGradient');
+
+
+goog.require('goog.asserts');
+goog.require('goog.graphics.Fill');
+
+
+
+/**
+ * Creates an immutable linear gradient fill object.
+ *
+ * @param {number} x1 Start X position of the gradient.
+ * @param {number} y1 Start Y position of the gradient.
+ * @param {number} x2 End X position of the gradient.
+ * @param {number} y2 End Y position of the gradient.
+ * @param {string} color1 Start color of the gradient.
+ * @param {string} color2 End color of the gradient.
+ * @param {?number=} opt_opacity1 Start opacity of the gradient, both or neither
+ * of opt_opacity1 and opt_opacity2 have to be set.
+ * @param {?number=} opt_opacity2 End opacity of the gradient.
+ * @constructor
+ * @extends {goog.graphics.Fill}
+ * @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.LinearGradient =
+ function(x1, y1, x2, y2, color1, color2, opt_opacity1, opt_opacity2) {
+ /**
+ * Start X position of the gradient.
+ * @type {number}
+ * @private
+ */
+ this.x1_ = x1;
+
+ /**
+ * Start Y position of the gradient.
+ * @type {number}
+ * @private
+ */
+ this.y1_ = y1;
+
+ /**
+ * End X position of the gradient.
+ * @type {number}
+ * @private
+ */
+ this.x2_ = x2;
+
+ /**
+ * End Y position of the gradient.
+ * @type {number}
+ * @private
+ */
+ this.y2_ = y2;
+
+ /**
+ * Start color of the gradient.
+ * @type {string}
+ * @private
+ */
+ this.color1_ = color1;
+
+ /**
+ * End color of the gradient.
+ * @type {string}
+ * @private
+ */
+ this.color2_ = color2;
+
+ goog.asserts.assert(
+ goog.isNumber(opt_opacity1) == goog.isNumber(opt_opacity2),
+ 'Both or neither of opt_opacity1 and opt_opacity2 have to be set.');
+
+ /**
+ * Start opacity of the gradient.
+ * @type {?number}
+ * @private
+ */
+ this.opacity1_ = goog.isDef(opt_opacity1) ? opt_opacity1 : null;
+
+ /**
+ * End opacity of the gradient.
+ * @type {?number}
+ * @private
+ */
+ this.opacity2_ = goog.isDef(opt_opacity2) ? opt_opacity2 : null;
+};
+goog.inherits(goog.graphics.LinearGradient, goog.graphics.Fill);
+
+
+/**
+ * @return {number} The start X position of the gradient.
+ */
+goog.graphics.LinearGradient.prototype.getX1 = function() {
+ return this.x1_;
+};
+
+
+/**
+ * @return {number} The start Y position of the gradient.
+ */
+goog.graphics.LinearGradient.prototype.getY1 = function() {
+ return this.y1_;
+};
+
+
+/**
+ * @return {number} The end X position of the gradient.
+ */
+goog.graphics.LinearGradient.prototype.getX2 = function() {
+ return this.x2_;
+};
+
+
+/**
+ * @return {number} The end Y position of the gradient.
+ */
+goog.graphics.LinearGradient.prototype.getY2 = function() {
+ return this.y2_;
+};
+
+
+/**
+ * @override
+ */
+goog.graphics.LinearGradient.prototype.getColor1 = function() {
+ return this.color1_;
+};
+
+
+/**
+ * @override
+ */
+goog.graphics.LinearGradient.prototype.getColor2 = function() {
+ return this.color2_;
+};
+
+
+/**
+ * @return {?number} The start opacity of the gradient.
+ */
+goog.graphics.LinearGradient.prototype.getOpacity1 = function() {
+ return this.opacity1_;
+};
+
+
+/**
+ * @return {?number} The end opacity of the gradient.
+ */
+goog.graphics.LinearGradient.prototype.getOpacity2 = function() {
+ return this.opacity2_;
+};
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/graphics/path.js
----------------------------------------------------------------------
diff --git a/externs/GCL/externs/goog/graphics/path.js b/externs/GCL/externs/goog/graphics/path.js
new file mode 100644
index 0000000..c19f2d9
--- /dev/null
+++ b/externs/GCL/externs/goog/graphics/path.js
@@ -0,0 +1,511 @@
+// 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 path used with a Graphics implementation.
+ * @author arv@google.com (Erik Arvidsson)
+ */
+
+goog.provide('goog.graphics.Path');
+goog.provide('goog.graphics.Path.Segment');
+
+goog.require('goog.array');
+goog.require('goog.math');
+
+
+
+/**
+ * Creates a path object. A path is a sequence of segments and may be open or
+ * closed. Path uses the EVEN-ODD fill rule for determining the interior of the
+ * path. A path must start with a moveTo command.
+ *
+ * A "simple" path does not contain any arcs and may be transformed using
+ * the {@code transform} method.
+ *
+ * @constructor
+ */
+goog.graphics.Path = function() {
+ /**
+ * The segment types that constitute this path.
+ * @type {!Array<number>}
+ * @private
+ */
+ this.segments_ = [];
+
+ /**
+ * The number of repeated segments of the current type.
+ * @type {!Array<number>}
+ * @private
+ */
+ this.count_ = [];
+
+ /**
+ * The arguments corresponding to each of the segments.
+ * @type {!Array<number>}
+ * @private
+ */
+ this.arguments_ = [];
+};
+
+
+/**
+ * The coordinates of the point which closes the path (the point of the
+ * last moveTo command).
+ * @type {Array<number>?}
+ * @private
+ */
+goog.graphics.Path.prototype.closePoint_ = null;
+
+
+/**
+ * The coordinates most recently added to the end of the path.
+ * @type {Array<number>?}
+ * @private
+ */
+goog.graphics.Path.prototype.currentPoint_ = null;
+
+
+/**
+ * Flag for whether this is a simple path (contains no arc segments).
+ * @type {boolean}
+ * @private
+ */
+goog.graphics.Path.prototype.simple_ = true;
+
+
+/**
+ * Path segment types.
+ * @enum {number}
+ */
+goog.graphics.Path.Segment = {
+ MOVETO: 0,
+ LINETO: 1,
+ CURVETO: 2,
+ ARCTO: 3,
+ CLOSE: 4
+};
+
+
+/**
+ * The number of points for each segment type.
+ * @type {!Array<number>}
+ * @private
+ */
+goog.graphics.Path.segmentArgCounts_ = (function() {
+ var counts = [];
+ counts[goog.graphics.Path.Segment.MOVETO] = 2;
+ counts[goog.graphics.Path.Segment.LINETO] = 2;
+ counts[goog.graphics.Path.Segment.CURVETO] = 6;
+ counts[goog.graphics.Path.Segment.ARCTO] = 6;
+ counts[goog.graphics.Path.Segment.CLOSE] = 0;
+ return counts;
+})();
+
+
+/**
+ * Returns the number of points for a segment type.
+ *
+ * @param {number} segment The segment type.
+ * @return {number} The number of points.
+ */
+goog.graphics.Path.getSegmentCount = function(segment) {
+ return goog.graphics.Path.segmentArgCounts_[segment];
+};
+
+
+/**
+ * Appends another path to the end of this path.
+ *
+ * @param {!goog.graphics.Path} path The path to append.
+ * @return {!goog.graphics.Path} This path.
+ */
+goog.graphics.Path.prototype.appendPath = function(path) {
+ if (path.currentPoint_) {
+ Array.prototype.push.apply(this.segments_, path.segments_);
+ Array.prototype.push.apply(this.count_, path.count_);
+ Array.prototype.push.apply(this.arguments_, path.arguments_);
+ this.currentPoint_ = path.currentPoint_.concat();
+ this.closePoint_ = path.closePoint_.concat();
+ this.simple_ = this.simple_ && path.simple_;
+ }
+ return this;
+};
+
+
+/**
+ * Clears the path.
+ *
+ * @return {!goog.graphics.Path} The path itself.
+ */
+goog.graphics.Path.prototype.clear = function() {
+ this.segments_.length = 0;
+ this.count_.length = 0;
+ this.arguments_.length = 0;
+ delete this.closePoint_;
+ delete this.currentPoint_;
+ delete this.simple_;
+ return this;
+};
+
+
+/**
+ * Adds a point to the path by moving to the specified point. Repeated moveTo
+ * commands are collapsed into a single moveTo.
+ *
+ * @param {number} x X coordinate of destination point.
+ * @param {number} y Y coordinate of destination point.
+ * @return {!goog.graphics.Path} The path itself.
+ */
+goog.graphics.Path.prototype.moveTo = function(x, y) {
+ if (goog.array.peek(this.segments_) == goog.graphics.Path.Segment.MOVETO) {
+ this.arguments_.length -= 2;
+ } else {
+ this.segments_.push(goog.graphics.Path.Segment.MOVETO);
+ this.count_.push(1);
+ }
+ this.arguments_.push(x, y);
+ this.currentPoint_ = this.closePoint_ = [x, y];
+ return this;
+};
+
+
+/**
+ * Adds points to the path by drawing a straight line to each point.
+ *
+ * @param {...number} var_args The coordinates of each destination point as x, y
+ * value pairs.
+ * @return {!goog.graphics.Path} The path itself.
+ */
+goog.graphics.Path.prototype.lineTo = function(var_args) {
+ var lastSegment = goog.array.peek(this.segments_);
+ if (lastSegment == null) {
+ throw Error('Path cannot start with lineTo');
+ }
+ if (lastSegment != goog.graphics.Path.Segment.LINETO) {
+ this.segments_.push(goog.graphics.Path.Segment.LINETO);
+ this.count_.push(0);
+ }
+ for (var i = 0; i < arguments.length; i += 2) {
+ var x = arguments[i];
+ var y = arguments[i + 1];
+ this.arguments_.push(x, y);
+ }
+ this.count_[this.count_.length - 1] += i / 2;
+ this.currentPoint_ = [x, y];
+ return this;
+};
+
+
+/**
+ * Adds points to the path by drawing cubic Bezier curves. Each curve is
+ * specified using 3 points (6 coordinates) - two control points and the end
+ * point of the curve.
+ *
+ * @param {...number} var_args The coordinates specifiying each curve in sets of
+ * 6 points: {@code [x1, y1]} the first control point, {@code [x2, y2]} the
+ * second control point and {@code [x, y]} the end point.
+ * @return {!goog.graphics.Path} The path itself.
+ */
+goog.graphics.Path.prototype.curveTo = function(var_args) {
+ var lastSegment = goog.array.peek(this.segments_);
+ if (lastSegment == null) {
+ throw Error('Path cannot start with curve');
+ }
+ if (lastSegment != goog.graphics.Path.Segment.CURVETO) {
+ this.segments_.push(goog.graphics.Path.Segment.CURVETO);
+ this.count_.push(0);
+ }
+ for (var i = 0; i < arguments.length; i += 6) {
+ var x = arguments[i + 4];
+ var y = arguments[i + 5];
+ this.arguments_.push(arguments[i], arguments[i + 1],
+ arguments[i + 2], arguments[i + 3], x, y);
+ }
+ this.count_[this.count_.length - 1] += i / 6;
+ this.currentPoint_ = [x, y];
+ return this;
+};
+
+
+/**
+ * Adds a path command to close the path by connecting the
+ * last point to the first point.
+ *
+ * @return {!goog.graphics.Path} The path itself.
+ */
+goog.graphics.Path.prototype.close = function() {
+ var lastSegment = goog.array.peek(this.segments_);
+ if (lastSegment == null) {
+ throw Error('Path cannot start with close');
+ }
+ if (lastSegment != goog.graphics.Path.Segment.CLOSE) {
+ this.segments_.push(goog.graphics.Path.Segment.CLOSE);
+ this.count_.push(1);
+ this.currentPoint_ = this.closePoint_;
+ }
+ return this;
+};
+
+
+/**
+ * Adds a path command to draw an arc centered at the point {@code (cx, cy)}
+ * with radius {@code rx} along the x-axis and {@code ry} along the y-axis from
+ * {@code startAngle} through {@code extent} degrees. Positive rotation is in
+ * the direction from positive x-axis to positive y-axis.
+ *
+ * @param {number} cx X coordinate of center of ellipse.
+ * @param {number} cy Y coordinate of center of ellipse.
+ * @param {number} rx Radius of ellipse on x axis.
+ * @param {number} ry Radius of ellipse on y axis.
+ * @param {number} fromAngle Starting angle measured in degrees from the
+ * positive x-axis.
+ * @param {number} extent The span of the arc in degrees.
+ * @param {boolean} connect If true, the starting point of the arc is connected
+ * to the current point.
+ * @return {!goog.graphics.Path} The path itself.
+ * @deprecated Use {@code arcTo} or {@code arcToAsCurves} instead.
+ */
+goog.graphics.Path.prototype.arc = function(cx, cy, rx, ry,
+ fromAngle, extent, connect) {
+ var startX = cx + goog.math.angleDx(fromAngle, rx);
+ var startY = cy + goog.math.angleDy(fromAngle, ry);
+ if (connect) {
+ if (!this.currentPoint_ || startX != this.currentPoint_[0] ||
+ startY != this.currentPoint_[1]) {
+ this.lineTo(startX, startY);
+ }
+ } else {
+ this.moveTo(startX, startY);
+ }
+ return this.arcTo(rx, ry, fromAngle, extent);
+};
+
+
+/**
+ * Adds a path command to draw an arc starting at the path's current point,
+ * with radius {@code rx} along the x-axis and {@code ry} along the y-axis from
+ * {@code startAngle} through {@code extent} degrees. Positive rotation is in
+ * the direction from positive x-axis to positive y-axis.
+ *
+ * This method makes the path non-simple.
+ *
+ * @param {number} rx Radius of ellipse on x axis.
+ * @param {number} ry Radius of ellipse on y axis.
+ * @param {number} fromAngle Starting angle measured in degrees from the
+ * positive x-axis.
+ * @param {number} extent The span of the arc in degrees.
+ * @return {!goog.graphics.Path} The path itself.
+ */
+goog.graphics.Path.prototype.arcTo = function(rx, ry, fromAngle, extent) {
+ var cx = this.currentPoint_[0] - goog.math.angleDx(fromAngle, rx);
+ var cy = this.currentPoint_[1] - goog.math.angleDy(fromAngle, ry);
+ var ex = cx + goog.math.angleDx(fromAngle + extent, rx);
+ var ey = cy + goog.math.angleDy(fromAngle + extent, ry);
+ this.segments_.push(goog.graphics.Path.Segment.ARCTO);
+ this.count_.push(1);
+ this.arguments_.push(rx, ry, fromAngle, extent, ex, ey);
+ this.simple_ = false;
+ this.currentPoint_ = [ex, ey];
+ return this;
+};
+
+
+/**
+ * Same as {@code arcTo}, but approximates the arc using bezier curves.
+.* As a result, this method does not affect the simplified status of this path.
+ * The algorithm is adapted from {@code java.awt.geom.ArcIterator}.
+ *
+ * @param {number} rx Radius of ellipse on x axis.
+ * @param {number} ry Radius of ellipse on y axis.
+ * @param {number} fromAngle Starting angle measured in degrees from the
+ * positive x-axis.
+ * @param {number} extent The span of the arc in degrees.
+ * @return {!goog.graphics.Path} The path itself.
+ */
+goog.graphics.Path.prototype.arcToAsCurves = function(
+ rx, ry, fromAngle, extent) {
+ var cx = this.currentPoint_[0] - goog.math.angleDx(fromAngle, rx);
+ var cy = this.currentPoint_[1] - goog.math.angleDy(fromAngle, ry);
+ var extentRad = goog.math.toRadians(extent);
+ var arcSegs = Math.ceil(Math.abs(extentRad) / Math.PI * 2);
+ var inc = extentRad / arcSegs;
+ var angle = goog.math.toRadians(fromAngle);
+ for (var j = 0; j < arcSegs; j++) {
+ var relX = Math.cos(angle);
+ var relY = Math.sin(angle);
+ var z = 4 / 3 * Math.sin(inc / 2) / (1 + Math.cos(inc / 2));
+ var c0 = cx + (relX - z * relY) * rx;
+ var c1 = cy + (relY + z * relX) * ry;
+ angle += inc;
+ relX = Math.cos(angle);
+ relY = Math.sin(angle);
+ this.curveTo(c0, c1,
+ cx + (relX + z * relY) * rx,
+ cy + (relY - z * relX) * ry,
+ cx + relX * rx,
+ cy + relY * ry);
+ }
+ return this;
+};
+
+
+/**
+ * Iterates over the path calling the supplied callback once for each path
+ * segment. The arguments to the callback function are the segment type and
+ * an array of its arguments.
+ *
+ * The {@code LINETO} and {@code CURVETO} arrays can contain multiple
+ * segments of the same type. The number of segments is the length of the
+ * array divided by the segment length (2 for lines, 6 for curves).
+ *
+ * As a convenience the {@code ARCTO} segment also includes the end point as the
+ * last two arguments: {@code rx, ry, fromAngle, extent, x, y}.
+ *
+ * @param {function(number, Array)} callback The function to call with each
+ * path segment.
+ */
+goog.graphics.Path.prototype.forEachSegment = function(callback) {
+ var points = this.arguments_;
+ var index = 0;
+ for (var i = 0, length = this.segments_.length; i < length; i++) {
+ var seg = this.segments_[i];
+ var n = goog.graphics.Path.segmentArgCounts_[seg] * this.count_[i];
+ callback(seg, points.slice(index, index + n));
+ index += n;
+ }
+};
+
+
+/**
+ * Returns the coordinates most recently added to the end of the path.
+ *
+ * @return {Array<number>?} An array containing the ending coordinates of the
+ * path of the form {@code [x, y]}.
+ */
+goog.graphics.Path.prototype.getCurrentPoint = function() {
+ return this.currentPoint_ && this.currentPoint_.concat();
+};
+
+
+/**
+ * @return {!goog.graphics.Path} A copy of this path.
+ */
+goog.graphics.Path.prototype.clone = function() {
+ var path = new this.constructor();
+ path.segments_ = this.segments_.concat();
+ path.count_ = this.count_.concat();
+ path.arguments_ = this.arguments_.concat();
+ path.closePoint_ = this.closePoint_ && this.closePoint_.concat();
+ path.currentPoint_ = this.currentPoint_ && this.currentPoint_.concat();
+ path.simple_ = this.simple_;
+ return path;
+};
+
+
+/**
+ * Returns true if this path contains no arcs. Simplified paths can be
+ * created using {@code createSimplifiedPath}.
+ *
+ * @return {boolean} True if the path contains no arcs.
+ */
+goog.graphics.Path.prototype.isSimple = function() {
+ return this.simple_;
+};
+
+
+/**
+ * A map from segment type to the path function to call to simplify a path.
+ * @type {!Object}
+ * @private
+ * @suppress {deprecated} goog.graphics.Path is deprecated.
+ */
+goog.graphics.Path.simplifySegmentMap_ = (function() {
+ var map = {};
+ map[goog.graphics.Path.Segment.MOVETO] = goog.graphics.Path.prototype.moveTo;
+ map[goog.graphics.Path.Segment.LINETO] = goog.graphics.Path.prototype.lineTo;
+ map[goog.graphics.Path.Segment.CLOSE] = goog.graphics.Path.prototype.close;
+ map[goog.graphics.Path.Segment.CURVETO] =
+ goog.graphics.Path.prototype.curveTo;
+ map[goog.graphics.Path.Segment.ARCTO] =
+ goog.graphics.Path.prototype.arcToAsCurves;
+ return map;
+})();
+
+
+/**
+ * Creates a copy of the given path, replacing {@code arcTo} with
+ * {@code arcToAsCurves}. The resulting path is simplified and can
+ * be transformed.
+ *
+ * @param {!goog.graphics.Path} src The path to simplify.
+ * @return {!goog.graphics.Path} A new simplified path.
+ * @suppress {deprecated} goog.graphics is deprecated.
+ */
+goog.graphics.Path.createSimplifiedPath = function(src) {
+ if (src.isSimple()) {
+ return src.clone();
+ }
+ var path = new goog.graphics.Path();
+ src.forEachSegment(function(segment, args) {
+ goog.graphics.Path.simplifySegmentMap_[segment].apply(path, args);
+ });
+ return path;
+};
+
+
+// TODO(chrisn): Delete this method
+/**
+ * Creates a transformed copy of this path. The path is simplified
+ * {@see #createSimplifiedPath} prior to transformation.
+ *
+ * @param {!goog.graphics.AffineTransform} tx The transformation to perform.
+ * @return {!goog.graphics.Path} A new, transformed path.
+ */
+goog.graphics.Path.prototype.createTransformedPath = function(tx) {
+ var path = goog.graphics.Path.createSimplifiedPath(this);
+ path.transform(tx);
+ return path;
+};
+
+
+/**
+ * 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.Path} The path itself.
+ */
+goog.graphics.Path.prototype.transform = function(tx) {
+ if (!this.isSimple()) {
+ throw Error('Non-simple path');
+ }
+ tx.transform(this.arguments_, 0, this.arguments_, 0,
+ this.arguments_.length / 2);
+ if (this.closePoint_) {
+ tx.transform(this.closePoint_, 0, this.closePoint_, 0, 1);
+ }
+ if (this.currentPoint_ && this.closePoint_ != this.currentPoint_) {
+ tx.transform(this.currentPoint_, 0, this.currentPoint_, 0, 1);
+ }
+ return this;
+};
+
+
+/**
+ * @return {boolean} Whether the path is empty.
+ */
+goog.graphics.Path.prototype.isEmpty = function() {
+ return this.segments_.length == 0;
+};
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/graphics/pathelement.js
----------------------------------------------------------------------
diff --git a/externs/GCL/externs/goog/graphics/pathelement.js b/externs/GCL/externs/goog/graphics/pathelement.js
new file mode 100644
index 0000000..b58b8c6
--- /dev/null
+++ b/externs/GCL/externs/goog/graphics/pathelement.js
@@ -0,0 +1,54 @@
+// 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 paths.
+ * @author arv@google.com (Erik Arvidsson)
+ */
+
+
+goog.provide('goog.graphics.PathElement');
+
+goog.require('goog.graphics.StrokeAndFillElement');
+
+
+
+/**
+ * Interface for a graphics path 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.PathElement = function(element, graphics, stroke, fill) {
+ goog.graphics.StrokeAndFillElement.call(this, element, graphics, stroke,
+ fill);
+};
+goog.inherits(goog.graphics.PathElement, goog.graphics.StrokeAndFillElement);
+
+
+/**
+ * Update the underlying path.
+ * @param {!goog.graphics.Path} path The path object to draw.
+ */
+goog.graphics.PathElement.prototype.setPath = goog.abstractMethod;
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/graphics/paths.js
----------------------------------------------------------------------
diff --git a/externs/GCL/externs/goog/graphics/paths.js b/externs/GCL/externs/goog/graphics/paths.js
new file mode 100644
index 0000000..37b53d9
--- /dev/null
+++ b/externs/GCL/externs/goog/graphics/paths.js
@@ -0,0 +1,86 @@
+// Copyright 2010 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 Factories for common path types.
+ * @author nicksantos@google.com (Nick Santos)
+ */
+
+
+goog.provide('goog.graphics.paths');
+
+goog.require('goog.graphics.Path');
+goog.require('goog.math.Coordinate');
+
+
+/**
+ * Defines a regular n-gon by specifing the center, a vertex, and the total
+ * number of vertices.
+ * @param {goog.math.Coordinate} center The center point.
+ * @param {goog.math.Coordinate} vertex The vertex, which implicitly defines
+ * a radius as well.
+ * @param {number} n The number of vertices.
+ * @return {!goog.graphics.Path} The path.
+ */
+goog.graphics.paths.createRegularNGon = function(center, vertex, n) {
+ var path = new goog.graphics.Path();
+ path.moveTo(vertex.x, vertex.y);
+
+ var startAngle = Math.atan2(vertex.y - center.y, vertex.x - center.x);
+ var radius = goog.math.Coordinate.distance(center, vertex);
+ for (var i = 1; i < n; i++) {
+ var angle = startAngle + 2 * Math.PI * (i / n);
+ path.lineTo(center.x + radius * Math.cos(angle),
+ center.y + radius * Math.sin(angle));
+ }
+ path.close();
+ return path;
+};
+
+
+/**
+ * Defines an arrow.
+ * @param {goog.math.Coordinate} a Point A.
+ * @param {goog.math.Coordinate} b Point B.
+ * @param {?number} aHead The size of the arrow head at point A.
+ * 0 omits the head.
+ * @param {?number} bHead The size of the arrow head at point B.
+ * 0 omits the head.
+ * @return {!goog.graphics.Path} The path.
+ */
+goog.graphics.paths.createArrow = function(a, b, aHead, bHead) {
+ var path = new goog.graphics.Path();
+ path.moveTo(a.x, a.y);
+ path.lineTo(b.x, b.y);
+
+ var angle = Math.atan2(b.y - a.y, b.x - a.x);
+ if (aHead) {
+ path.appendPath(
+ goog.graphics.paths.createRegularNGon(
+ new goog.math.Coordinate(
+ a.x + aHead * Math.cos(angle),
+ a.y + aHead * Math.sin(angle)),
+ a, 3));
+ }
+ if (bHead) {
+ path.appendPath(
+ goog.graphics.paths.createRegularNGon(
+ new goog.math.Coordinate(
+ b.x + bHead * Math.cos(angle + Math.PI),
+ b.y + bHead * Math.sin(angle + Math.PI)),
+ b, 3));
+ }
+ return path;
+};
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/graphics/rectelement.js
----------------------------------------------------------------------
diff --git a/externs/GCL/externs/goog/graphics/rectelement.js b/externs/GCL/externs/goog/graphics/rectelement.js
new file mode 100644
index 0000000..9a6e9a1
--- /dev/null
+++ b/externs/GCL/externs/goog/graphics/rectelement.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 rectangles.
+ * @author arv@google.com (Erik Arvidsson)
+ */
+
+
+goog.provide('goog.graphics.RectElement');
+
+goog.require('goog.graphics.StrokeAndFillElement');
+
+
+
+/**
+ * Interface for a graphics rectangle 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.RectElement = function(element, graphics, stroke, fill) {
+ goog.graphics.StrokeAndFillElement.call(this, element, graphics, stroke,
+ fill);
+};
+goog.inherits(goog.graphics.RectElement, goog.graphics.StrokeAndFillElement);
+
+
+/**
+ * Update the position of the rectangle.
+ * @param {number} x X coordinate (left).
+ * @param {number} y Y coordinate (top).
+ */
+goog.graphics.RectElement.prototype.setPosition = goog.abstractMethod;
+
+
+/**
+ * Update the size of the rectangle.
+ * @param {number} width Width of rectangle.
+ * @param {number} height Height of rectangle.
+ */
+goog.graphics.RectElement.prototype.setSize = goog.abstractMethod;
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/graphics/solidfill.js
----------------------------------------------------------------------
diff --git a/externs/GCL/externs/goog/graphics/solidfill.js b/externs/GCL/externs/goog/graphics/solidfill.js
new file mode 100644
index 0000000..fae3fc4
--- /dev/null
+++ b/externs/GCL/externs/goog/graphics/solidfill.js
@@ -0,0 +1,74 @@
+// 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 solid color fill goog.graphics.
+ * @author arv@google.com (Erik Arvidsson)
+ */
+
+
+goog.provide('goog.graphics.SolidFill');
+
+
+goog.require('goog.graphics.Fill');
+
+
+
+/**
+ * Creates an immutable solid color fill object.
+ *
+ * @param {string} color The color of the background.
+ * @param {number=} opt_opacity The opacity of the background fill. The value
+ * must be greater than or equal to zero (transparent) and less than or
+ * equal to 1 (opaque).
+ * @constructor
+ * @extends {goog.graphics.Fill}
+ * @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.SolidFill = function(color, opt_opacity) {
+ /**
+ * The color with which to fill.
+ * @type {string}
+ * @private
+ */
+ this.color_ = color;
+
+
+ /**
+ * The opacity of the fill.
+ * @type {number}
+ * @private
+ */
+ this.opacity_ = opt_opacity == null ? 1.0 : opt_opacity;
+};
+goog.inherits(goog.graphics.SolidFill, goog.graphics.Fill);
+
+
+/**
+ * @return {string} The color of this fill.
+ */
+goog.graphics.SolidFill.prototype.getColor = function() {
+ return this.color_;
+};
+
+
+/**
+ * @return {number} The opacity of this fill.
+ */
+goog.graphics.SolidFill.prototype.getOpacity = function() {
+ return this.opacity_;
+};
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/graphics/stroke.js
----------------------------------------------------------------------
diff --git a/externs/GCL/externs/goog/graphics/stroke.js b/externs/GCL/externs/goog/graphics/stroke.js
new file mode 100644
index 0000000..ae1eb8e
--- /dev/null
+++ b/externs/GCL/externs/goog/graphics/stroke.js
@@ -0,0 +1,86 @@
+// 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 stroke object for goog.graphics.
+ * @author arv@google.com (Erik Arvidsson)
+ */
+
+
+goog.provide('goog.graphics.Stroke');
+
+
+
+/**
+ * Creates an immutable stroke object.
+ *
+ * @param {number|string} width The width of the stroke.
+ * @param {string} color The color of the stroke.
+ * @param {number=} opt_opacity The opacity of the background fill. The value
+ * must be greater than or equal to zero (transparent) and less than or
+ * equal to 1 (opaque).
+ * @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.Stroke = function(width, color, opt_opacity) {
+ /**
+ * The width of the stroke.
+ * @type {number|string}
+ * @private
+ */
+ this.width_ = width;
+
+
+ /**
+ * The color with which to fill.
+ * @type {string}
+ * @private
+ */
+ this.color_ = color;
+
+
+ /**
+ * The opacity of the fill.
+ * @type {number}
+ * @private
+ */
+ this.opacity_ = opt_opacity == null ? 1.0 : opt_opacity;
+};
+
+
+/**
+ * @return {number|string} The width of this stroke.
+ */
+goog.graphics.Stroke.prototype.getWidth = function() {
+ return this.width_;
+};
+
+
+/**
+ * @return {string} The color of this stroke.
+ */
+goog.graphics.Stroke.prototype.getColor = function() {
+ return this.color_;
+};
+
+
+/**
+ * @return {number} The opacity of this fill.
+ */
+goog.graphics.Stroke.prototype.getOpacity = function() {
+ return this.opacity_;
+};
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/graphics/strokeandfillelement.js
----------------------------------------------------------------------
diff --git a/externs/GCL/externs/goog/graphics/strokeandfillelement.js b/externs/GCL/externs/goog/graphics/strokeandfillelement.js
new file mode 100644
index 0000000..e3b50f9
--- /dev/null
+++ b/externs/GCL/externs/goog/graphics/strokeandfillelement.js
@@ -0,0 +1,114 @@
+// 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 elements with a
+ * stroke and fill.
+ * @author arv@google.com (Erik Arvidsson)
+ */
+
+
+goog.provide('goog.graphics.StrokeAndFillElement');
+
+goog.require('goog.graphics.Element');
+
+
+
+/**
+ * Interface for a graphics element with a stroke and fill.
+ * This is the base interface for ellipse, rectangle and other
+ * shape interfaces.
+ * 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.Element}
+ * @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.StrokeAndFillElement = function(element, graphics, stroke, fill) {
+ goog.graphics.Element.call(this, element, graphics);
+ this.setStroke(stroke);
+ this.setFill(fill);
+};
+goog.inherits(goog.graphics.StrokeAndFillElement, goog.graphics.Element);
+
+
+/**
+ * The latest fill applied to this element.
+ * @type {goog.graphics.Fill?}
+ * @protected
+ */
+goog.graphics.StrokeAndFillElement.prototype.fill = null;
+
+
+/**
+ * The latest stroke applied to this element.
+ * @type {goog.graphics.Stroke?}
+ * @private
+ */
+goog.graphics.StrokeAndFillElement.prototype.stroke_ = null;
+
+
+/**
+ * Sets the fill for this element.
+ * @param {goog.graphics.Fill?} fill The fill object.
+ */
+goog.graphics.StrokeAndFillElement.prototype.setFill = function(fill) {
+ this.fill = fill;
+ this.getGraphics().setElementFill(this, fill);
+};
+
+
+/**
+ * @return {goog.graphics.Fill?} fill The fill object.
+ */
+goog.graphics.StrokeAndFillElement.prototype.getFill = function() {
+ return this.fill;
+};
+
+
+/**
+ * Sets the stroke for this element.
+ * @param {goog.graphics.Stroke?} stroke The stroke object.
+ */
+goog.graphics.StrokeAndFillElement.prototype.setStroke = function(stroke) {
+ this.stroke_ = stroke;
+ this.getGraphics().setElementStroke(this, stroke);
+};
+
+
+/**
+ * @return {goog.graphics.Stroke?} stroke The stroke object.
+ */
+goog.graphics.StrokeAndFillElement.prototype.getStroke = function() {
+ return this.stroke_;
+};
+
+
+/**
+ * Re-strokes the element to react to coordinate size changes.
+ */
+goog.graphics.StrokeAndFillElement.prototype.reapplyStroke = function() {
+ if (this.stroke_) {
+ this.setStroke(this.stroke_);
+ }
+};
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/graphics/svgelement.js
----------------------------------------------------------------------
diff --git a/externs/GCL/externs/goog/graphics/svgelement.js b/externs/GCL/externs/goog/graphics/svgelement.js
new file mode 100644
index 0000000..eddcbb5
--- /dev/null
+++ b/externs/GCL/externs/goog/graphics/svgelement.js
@@ -0,0 +1,284 @@
+// 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 Thin wrappers around the DOM element returned from
+ * the different draw methods of the graphics. This is the SVG implementation.
+ * @author arv@google.com (Erik Arvidsson)
+ */
+
+goog.provide('goog.graphics.SvgEllipseElement');
+goog.provide('goog.graphics.SvgGroupElement');
+goog.provide('goog.graphics.SvgImageElement');
+goog.provide('goog.graphics.SvgPathElement');
+goog.provide('goog.graphics.SvgRectElement');
+goog.provide('goog.graphics.SvgTextElement');
+
+
+goog.require('goog.dom');
+goog.require('goog.graphics.EllipseElement');
+goog.require('goog.graphics.GroupElement');
+goog.require('goog.graphics.ImageElement');
+goog.require('goog.graphics.PathElement');
+goog.require('goog.graphics.RectElement');
+goog.require('goog.graphics.TextElement');
+
+
+
+/**
+ * Thin wrapper for SVG group elements.
+ * 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.SvgGraphics} graphics The graphics creating
+ * this element.
+ * @constructor
+ * @extends {goog.graphics.GroupElement}
+ * @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.SvgGroupElement = function(element, graphics) {
+ goog.graphics.GroupElement.call(this, element, graphics);
+};
+goog.inherits(goog.graphics.SvgGroupElement, goog.graphics.GroupElement);
+
+
+/**
+ * Remove all drawing elements from the group.
+ * @override
+ */
+goog.graphics.SvgGroupElement.prototype.clear = function() {
+ goog.dom.removeChildren(this.getElement());
+};
+
+
+/**
+ * Set the size of the group element.
+ * @param {number|string} width The width of the group element.
+ * @param {number|string} height The height of the group element.
+ * @override
+ */
+goog.graphics.SvgGroupElement.prototype.setSize = function(width, height) {
+ this.getGraphics().setElementAttributes(this.getElement(),
+ {'width': width, 'height': height});
+};
+
+
+
+/**
+ * Thin wrapper for SVG ellipse elements.
+ * This is an implementation of the goog.graphics.EllipseElement interface.
+ * 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.SvgGraphics} 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.EllipseElement}
+ * @final
+ */
+goog.graphics.SvgEllipseElement = function(element, graphics, stroke, fill) {
+ goog.graphics.EllipseElement.call(this, element, graphics, stroke, fill);
+};
+goog.inherits(goog.graphics.SvgEllipseElement, goog.graphics.EllipseElement);
+
+
+/**
+ * Update the center point of the ellipse.
+ * @param {number} cx Center X coordinate.
+ * @param {number} cy Center Y coordinate.
+ * @override
+ */
+goog.graphics.SvgEllipseElement.prototype.setCenter = function(cx, cy) {
+ this.getGraphics().setElementAttributes(this.getElement(),
+ {'cx': cx, 'cy': cy});
+};
+
+
+/**
+ * Update the radius of the ellipse.
+ * @param {number} rx Radius length for the x-axis.
+ * @param {number} ry Radius length for the y-axis.
+ * @override
+ */
+goog.graphics.SvgEllipseElement.prototype.setRadius = function(rx, ry) {
+ this.getGraphics().setElementAttributes(this.getElement(),
+ {'rx': rx, 'ry': ry});
+};
+
+
+
+/**
+ * Thin wrapper for SVG rectangle elements.
+ * This is an implementation of the goog.graphics.RectElement interface.
+ * 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.SvgGraphics} 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.RectElement}
+ * @final
+ */
+goog.graphics.SvgRectElement = function(element, graphics, stroke, fill) {
+ goog.graphics.RectElement.call(this, element, graphics, stroke, fill);
+};
+goog.inherits(goog.graphics.SvgRectElement, goog.graphics.RectElement);
+
+
+/**
+ * Update the position of the rectangle.
+ * @param {number} x X coordinate (left).
+ * @param {number} y Y coordinate (top).
+ * @override
+ */
+goog.graphics.SvgRectElement.prototype.setPosition = function(x, y) {
+ this.getGraphics().setElementAttributes(this.getElement(), {'x': x, 'y': y});
+};
+
+
+/**
+ * Update the size of the rectangle.
+ * @param {number} width Width of rectangle.
+ * @param {number} height Height of rectangle.
+ * @override
+ */
+goog.graphics.SvgRectElement.prototype.setSize = function(width, height) {
+ this.getGraphics().setElementAttributes(this.getElement(),
+ {'width': width, 'height': height});
+};
+
+
+
+/**
+ * Thin wrapper for SVG path elements.
+ * This is an implementation of the goog.graphics.PathElement interface.
+ * 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.SvgGraphics} 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.PathElement}
+ * @final
+ */
+goog.graphics.SvgPathElement = function(element, graphics, stroke, fill) {
+ goog.graphics.PathElement.call(this, element, graphics, stroke, fill);
+};
+goog.inherits(goog.graphics.SvgPathElement, goog.graphics.PathElement);
+
+
+/**
+ * Update the underlying path.
+ * @param {!goog.graphics.Path} path The path object to draw.
+ * @override
+ */
+goog.graphics.SvgPathElement.prototype.setPath = function(path) {
+ this.getGraphics().setElementAttributes(this.getElement(),
+ {'d': /** @suppress {missingRequire} */
+ goog.graphics.SvgGraphics.getSvgPath(path)});
+};
+
+
+
+/**
+ * Thin wrapper for SVG text elements.
+ * This is an implementation of the goog.graphics.TextElement interface.
+ * 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.SvgGraphics} 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.TextElement}
+ * @final
+ */
+goog.graphics.SvgTextElement = function(element, graphics, stroke, fill) {
+ goog.graphics.TextElement.call(this, element, graphics, stroke, fill);
+};
+goog.inherits(goog.graphics.SvgTextElement, goog.graphics.TextElement);
+
+
+/**
+ * Update the displayed text of the element.
+ * @param {string} text The text to draw.
+ * @override
+ */
+goog.graphics.SvgTextElement.prototype.setText = function(text) {
+ this.getElement().firstChild.data = text;
+};
+
+
+
+/**
+ * Thin wrapper for SVG image elements.
+ * This is an implementation of the goog.graphics.ImageElement interface.
+ * 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.SvgGraphics} graphics The graphics creating
+ * this element.
+ * @constructor
+ * @extends {goog.graphics.ImageElement}
+ * @final
+ */
+goog.graphics.SvgImageElement = function(element, graphics) {
+ goog.graphics.ImageElement.call(this, element, graphics);
+};
+goog.inherits(goog.graphics.SvgImageElement, goog.graphics.ImageElement);
+
+
+/**
+ * Update the position of the image.
+ * @param {number} x X coordinate (left).
+ * @param {number} y Y coordinate (top).
+ * @override
+ */
+goog.graphics.SvgImageElement.prototype.setPosition = function(x, y) {
+ this.getGraphics().setElementAttributes(this.getElement(), {'x': x, 'y': y});
+};
+
+
+/**
+ * Update the size of the image.
+ * @param {number} width Width of image.
+ * @param {number} height Height of image.
+ * @override
+ */
+goog.graphics.SvgImageElement.prototype.setSize = function(width, height) {
+ this.getGraphics().setElementAttributes(this.getElement(),
+ {'width': width, 'height': height});
+};
+
+
+/**
+ * Update the source of the image.
+ * @param {string} src Source of the image.
+ * @override
+ */
+goog.graphics.SvgImageElement.prototype.setSource = function(src) {
+ this.getGraphics().setElementAttributes(this.getElement(),
+ {'xlink:href': src});
+};
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/graphics/svggraphics.js
----------------------------------------------------------------------
diff --git a/externs/GCL/externs/goog/graphics/svggraphics.js b/externs/GCL/externs/goog/graphics/svggraphics.js
new file mode 100644
index 0000000..59db4a2
--- /dev/null
+++ b/externs/GCL/externs/goog/graphics/svggraphics.js
@@ -0,0 +1,878 @@
+// 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 SvgGraphics sub class that uses SVG to draw the graphics.
+ * @author arv@google.com (Erik Arvidsson)
+ */
+
+goog.provide('goog.graphics.SvgGraphics');
+
+goog.require('goog.Timer');
+goog.require('goog.dom');
+goog.require('goog.events.EventHandler');
+goog.require('goog.events.EventType');
+goog.require('goog.graphics.AbstractGraphics');
+goog.require('goog.graphics.LinearGradient');
+goog.require('goog.graphics.Path');
+goog.require('goog.graphics.SolidFill');
+goog.require('goog.graphics.Stroke');
+goog.require('goog.graphics.SvgEllipseElement');
+goog.require('goog.graphics.SvgGroupElement');
+goog.require('goog.graphics.SvgImageElement');
+goog.require('goog.graphics.SvgPathElement');
+goog.require('goog.graphics.SvgRectElement');
+goog.require('goog.graphics.SvgTextElement');
+goog.require('goog.math');
+goog.require('goog.math.Size');
+goog.require('goog.style');
+goog.require('goog.userAgent');
+
+
+
+/**
+ * A Graphics implementation for drawing using SVG.
+ * @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.
+ * @constructor
+ * @extends {goog.graphics.AbstractGraphics}
+ * @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.SvgGraphics = function(width, height,
+ opt_coordWidth, opt_coordHeight,
+ opt_domHelper) {
+ goog.graphics.AbstractGraphics.call(this, width, height,
+ opt_coordWidth, opt_coordHeight,
+ opt_domHelper);
+
+ /**
+ * Map from def key to id of def root element.
+ * Defs are global "defines" of svg that are used to share common attributes,
+ * for example gradients.
+ * @type {Object}
+ * @private
+ */
+ this.defs_ = {};
+
+ /**
+ * Whether to manually implement viewBox by using a coordinate transform.
+ * As of 1/11/08 this is necessary for Safari 3 but not for the nightly
+ * WebKit build. Apply to webkit versions < 526. 525 is the
+ * last version used by Safari 3.1.
+ * @type {boolean}
+ * @private
+ */
+ this.useManualViewbox_ = goog.userAgent.WEBKIT &&
+ !goog.userAgent.isVersionOrHigher(526);
+
+ /**
+ * Event handler.
+ * @type {goog.events.EventHandler<!goog.graphics.SvgGraphics>}
+ * @private
+ */
+ this.handler_ = new goog.events.EventHandler(this);
+};
+goog.inherits(goog.graphics.SvgGraphics, goog.graphics.AbstractGraphics);
+
+
+/**
+ * The SVG namespace URN
+ * @private
+ * @type {string}
+ */
+goog.graphics.SvgGraphics.SVG_NS_ = 'http://www.w3.org/2000/svg';
+
+
+/**
+ * The name prefix for def entries
+ * @private
+ * @type {string}
+ */
+goog.graphics.SvgGraphics.DEF_ID_PREFIX_ = '_svgdef_';
+
+
+/**
+ * The next available unique identifier for a def entry.
+ * This is a static variable, so that when multiple graphics are used in one
+ * document, the same def id can not be re-defined by another SvgGraphics.
+ * @type {number}
+ * @private
+ */
+goog.graphics.SvgGraphics.nextDefId_ = 0;
+
+
+/**
+ * Svg element for definitions for other elements, e.g. linear gradients.
+ * @type {Element}
+ * @private
+ */
+goog.graphics.SvgGraphics.prototype.defsElement_;
+
+
+/**
+ * Creates an SVG element. Used internally and by different SVG classes.
+ * @param {string} tagName The type of element to create.
+ * @param {Object=} opt_attributes Map of name-value pairs for attributes.
+ * @return {!Element} The created element.
+ * @private
+ */
+goog.graphics.SvgGraphics.prototype.createSvgElement_ = function(tagName,
+ opt_attributes) {
+ var element = this.dom_.getDocument().createElementNS(
+ goog.graphics.SvgGraphics.SVG_NS_, tagName);
+
+ if (opt_attributes) {
+ this.setElementAttributes(element, opt_attributes);
+ }
+
+ return element;
+};
+
+
+/**
+ * Sets properties to an SVG element. Used internally and by different
+ * SVG elements.
+ * @param {Element} element The svg element.
+ * @param {Object} attributes Map of name-value pairs for attributes.
+ */
+goog.graphics.SvgGraphics.prototype.setElementAttributes = function(element,
+ attributes) {
+ for (var key in attributes) {
+ element.setAttribute(key, attributes[key]);
+ }
+};
+
+
+/**
+ * Appends an element.
+ *
+ * @param {goog.graphics.Element} element The element wrapper.
+ * @param {goog.graphics.GroupElement=} opt_group The group wrapper element
+ * to append to. If not specified, appends to the main canvas.
+ * @private
+ */
+goog.graphics.SvgGraphics.prototype.append_ = function(element, opt_group) {
+ var parent = opt_group || this.canvasElement;
+ parent.getElement().appendChild(element.getElement());
+};
+
+
+/**
+ * Sets the fill of the given element.
+ * @param {goog.graphics.StrokeAndFillElement} element The element wrapper.
+ * @param {goog.graphics.Fill?} fill The fill object.
+ * @override
+ */
+goog.graphics.SvgGraphics.prototype.setElementFill = function(element, fill) {
+ var svgElement = element.getElement();
+ if (fill instanceof goog.graphics.SolidFill) {
+ svgElement.setAttribute('fill', fill.getColor());
+ svgElement.setAttribute('fill-opacity', fill.getOpacity());
+ } else if (fill instanceof goog.graphics.LinearGradient) {
+ // create a def key which is just a concat of all the relevant fields
+ var defKey = 'lg-' +
+ fill.getX1() + '-' + fill.getY1() + '-' +
+ fill.getX2() + '-' + fill.getY2() + '-' +
+ fill.getColor1() + '-' + fill.getColor2();
+ // It seems that the SVG version accepts opacity where the VML does not
+
+ var id = this.getDef(defKey);
+
+ if (!id) { // No def for this yet, create it
+ // Create the gradient def entry (only linear gradient are supported)
+ var gradient = this.createSvgElement_('linearGradient', {
+ 'x1': fill.getX1(),
+ 'y1': fill.getY1(),
+ 'x2': fill.getX2(),
+ 'y2': fill.getY2(),
+ 'gradientUnits': 'userSpaceOnUse'
+ });
+
+ var gstyle = 'stop-color:' + fill.getColor1();
+ if (goog.isNumber(fill.getOpacity1())) {
+ gstyle += ';stop-opacity:' + fill.getOpacity1();
+ }
+ var stop1 = this.createSvgElement_(
+ 'stop', {'offset': '0%', 'style': gstyle});
+ gradient.appendChild(stop1);
+
+ // LinearGradients don't have opacity in VML so implement that before
+ // enabling the following code.
+ // if (fill.getOpacity() != null) {
+ // gstyles += 'opacity:' + fill.getOpacity() + ';'
+ // }
+ gstyle = 'stop-color:' + fill.getColor2();
+ if (goog.isNumber(fill.getOpacity2())) {
+ gstyle += ';stop-opacity:' + fill.getOpacity2();
+ }
+ var stop2 = this.createSvgElement_(
+ 'stop', {'offset': '100%', 'style': gstyle});
+ gradient.appendChild(stop2);
+
+ // LinearGradients don't have opacity in VML so implement that before
+ // enabling the following code.
+ // if (fill.getOpacity() != null) {
+ // gstyles += 'opacity:' + fill.getOpacity() + ';'
+ // }
+
+ id = this.addDef(defKey, gradient);
+ }
+
+ // Link element to linearGradient definition
+ svgElement.setAttribute('fill', 'url(#' + id + ')');
+ } else {
+ svgElement.setAttribute('fill', 'none');
+ }
+};
+
+
+/**
+ * Sets the stroke of the given element.
+ * @param {goog.graphics.StrokeAndFillElement} element The element wrapper.
+ * @param {goog.graphics.Stroke?} stroke The stroke object.
+ * @override
+ */
+goog.graphics.SvgGraphics.prototype.setElementStroke = function(element,
+ stroke) {
+ var svgElement = element.getElement();
+ if (stroke) {
+ svgElement.setAttribute('stroke', stroke.getColor());
+ svgElement.setAttribute('stroke-opacity', stroke.getOpacity());
+
+ var width = stroke.getWidth();
+ if (goog.isString(width) && width.indexOf('px') != -1) {
+ svgElement.setAttribute('stroke-width',
+ parseFloat(width) / this.getPixelScaleX());
+ } else {
+ svgElement.setAttribute('stroke-width', width);
+ }
+ } else {
+ svgElement.setAttribute('stroke', 'none');
+ }
+};
+
+
+/**
+ * Set the translation and rotation of an element.
+ *
+ * If a more general affine transform is needed than this provides
+ * (e.g. skew and scale) then use setElementAffineTransform.
+ * @param {goog.graphics.Element} element The element wrapper.
+ * @param {number} x The x coordinate of the translation transform.
+ * @param {number} y The y coordinate of the translation transform.
+ * @param {number} angle 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.
+ * @override
+ */
+goog.graphics.SvgGraphics.prototype.setElementTransform = function(element, x,
+ y, angle, centerX, centerY) {
+ element.getElement().setAttribute('transform', 'translate(' + x + ',' + y +
+ ') rotate(' + angle + ' ' + centerX + ' ' + centerY + ')');
+};
+
+
+/**
+ * Set the transformation of an element.
+ * @param {goog.graphics.Element} element The element wrapper.
+ * @param {!goog.graphics.AffineTransform} affineTransform The
+ * transformation applied to this element.
+ * @override
+ */
+goog.graphics.SvgGraphics.prototype.setElementAffineTransform = function(
+ element, affineTransform) {
+ var t = affineTransform;
+ var substr = [t.getScaleX(), t.getShearY(), t.getShearX(), t.getScaleY(),
+ t.getTranslateX(), t.getTranslateY()].join(',');
+ element.getElement().setAttribute('transform', 'matrix(' + substr + ')');
+};
+
+
+/**
+ * Creates the DOM representation of the graphics area.
+ * @override
+ */
+goog.graphics.SvgGraphics.prototype.createDom = function() {
+ // Set up the standard attributes.
+ var attributes = {
+ 'width': this.width,
+ 'height': this.height,
+ 'overflow': 'hidden'
+ };
+
+ var svgElement = this.createSvgElement_('svg', attributes);
+
+ var groupElement = this.createSvgElement_('g');
+
+ this.defsElement_ = this.createSvgElement_('defs');
+ this.canvasElement = new goog.graphics.SvgGroupElement(groupElement, this);
+
+ svgElement.appendChild(this.defsElement_);
+ svgElement.appendChild(groupElement);
+
+ // Use the svgElement as the root element.
+ this.setElementInternal(svgElement);
+
+ // Set up the coordinate system.
+ this.setViewBox_();
+};
+
+
+/**
+ * Changes the coordinate system position.
+ * @param {number} left The coordinate system left bound.
+ * @param {number} top The coordinate system top bound.
+ * @override
+ */
+goog.graphics.SvgGraphics.prototype.setCoordOrigin = function(left, top) {
+ this.coordLeft = left;
+ this.coordTop = top;
+
+ this.setViewBox_();
+};
+
+
+/**
+ * Changes the coordinate size.
+ * @param {number} coordWidth The coordinate width.
+ * @param {number} coordHeight The coordinate height.
+ * @override
+ */
+goog.graphics.SvgGraphics.prototype.setCoordSize = function(coordWidth,
+ coordHeight) {
+ goog.graphics.SvgGraphics.superClass_.setCoordSize.apply(
+ this, arguments);
+ this.setViewBox_();
+};
+
+
+/**
+ * @return {string} The view box string.
+ * @private
+ */
+goog.graphics.SvgGraphics.prototype.getViewBox_ = function() {
+ return this.coordLeft + ' ' + this.coordTop + ' ' +
+ (this.coordWidth ? this.coordWidth + ' ' + this.coordHeight : '');
+};
+
+
+/**
+ * Sets up the view box.
+ * @private
+ */
+goog.graphics.SvgGraphics.prototype.setViewBox_ = function() {
+ if (this.coordWidth || this.coordLeft || this.coordTop) {
+ this.getElement().setAttribute('preserveAspectRatio', 'none');
+ if (this.useManualViewbox_) {
+ this.updateManualViewBox_();
+ } else {
+ this.getElement().setAttribute('viewBox', this.getViewBox_());
+ }
+ }
+};
+
+
+/**
+ * Updates the transform of the root element to fake a viewBox. Should only
+ * be called when useManualViewbox_ is set.
+ * @private
+ */
+goog.graphics.SvgGraphics.prototype.updateManualViewBox_ = function() {
+ if (!this.isInDocument() ||
+ !(this.coordWidth || this.coordLeft || !this.coordTop)) {
+ return;
+ }
+
+ var size = this.getPixelSize();
+ if (size.width == 0) {
+ // In Safari, invisible SVG is sometimes shown. Explicitly hide it.
+ this.getElement().style.visibility = 'hidden';
+ return;
+ }
+
+ this.getElement().style.visibility = '';
+
+ var offsetX = - this.coordLeft;
+ var offsetY = - this.coordTop;
+ var scaleX = size.width / this.coordWidth;
+ var scaleY = size.height / this.coordHeight;
+
+ this.canvasElement.getElement().setAttribute('transform',
+ 'scale(' + scaleX + ' ' + scaleY + ') ' +
+ 'translate(' + offsetX + ' ' + offsetY + ')');
+};
+
+
+/**
+ * Change the size of the canvas.
+ * @param {number} pixelWidth The width in pixels.
+ * @param {number} pixelHeight The height in pixels.
+ * @override
+ */
+goog.graphics.SvgGraphics.prototype.setSize = function(pixelWidth,
+ pixelHeight) {
+ goog.style.setSize(this.getElement(), pixelWidth, pixelHeight);
+};
+
+
+/** @override */
+goog.graphics.SvgGraphics.prototype.getPixelSize = function() {
+ if (!goog.userAgent.GECKO) {
+ return this.isInDocument() ?
+ goog.style.getSize(this.getElement()) :
+ goog.graphics.SvgGraphics.base(this, 'getPixelSize');
+ }
+
+ // In Gecko, goog.style.getSize does not work for SVG elements. We have to
+ // compute the size manually if it is percentage based.
+ var width = this.width;
+ var height = this.height;
+ var computeWidth = goog.isString(width) && width.indexOf('%') != -1;
+ var computeHeight = goog.isString(height) && height.indexOf('%') != -1;
+
+ if (!this.isInDocument() && (computeWidth || computeHeight)) {
+ return null;
+ }
+
+ var parent;
+ var parentSize;
+
+ if (computeWidth) {
+ parent = /** @type {Element} */ (this.getElement().parentNode);
+ parentSize = goog.style.getSize(parent);
+ width = parseFloat(/** @type {string} */ (width)) * parentSize.width / 100;
+ }
+
+ if (computeHeight) {
+ parent = parent || /** @type {Element} */ (this.getElement().parentNode);
+ parentSize = parentSize || goog.style.getSize(parent);
+ height = parseFloat(/** @type {string} */ (height)) * parentSize.height /
+ 100;
+ }
+
+ return new goog.math.Size(/** @type {number} */ (width),
+ /** @type {number} */ (height));
+};
+
+
+/**
+ * Remove all drawing elements from the graphics.
+ * @override
+ */
+goog.graphics.SvgGraphics.prototype.clear = function() {
+ this.canvasElement.clear();
+ goog.dom.removeChildren(this.defsElement_);
+ this.defs_ = {};
+};
+
+
+/**
+ * Draw an ellipse.
+ *
+ * @param {number} cx Center X coordinate.
+ * @param {number} cy Center Y coordinate.
+ * @param {number} rx Radius length for the x-axis.
+ * @param {number} ry Radius length for the y-axis.
+ * @param {goog.graphics.Stroke?} stroke Stroke object describing the
+ * stroke.
+ * @param {goog.graphics.Fill?} fill Fill object describing the fill.
+ * @param {goog.graphics.GroupElement=} opt_group The group wrapper element
+ * to append to. If not specified, appends to the main canvas.
+ *
+ * @return {!goog.graphics.EllipseElement} The newly created element.
+ * @override
+ */
+goog.graphics.SvgGraphics.prototype.drawEllipse = function(
+ cx, cy, rx, ry, stroke, fill, opt_group) {
+ var element = this.createSvgElement_('ellipse',
+ {'cx': cx, 'cy': cy, 'rx': rx, 'ry': ry});
+ var wrapper = new goog.graphics.SvgEllipseElement(element, this, stroke,
+ fill);
+ this.append_(wrapper, opt_group);
+ return wrapper;
+};
+
+
+/**
+ * Draw a rectangle.
+ *
+ * @param {number} x X coordinate (left).
+ * @param {number} y Y coordinate (top).
+ * @param {number} width Width of rectangle.
+ * @param {number} height Height of rectangle.
+ * @param {goog.graphics.Stroke?} stroke Stroke object describing the
+ * stroke.
+ * @param {goog.graphics.Fill?} fill Fill object describing the fill.
+ * @param {goog.graphics.GroupElement=} opt_group The group wrapper element
+ * to append to. If not specified, appends to the main canvas.
+ *
+ * @return {!goog.graphics.RectElement} The newly created element.
+ * @override
+ */
+goog.graphics.SvgGraphics.prototype.drawRect = function(x, y, width, height,
+ stroke, fill, opt_group) {
+ var element = this.createSvgElement_('rect',
+ {'x': x, 'y': y, 'width': width, 'height': height});
+ var wrapper = new goog.graphics.SvgRectElement(element, this, stroke, fill);
+ this.append_(wrapper, opt_group);
+ return wrapper;
+};
+
+
+/**
+ * Draw an image.
+ *
+ * @param {number} x X coordinate (left).
+ * @param {number} y Y coordinate (top).
+ * @param {number} width Width of the image.
+ * @param {number} height Height of the image.
+ * @param {string} src The source fo the image.
+ * @param {goog.graphics.GroupElement=} opt_group The group wrapper element
+ * to append to. If not specified, appends to the main canvas.
+ *
+ * @return {!goog.graphics.ImageElement} The newly created image wrapped in a
+ * rectangle element.
+ */
+goog.graphics.SvgGraphics.prototype.drawImage = function(x, y, width, height,
+ src, opt_group) {
+ var element = this.createSvgElement_('image', {
+ 'x': x,
+ 'y': y,
+ 'width': width,
+ 'height': height,
+ 'image-rendering': 'optimizeQuality',
+ 'preserveAspectRatio': 'none'
+ });
+ element.setAttributeNS('http://www.w3.org/1999/xlink', 'href', src);
+ var wrapper = new goog.graphics.SvgImageElement(element, this);
+ this.append_(wrapper, opt_group);
+ return wrapper;
+};
+
+
+/**
+ * Draw a text string vertically centered on a given line.
+ *
+ * @param {string} text The text to draw.
+ * @param {number} x1 X coordinate of start of line.
+ * @param {number} y1 Y coordinate of start of line.
+ * @param {number} x2 X coordinate of end of line.
+ * @param {number} y2 Y coordinate of end of line.
+ * @param {string} align Horizontal alignment: left (default), center, right.
+ * @param {goog.graphics.Font} font Font describing the font properties.
+ * @param {goog.graphics.Stroke?} stroke Stroke object describing the
+ * stroke.
+ * @param {goog.graphics.Fill?} fill Fill object describing the fill.
+ * @param {goog.graphics.GroupElement=} opt_group The group wrapper element
+ * to append to. If not specified, appends to the main canvas.
+ *
+ * @return {!goog.graphics.TextElement} The newly created element.
+ * @override
+ */
+goog.graphics.SvgGraphics.prototype.drawTextOnLine = function(
+ text, x1, y1, x2, y2, align, font, stroke, fill, opt_group) {
+ var angle = Math.round(goog.math.angle(x1, y1, x2, y2));
+ var dx = x2 - x1;
+ var dy = y2 - y1;
+ var lineLength = Math.round(Math.sqrt(dx * dx + dy * dy)); // Length of line
+
+ // SVG baseline is on the glyph's base line. We estimate it as 85% of the
+ // font height. This is just a rough estimate, but do not have a better way.
+ var fontSize = font.size;
+ var attributes = {'font-family': font.family, 'font-size': fontSize};
+ var baseline = Math.round(fontSize * 0.85);
+ var textY = Math.round(y1 - (fontSize / 2) + baseline);
+ var textX = x1;
+ if (align == 'center') {
+ textX += Math.round(lineLength / 2);
+ attributes['text-anchor'] = 'middle';
+ } else if (align == 'right') {
+ textX += lineLength;
+ attributes['text-anchor'] = 'end';
+ }
+ attributes['x'] = textX;
+ attributes['y'] = textY;
+ if (font.bold) {
+ attributes['font-weight'] = 'bold';
+ }
+ if (font.italic) {
+ attributes['font-style'] = 'italic';
+ }
+ if (angle != 0) {
+ attributes['transform'] = 'rotate(' + angle + ' ' + x1 + ' ' + y1 + ')';
+ }
+
+ var element = this.createSvgElement_('text', attributes);
+ element.appendChild(this.dom_.getDocument().createTextNode(text));
+
+ // Bypass a Firefox-Mac bug where text fill is ignored. If text has no stroke,
+ // set a stroke, otherwise the text will not be visible.
+ if (stroke == null && goog.userAgent.GECKO && goog.userAgent.MAC) {
+ var color = 'black';
+ // For solid fills, use the fill color
+ if (fill instanceof goog.graphics.SolidFill) {
+ color = fill.getColor();
+ }
+ stroke = new goog.graphics.Stroke(1, color);
+ }
+
+ var wrapper = new goog.graphics.SvgTextElement(element, this, stroke, fill);
+ this.append_(wrapper, opt_group);
+ return wrapper;
+};
+
+
+/**
+ * Draw a path.
+ *
+ * @param {!goog.graphics.Path} path The path object to draw.
+ * @param {goog.graphics.Stroke?} stroke Stroke object describing the
+ * stroke.
+ * @param {goog.graphics.Fill?} fill Fill object describing the fill.
+ * @param {goog.graphics.GroupElement=} opt_group The group wrapper element
+ * to append to. If not specified, appends to the main canvas.
+ *
+ * @return {!goog.graphics.PathElement} The newly created element.
+ * @override
+ */
+goog.graphics.SvgGraphics.prototype.drawPath = function(
+ path, stroke, fill, opt_group) {
+
+ var element = this.createSvgElement_('path',
+ {'d': goog.graphics.SvgGraphics.getSvgPath(path)});
+ var wrapper = new goog.graphics.SvgPathElement(element, this, stroke, fill);
+ this.append_(wrapper, opt_group);
+ return wrapper;
+};
+
+
+/**
+ * Returns a string representation of a logical path suitable for use in
+ * an SVG element.
+ *
+ * @param {goog.graphics.Path} path The logical path.
+ * @return {string} The SVG path representation.
+ * @suppress {deprecated} goog.graphics is deprecated.
+ */
+goog.graphics.SvgGraphics.getSvgPath = function(path) {
+ var list = [];
+ path.forEachSegment(function(segment, args) {
+ switch (segment) {
+ case goog.graphics.Path.Segment.MOVETO:
+ list.push('M');
+ Array.prototype.push.apply(list, args);
+ break;
+ case goog.graphics.Path.Segment.LINETO:
+ list.push('L');
+ Array.prototype.push.apply(list, args);
+ break;
+ case goog.graphics.Path.Segment.CURVETO:
+ list.push('C');
+ Array.prototype.push.apply(list, args);
+ break;
+ case goog.graphics.Path.Segment.ARCTO:
+ var extent = args[3];
+ list.push('A', args[0], args[1],
+ 0, Math.abs(extent) > 180 ? 1 : 0, extent > 0 ? 1 : 0,
+ args[4], args[5]);
+ break;
+ case goog.graphics.Path.Segment.CLOSE:
+ list.push('Z');
+ break;
+ }
+ });
+ return list.join(' ');
+};
+
+
+/**
+ * Create an empty group of drawing elements.
+ *
+ * @param {goog.graphics.GroupElement=} opt_group The group wrapper element
+ * to append to. If not specified, appends to the main canvas.
+ *
+ * @return {!goog.graphics.GroupElement} The newly created group.
+ * @override
+ */
+goog.graphics.SvgGraphics.prototype.createGroup = function(opt_group) {
+ var element = this.createSvgElement_('g');
+ var parent = opt_group || this.canvasElement;
+ parent.getElement().appendChild(element);
+ return new goog.graphics.SvgGroupElement(element, this);
+};
+
+
+/**
+ * Measure and return the width (in pixels) of a given text string.
+ * Text measurement is needed to make sure a text can fit in the allocated area.
+ * The way text length is measured is by writing it into a div that is after
+ * the visible area, measure the div width, and immediatly erase the written
+ * value.
+ *
+ * @param {string} text The text string to measure.
+ * @param {goog.graphics.Font} font The font object describing the font style.
+ * @override
+ */
+goog.graphics.SvgGraphics.prototype.getTextWidth = function(text, font) {
+ // TODO(user) Implement
+};
+
+
+/**
+ * Adds a defintion of an element to the global definitions.
+ * @param {string} defKey This is a key that should be unique in a way that
+ * if two definitions are equal the should have the same key.
+ * @param {Element} defElement DOM element to add as a definition. It must
+ * have an id attribute set.
+ * @return {string} The assigned id of the defElement.
+ */
+goog.graphics.SvgGraphics.prototype.addDef = function(defKey, defElement) {
+ if (defKey in this.defs_) {
+ return this.defs_[defKey];
+ }
+ var id = goog.graphics.SvgGraphics.DEF_ID_PREFIX_ +
+ goog.graphics.SvgGraphics.nextDefId_++;
+ defElement.setAttribute('id', id);
+ this.defs_[defKey] = id;
+
+ // Add the def defElement of the defs list.
+ var defs = this.defsElement_;
+ defs.appendChild(defElement);
+ return id;
+};
+
+
+/**
+ * Returns the id of a definition element.
+ * @param {string} defKey This is a key that should be unique in a way that
+ * if two definitions are equal the should have the same key.
+ * @return {?string} The id of the found definition element or null if
+ * not found.
+ */
+goog.graphics.SvgGraphics.prototype.getDef = function(defKey) {
+ return defKey in this.defs_ ? this.defs_[defKey] : null;
+};
+
+
+/**
+ * Removes a definition of an elemnt from the global definitions.
+ * @param {string} defKey This is a key that should be unique in a way that
+ * if two definitions are equal they should have the same key.
+ */
+goog.graphics.SvgGraphics.prototype.removeDef = function(defKey) {
+ var id = this.getDef(defKey);
+ if (id) {
+ var element = this.dom_.getElement(id);
+ this.defsElement_.removeChild(element);
+ delete this.defs_[defKey];
+ }
+};
+
+
+/** @override */
+goog.graphics.SvgGraphics.prototype.enterDocument = function() {
+ var oldPixelSize = this.getPixelSize();
+ goog.graphics.SvgGraphics.superClass_.enterDocument.call(this);
+
+ // Dispatch a resize if this is the first time the size value is accurate.
+ if (!oldPixelSize) {
+ this.dispatchEvent(goog.events.EventType.RESIZE);
+ }
+
+
+ // For percentage based heights, listen for changes to size.
+ if (this.useManualViewbox_) {
+ var width = this.width;
+ var height = this.height;
+
+ if (typeof width == 'string' && width.indexOf('%') != -1 &&
+ typeof height == 'string' && height.indexOf('%') != -1) {
+ // SVG elements don't behave well with respect to size events, so we
+ // resort to polling.
+ this.handler_.listen(goog.graphics.SvgGraphics.getResizeCheckTimer_(),
+ goog.Timer.TICK, this.updateManualViewBox_);
+ }
+
+ this.updateManualViewBox_();
+ }
+};
+
+
+/** @override */
+goog.graphics.SvgGraphics.prototype.exitDocument = function() {
+ goog.graphics.SvgGraphics.superClass_.exitDocument.call(this);
+
+ // Stop polling.
+ if (this.useManualViewbox_) {
+ this.handler_.unlisten(goog.graphics.SvgGraphics.getResizeCheckTimer_(),
+ goog.Timer.TICK, this.updateManualViewBox_);
+ }
+};
+
+
+/**
+ * Disposes of the component by removing event handlers, detacing DOM nodes from
+ * the document body, and removing references to them.
+ * @override
+ * @protected
+ */
+goog.graphics.SvgGraphics.prototype.disposeInternal = function() {
+ delete this.defs_;
+ delete this.defsElement_;
+ delete this.canvasElement;
+ this.handler_.dispose();
+ delete this.handler_;
+ goog.graphics.SvgGraphics.superClass_.disposeInternal.call(this);
+};
+
+
+/**
+ * The centralized resize checking timer.
+ * @type {goog.Timer|undefined}
+ * @private
+ */
+goog.graphics.SvgGraphics.resizeCheckTimer_;
+
+
+/**
+ * @return {goog.Timer} The centralized timer object used for interval timing.
+ * @private
+ */
+goog.graphics.SvgGraphics.getResizeCheckTimer_ = function() {
+ if (!goog.graphics.SvgGraphics.resizeCheckTimer_) {
+ goog.graphics.SvgGraphics.resizeCheckTimer_ = new goog.Timer(400);
+ goog.graphics.SvgGraphics.resizeCheckTimer_.start();
+ }
+
+ return /** @type {goog.Timer} */ (
+ goog.graphics.SvgGraphics.resizeCheckTimer_);
+};
+
+
+/** @override */
+goog.graphics.SvgGraphics.prototype.isDomClonable = function() {
+ return true;
+};
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/graphics/textelement.js
----------------------------------------------------------------------
diff --git a/externs/GCL/externs/goog/graphics/textelement.js b/externs/GCL/externs/goog/graphics/textelement.js
new file mode 100644
index 0000000..c96ae6d
--- /dev/null
+++ b/externs/GCL/externs/goog/graphics/textelement.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 thin wrapper around the DOM element for text elements.
+ * @author arv@google.com (Erik Arvidsson)
+ */
+
+
+goog.provide('goog.graphics.TextElement');
+
+goog.require('goog.graphics.StrokeAndFillElement');
+
+
+
+/**
+ * Interface for a graphics text 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.TextElement = function(element, graphics, stroke, fill) {
+ goog.graphics.StrokeAndFillElement.call(this, element, graphics, stroke,
+ fill);
+};
+goog.inherits(goog.graphics.TextElement, goog.graphics.StrokeAndFillElement);
+
+
+/**
+ * Update the displayed text of the element.
+ * @param {string} text The text to draw.
+ */
+goog.graphics.TextElement.prototype.setText = goog.abstractMethod;