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 [email protected] (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 [email protected] (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 [email protected] (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 [email protected] (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 [email protected] (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 [email protected] (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 [email protected] (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 [email protected] (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 [email protected] (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 [email protected] (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 [email protected] (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 [email protected] (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 [email protected] (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 [email protected] (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 [email protected] (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; +};
