/** * <a href="http://www.w3.org/TR/NOTE-VML">VML</a> implementation of the <a href="Shape.html">`Shape`</a> class. * `VMLShape` is not intended to be used directly. Instead, use the <a href="Shape.html">`Shape`</a> class. * If the browser lacks <a href="http://www.w3.org/TR/SVG/">SVG</a> and <a href="http://www.w3.org/TR/html5/the-canvas-element.html">Canvas</a> * capabilities, the <a href="Shape.html">`Shape`</a> class will point to the `VMLShape` class. * * @module graphics * @class VMLShape * @constructor * @param {Object} cfg (optional) Attribute configs */ VMLShape = function() { this._transforms = []; this.matrix = new Y.Matrix(); this._normalizedMatrix = new Y.Matrix(); VMLShape.superclass.constructor.apply(this, arguments); }; VMLShape.NAME = "shape"; Y.extend(VMLShape, Y.GraphicBase, Y.mix({ /** * Indicates the type of shape * * @property _type * @type String * @private */ _type: "shape", /** * Init method, invoked during construction. * Calls `initializer` method. * * @method init * @protected */ init: function() { this.initializer.apply(this, arguments); }, /** * Initializes the shape * * @private * @method _initialize */ initializer: function(cfg) { var host = this, graphic = cfg.graphic, data = this.get("data"); host.createNode(); if(graphic) { this._setGraphic(graphic); } if(data) { host._parsePathData(data); } this._updateHandler(); }, /** * Set the Graphic instance for the shape. * * @method _setGraphic * @param {Graphic | Node | HTMLElement | String} render This param is used to determine the graphic instance. If it is a * `Graphic` instance, it will be assigned to the `graphic` attribute. Otherwise, a new Graphic instance will be created * and rendered into the dom element that the render represents. * @private */ _setGraphic: function(render) { var graphic; if(render instanceof Y.VMLGraphic) { this._graphic = render; } else { graphic = new Y.VMLGraphic({ render: render }); graphic._appendShape(this); this._graphic = graphic; this._appendStrokeAndFill(); } }, /** * Appends fill and stroke nodes to the shape. * * @method _appendStrokeAndFill * @private */ _appendStrokeAndFill: function() { if(this._strokeNode) { this.node.appendChild(this._strokeNode); } if(this._fillNode) { this.node.appendChild(this._fillNode); } }, /** * Creates the dom node for the shape. * * @method createNode * @return HTMLElement * @private */ createNode: function() { var node, concat = this._camelCaseConcat, x = this.get("x"), y = this.get("y"), w = this.get("width"), h = this.get("height"), id, type, name = this.name, nodestring, visibility = this.get("visible") ? "visible" : "hidden", strokestring, classString, stroke, endcap, opacity, joinstyle, miterlimit, dashstyle, fill, fillstring; id = this.get("id"); type = this._type === "path" ? "shape" : this._type; classString = _getClassName(SHAPE) + " " + _getClassName(concat(IMPLEMENTATION, SHAPE)) + " " + _getClassName(name) + " " + _getClassName(concat(IMPLEMENTATION, name)) + " " + IMPLEMENTATION + type; stroke = this._getStrokeProps(); fill = this._getFillProps(); nodestring = '<' + type + ' xmlns="urn:schemas-microsft.com:vml" id="' + id + '" class="' + classString + '" style="behavior:url(#default#VML);display:inline-block;position:absolute;left:' + x + 'px;top:' + y + 'px;width:' + w + 'px;height:' + h + 'px;visibility:' + visibility + '"'; if(stroke && stroke.weight && stroke.weight > 0) { endcap = stroke.endcap; opacity = parseFloat(stroke.opacity); joinstyle = stroke.joinstyle; miterlimit = stroke.miterlimit; dashstyle = stroke.dashstyle; nodestring += ' stroked="t" strokecolor="' + stroke.color + '" strokeWeight="' + stroke.weight + 'px"'; strokestring = '<stroke class="vmlstroke"' + ' xmlns="urn:schemas-microsft.com:vml"' + ' on="t"' + ' style="behavior:url(#default#VML);display:inline-block;"' + ' opacity="' + opacity + '"'; if(endcap) { strokestring += ' endcap="' + endcap + '"'; } if(joinstyle) { strokestring += ' joinstyle="' + joinstyle + '"'; } if(miterlimit) { strokestring += ' miterlimit="' + miterlimit + '"'; } if(dashstyle) { strokestring += ' dashstyle="' + dashstyle + '"'; } strokestring += '></stroke>'; this._strokeNode = DOCUMENT.createElement(strokestring); nodestring += ' stroked="t"'; } else { nodestring += ' stroked="f"'; } if(fill) { if(fill.node) { fillstring = fill.node; this._fillNode = DOCUMENT.createElement(fillstring); } if(fill.color) { nodestring += ' fillcolor="' + fill.color + '"'; } nodestring += ' filled="' + fill.filled + '"'; } nodestring += '>'; nodestring += '</' + type + '>'; node = DOCUMENT.createElement(nodestring); this.node = node; this._strokeFlag = false; this._fillFlag = false; }, /** * Add a class name to each node. * * @method addClass * @param {String} className the class name to add to the node's class attribute */ addClass: function(className) { var node = this.node; Y_DOM.addClass(node, className); }, /** * Removes a class name from each node. * * @method removeClass * @param {String} className the class name to remove from the node's class attribute */ removeClass: function(className) { var node = this.node; Y_DOM.removeClass(node, className); }, /** * Gets the current position of the node in page coordinates. * * @method getXY * @return Array The XY position of the shape. */ getXY: function() { var graphic = this._graphic, parentXY = graphic.getXY(), x = this.get("x"), y = this.get("y"); return [parentXY[0] + x, parentXY[1] + y]; }, /** * Set the position of the shape in page coordinates, regardless of how the node is positioned. * * @method setXY * @param {Array} Contains x & y values for new position (coordinates are page-based) * */ setXY: function(xy) { var graphic = this._graphic, parentXY = graphic.getXY(); this.set("x", xy[0] - parentXY[0]); this.set("y", xy[1] - parentXY[1]); }, /** * Determines whether the node is an ancestor of another HTML element in the DOM hierarchy. * * @method contains * @param {VMLShape | HTMLElement} needle The possible node or descendent * @return Boolean Whether or not this shape is the needle or its ancestor. */ contains: function(needle) { var node = needle instanceof Y.Node ? needle._node : needle; return node === this.node; }, /** * Compares nodes to determine if they match. * Node instances can be compared to each other and/or HTMLElements. * @method compareTo * @param {HTMLElement | Node} refNode The reference node to compare to the node. * @return {Boolean} True if the nodes match, false if they do not. */ compareTo: function(refNode) { var node = this.node; return node === refNode; }, /** * Test if the supplied node matches the supplied selector. * * @method test * @param {String} selector The CSS selector to test against. * @return Boolean Wheter or not the shape matches the selector. */ test: function(selector) { return Y_SELECTOR.test(this.node, selector); }, /** * Calculates and returns properties for setting an initial stroke. * * @method _getStrokeProps * @return Object * * @private */ _getStrokeProps: function() { var props, stroke = this.get("stroke"), strokeOpacity, dashstyle, dash = "", val, i = 0, len, linecap, linejoin; if(stroke && stroke.weight && stroke.weight > 0) { props = {}; linecap = stroke.linecap || "flat"; linejoin = stroke.linejoin || "round"; if(linecap !== "round" && linecap !== "square") { linecap = "flat"; } strokeOpacity = parseFloat(stroke.opacity); dashstyle = stroke.dashstyle || "none"; stroke.color = stroke.color || "#000000"; stroke.weight = stroke.weight || 1; stroke.opacity = IS_NUM(strokeOpacity) ? strokeOpacity : 1; props.stroked = true; props.color = stroke.color; props.weight = stroke.weight; props.endcap = linecap; props.opacity = stroke.opacity; if(IS_ARRAY(dashstyle)) { dash = []; len = dashstyle.length; for(i = 0; i < len; ++i) { val = dashstyle[i]; dash[i] = val / stroke.weight; } } if(linejoin === "round" || linejoin === "bevel") { props.joinstyle = linejoin; } else { linejoin = parseInt(linejoin, 10); if(IS_NUM(linejoin)) { props.miterlimit = Math.max(linejoin, 1); props.joinstyle = "miter"; } } props.dashstyle = dash; } return props; }, /** * Adds a stroke to the shape node. * * @method _strokeChangeHandler * @private */ _strokeChangeHandler: function() { if(!this._strokeFlag) { return; } var node = this.node, stroke = this.get("stroke"), strokeOpacity, dashstyle, dash = "", val, i = 0, len, linecap, linejoin; if(stroke && stroke.weight && stroke.weight > 0) { linecap = stroke.linecap || "flat"; linejoin = stroke.linejoin || "round"; if(linecap !== "round" && linecap !== "square") { linecap = "flat"; } strokeOpacity = parseFloat(stroke.opacity); dashstyle = stroke.dashstyle || "none"; stroke.color = stroke.color || "#000000"; stroke.weight = stroke.weight || 1; stroke.opacity = IS_NUM(strokeOpacity) ? strokeOpacity : 1; node.stroked = true; node.strokeColor = stroke.color; node.strokeWeight = stroke.weight + "px"; if(!this._strokeNode) { this._strokeNode = this._createGraphicNode("stroke"); node.appendChild(this._strokeNode); } this._strokeNode.endcap = linecap; this._strokeNode.opacity = stroke.opacity; if(IS_ARRAY(dashstyle)) { dash = []; len = dashstyle.length; for(i = 0; i < len; ++i) { val = dashstyle[i]; dash[i] = val / stroke.weight; } } if(linejoin === "round" || linejoin === "bevel") { this._strokeNode.joinstyle = linejoin; } else { linejoin = parseInt(linejoin, 10); if(IS_NUM(linejoin)) { this._strokeNode.miterlimit = Math.max(linejoin, 1); this._strokeNode.joinstyle = "miter"; } } this._strokeNode.dashstyle = dash; this._strokeNode.on = true; } else { if(this._strokeNode) { this._strokeNode.on = false; } node.stroked = false; } this._strokeFlag = false; }, /** * Calculates and returns properties for setting an initial fill. * * @method _getFillProps * @return Object * * @private */ _getFillProps: function() { var fill = this.get("fill"), fillOpacity, props, gradient, i, fillstring, filled = false; if(fill) { props = {}; if(fill.type === "radial" || fill.type === "linear") { fillOpacity = parseFloat(fill.opacity); fillOpacity = IS_NUM(fillOpacity) ? fillOpacity : 1; filled = true; gradient = this._getGradientFill(fill); fillstring = '<fill xmlns="urn:schemas-microsft.com:vml"' + ' class="vmlfill" style="behavior:url(#default#VML);display:inline-block;"' + ' opacity="' + fillOpacity + '"'; for(i in gradient) { if(gradient.hasOwnProperty(i)) { fillstring += ' ' + i + '="' + gradient[i] + '"'; } } fillstring += ' />'; props.node = fillstring; } else if(fill.color) { fillOpacity = parseFloat(fill.opacity); filled = true; props.color = fill.color; if(IS_NUM(fillOpacity)) { fillOpacity = Math.max(Math.min(fillOpacity, 1), 0); props.opacity = fillOpacity; if(fillOpacity < 1) { props.node = '<fill xmlns="urn:schemas-microsft.com:vml"' + ' class="vmlfill" style="behavior:url(#default#VML);display:inline-block;"' + ' type="solid" opacity="' + fillOpacity + '"/>'; } } } props.filled = filled; } return props; }, /** * Adds a fill to the shape node. * * @method _fillChangeHandler * @private */ _fillChangeHandler: function() { if(!this._fillFlag) { return; } var node = this.node, fill = this.get("fill"), fillOpacity, fillstring, filled = false, i, gradient; if(fill) { if(fill.type === "radial" || fill.type === "linear") { filled = true; gradient = this._getGradientFill(fill); if(this._fillNode) { for(i in gradient) { if(gradient.hasOwnProperty(i)) { if(i === "colors") { this._fillNode.colors.value = gradient[i]; } else { this._fillNode[i] = gradient[i]; } } } } else { fillstring = '<fill xmlns="urn:schemas-microsft.com:vml"' + ' class="vmlfill"' + ' style="behavior:url(#default#VML);display:inline-block;"'; for(i in gradient) { if(gradient.hasOwnProperty(i)) { fillstring += ' ' + i + '="' + gradient[i] + '"'; } } fillstring += ' />'; this._fillNode = DOCUMENT.createElement(fillstring); node.appendChild(this._fillNode); } } else if(fill.color) { node.fillcolor = fill.color; fillOpacity = parseFloat(fill.opacity); filled = true; if(IS_NUM(fillOpacity) && fillOpacity < 1) { fill.opacity = fillOpacity; if(this._fillNode) { if(this._fillNode.getAttribute("type") !== "solid") { this._fillNode.type = "solid"; } this._fillNode.opacity = fillOpacity; } else { fillstring = '<fill xmlns="urn:schemas-microsft.com:vml"' + ' class="vmlfill"' + ' style="behavior:url(#default#VML);display:inline-block;"' + ' type="solid"' + ' opacity="' + fillOpacity + '"' + '/>'; this._fillNode = DOCUMENT.createElement(fillstring); node.appendChild(this._fillNode); } } else if(this._fillNode) { this._fillNode.opacity = 1; this._fillNode.type = "solid"; } } } node.filled = filled; this._fillFlag = false; }, //not used. remove next release. _updateFillNode: function(node) { if(!this._fillNode) { this._fillNode = this._createGraphicNode("fill"); node.appendChild(this._fillNode); } }, /** * Calculates and returns an object containing gradient properties for a fill node. * * @method _getGradientFill * @param {Object} fill Object containing fill properties. * @return Object * @private */ _getGradientFill: function(fill) { var gradientProps = {}, gradientBoxWidth, gradientBoxHeight, type = fill.type, w = this.get("width"), h = this.get("height"), isNumber = IS_NUM, stop, stops = fill.stops, len = stops.length, opacity, color, i, oi, colorstring = "", cx = fill.cx, cy = fill.cy, fx = fill.fx, fy = fill.fy, r = fill.r, pct, rotation = fill.rotation || 0; if(type === "linear") { if(rotation <= 270) { rotation = Math.abs(rotation - 270); } else if(rotation < 360) { rotation = 270 + (360 - rotation); } else { rotation = 270; } gradientProps.type = "gradient";//"gradientunscaled"; gradientProps.angle = rotation; } else if(type === "radial") { gradientBoxWidth = w * (r * 2); gradientBoxHeight = h * (r * 2); fx = r * 2 * (fx - 0.5); fy = r * 2 * (fy - 0.5); fx += cx; fy += cy; gradientProps.focussize = (gradientBoxWidth/w)/10 + "% " + (gradientBoxHeight/h)/10 + "%"; gradientProps.alignshape = false; gradientProps.type = "gradientradial"; gradientProps.focus = "100%"; gradientProps.focusposition = Math.round(fx * 100) + "% " + Math.round(fy * 100) + "%"; } for(i = 0;i < len; ++i) { stop = stops[i]; color = stop.color; opacity = stop.opacity; opacity = isNumber(opacity) ? opacity : 1; pct = stop.offset || i/(len-1); pct *= (r * 2); pct = Math.round(100 * pct) + "%"; oi = i > 0 ? i + 1 : ""; gradientProps["opacity" + oi] = opacity + ""; colorstring += ", " + pct + " " + color; } if(parseFloat(pct) < 100) { colorstring += ", 100% " + color; } gradientProps.colors = colorstring.substr(2); return gradientProps; }, /** * Adds a transform to the shape. * * @method _addTransform * @param {String} type The transform being applied. * @param {Array} args The arguments for the transform. * @private */ _addTransform: function(type, args) { args = Y.Array(args); this._transform = Y_LANG.trim(this._transform + " " + type + "(" + args.join(", ") + ")"); args.unshift(type); this._transforms.push(args); if(this.initialized) { this._updateTransform(); } }, /** * Applies all transforms. * * @method _updateTransform * @private */ _updateTransform: function() { var node = this.node, key, transform, transformOrigin, x = this.get("x"), y = this.get("y"), tx, ty, matrix = this.matrix, normalizedMatrix = this._normalizedMatrix, isPathShape = this instanceof Y.VMLPath, i, len = this._transforms.length; if(this._transforms && this._transforms.length > 0) { transformOrigin = this.get("transformOrigin"); if(isPathShape) { normalizedMatrix.translate(this._left, this._top); } //vml skew matrix transformOrigin ranges from -0.5 to 0.5. //subtract 0.5 from values tx = transformOrigin[0] - 0.5; ty = transformOrigin[1] - 0.5; //ensure the values are within the appropriate range to avoid errors tx = Math.max(-0.5, Math.min(0.5, tx)); ty = Math.max(-0.5, Math.min(0.5, ty)); for(i = 0; i < len; ++i) { key = this._transforms[i].shift(); if(key) { normalizedMatrix[key].apply(normalizedMatrix, this._transforms[i]); matrix[key].apply(matrix, this._transforms[i]); } } if(isPathShape) { normalizedMatrix.translate(-this._left, -this._top); } transform = normalizedMatrix.a + "," + normalizedMatrix.c + "," + normalizedMatrix.b + "," + normalizedMatrix.d + "," + 0 + "," + 0; } this._graphic.addToRedrawQueue(this); if(transform) { if(!this._skew) { this._skew = DOCUMENT.createElement( '<skew class="vmlskew"' + ' xmlns="urn:schemas-microsft.com:vml"' + ' on="false"' + ' style="behavior:url(#default#VML);display:inline-block;"' + '/>' ); this.node.appendChild(this._skew); } this._skew.matrix = transform; this._skew.on = true; //this._skew.offset = this._getSkewOffsetValue(normalizedMatrix.dx) + "px, " + this._getSkewOffsetValue(normalizedMatrix.dy) + "px"; this._skew.origin = tx + ", " + ty; } if(this._type !== "path") { this._transforms = []; } //add the translate to the x and y coordinates node.style.left = (x + this._getSkewOffsetValue(normalizedMatrix.dx)) + "px"; node.style.top = (y + this._getSkewOffsetValue(normalizedMatrix.dy)) + "px"; }, /** * Normalizes the skew offset values between -32767 and 32767. * * @method _getSkewOffsetValue * @param {Number} val The value to normalize * @return Number * @private */ _getSkewOffsetValue: function(val) { var sign = Y.MatrixUtil.sign(val), absVal = Math.abs(val); val = Math.min(absVal, 32767) * sign; return val; }, /** * Storage for translateX * * @property _translateX * @type Number * @private */ _translateX: 0, /** * Storage for translateY * * @property _translateY * @type Number * @private */ _translateY: 0, /** * Storage for the transform attribute. * * @property _transform * @type String * @private */ _transform: "", /** * Specifies a 2d translation. * * @method translate * @param {Number} x The value to translate on the x-axis. * @param {Number} y The value to translate on the y-axis. */ translate: function(x, y) { this._translateX += x; this._translateY += y; this._addTransform("translate", arguments); }, /** * Translates the shape along the x-axis. When translating x and y coordinates, * use the `translate` method. * * @method translateX * @param {Number} x The value to translate. */ translateX: function(x) { this._translateX += x; this._addTransform("translateX", arguments); }, /** * Performs a translate on the y-coordinate. When translating x and y coordinates, * use the `translate` method. * * @method translateY * @param {Number} y The value to translate. */ translateY: function(y) { this._translateY += y; this._addTransform("translateY", arguments); }, /** * Skews the shape around the x-axis and y-axis. * * @method skew * @param {Number} x The value to skew on the x-axis. * @param {Number} y The value to skew on the y-axis. */ skew: function() { this._addTransform("skew", arguments); }, /** * Skews the shape around the x-axis. * * @method skewX * @param {Number} x x-coordinate */ skewX: function() { this._addTransform("skewX", arguments); }, /** * Skews the shape around the y-axis. * * @method skewY * @param {Number} y y-coordinate */ skewY: function() { this._addTransform("skewY", arguments); }, /** * Rotates the shape clockwise around it transformOrigin. * * @method rotate * @param {Number} deg The degree of the rotation. */ rotate: function() { this._addTransform("rotate", arguments); }, /** * Specifies a 2d scaling operation. * * @method scale * @param {Number} val */ scale: function() { this._addTransform("scale", arguments); }, /** * Overrides default `on` method. Checks to see if its a dom interaction event. If so, * return an event attached to the `node` element. If not, return the normal functionality. * * @method on * @param {String} type event type * @param {Object} callback function * @private */ on: function(type, fn) { if(Y.Node.DOM_EVENTS[type]) { return Y.on(type, fn, "#" + this.get("id")); } return Y.on.apply(this, arguments); }, /** * Draws the shape. * * @method _draw * @private */ _draw: function() { }, /** * Updates `Shape` based on attribute changes. * * @method _updateHandler * @private */ _updateHandler: function() { var host = this, node = host.node; host._fillChangeHandler(); host._strokeChangeHandler(); node.style.width = this.get("width") + "px"; node.style.height = this.get("height") + "px"; this._draw(); host._updateTransform(); }, /** * Creates a graphic node * * @method _createGraphicNode * @param {String} type node type to create * @return HTMLElement * @private */ _createGraphicNode: function(type) { type = type || this._type; return DOCUMENT.createElement( '<' + type + ' xmlns="urn:schemas-microsft.com:vml"' + ' style="behavior:url(#default#VML);display:inline-block;"' + ' class="vml' + type + '"' + '/>' ); }, /** * Value function for fill attribute * * @private * @method _getDefaultFill * @return Object */ _getDefaultFill: function() { return { type: "solid", opacity: 1, cx: 0.5, cy: 0.5, fx: 0.5, fy: 0.5, r: 0.5 }; }, /** * Value function for stroke attribute * * @private * @method _getDefaultStroke * @return Object */ _getDefaultStroke: function() { return { weight: 1, dashstyle: "none", color: "#000", opacity: 1.0 }; }, /** * Sets the value of an attribute. * * @method set * @param {String|Object} name The name of the attribute. Alternatively, an object of key value pairs can * be passed in to set multiple attributes at once. * @param {Any} value The value to set the attribute to. This value is ignored if an object is received as * the name param. */ set: function() { var host = this; AttributeLite.prototype.set.apply(host, arguments); if(host.initialized) { host._updateHandler(); } }, /** * Returns the bounds for a shape. * * Calculates the a new bounding box from the original corner coordinates (base on size and position) and the transform matrix. * The calculated bounding box is used by the graphic instance to calculate its viewBox. * * @method getBounds * @return Object */ getBounds: function() { var isPathShape = this instanceof Y.VMLPath, w = this.get("width"), h = this.get("height"), x = this.get("x"), y = this.get("y"); if(isPathShape) { x = x + this._left; y = y + this._top; w = this._right - this._left; h = this._bottom - this._top; } return this._getContentRect(w, h, x, y); }, /** * Calculates the bounding box for the shape. * * @method _getContentRect * @param {Number} w width of the shape * @param {Number} h height of the shape * @param {Number} x x-coordinate of the shape * @param {Number} y y-coordinate of the shape * @private */ _getContentRect: function(w, h, x, y) { var transformOrigin = this.get("transformOrigin"), transformX = transformOrigin[0] * w, transformY = transformOrigin[1] * h, transforms = this.matrix.getTransformArray(this.get("transform")), matrix = new Y.Matrix(), i, len = transforms.length, transform, key, contentRect, isPathShape = this instanceof Y.VMLPath; if(isPathShape) { matrix.translate(this._left, this._top); } transformX = !isNaN(transformX) ? transformX : 0; transformY = !isNaN(transformY) ? transformY : 0; matrix.translate(transformX, transformY); for(i = 0; i < len; i = i + 1) { transform = transforms[i]; key = transform.shift(); if(key) { matrix[key].apply(matrix, transform); } } matrix.translate(-transformX, -transformY); if(isPathShape) { matrix.translate(-this._left, -this._top); } contentRect = matrix.getContentRect(w, h, x, y); return contentRect; }, /** * Places the shape above all other shapes. * * @method toFront */ toFront: function() { var graphic = this.get("graphic"); if(graphic) { graphic._toFront(this); } }, /** * Places the shape underneath all other shapes. * * @method toFront */ toBack: function() { var graphic = this.get("graphic"); if(graphic) { graphic._toBack(this); } }, /** * Parses path data string and call mapped methods. * * @method _parsePathData * @param {String} val The path data * @private */ _parsePathData: function(val) { var method, methodSymbol, args, commandArray = Y.Lang.trim(val.match(SPLITPATHPATTERN)), i, len, str, symbolToMethod = this._pathSymbolToMethod; if(commandArray) { this.clear(); len = commandArray.length || 0; for(i = 0; i < len; i = i + 1) { str = commandArray[i]; methodSymbol = str.substr(0, 1); args = str.substr(1).match(SPLITARGSPATTERN); method = symbolToMethod[methodSymbol]; if(method) { if(args) { this[method].apply(this, args); } else { this[method].apply(this); } } } this.end(); } }, /** * Destroys shape * * @method destroy */ destroy: function() { var graphic = this.get("graphic"); if(graphic) { graphic.removeShape(this); } else { this._destroy(); } }, /** * Implementation for shape destruction * * @method destroy * @protected */ _destroy: function() { if(this.node) { if(this._fillNode) { this.node.removeChild(this._fillNode); this._fillNode = null; } if(this._strokeNode) { this.node.removeChild(this._strokeNode); this._strokeNode = null; } Y.Event.purgeElement(this.node, true); if(this.node.parentNode) { this.node.parentNode.removeChild(this.node); } this.node = null; } } }, Y.VMLDrawing.prototype)); VMLShape.ATTRS = { /** * An array of x, y values which indicates the transformOrigin in which to rotate the shape. Valid values range between 0 and 1 representing a * fraction of the shape's corresponding bounding box dimension. The default value is [0.5, 0.5]. * * @config transformOrigin * @type Array */ transformOrigin: { valueFn: function() { return [0.5, 0.5]; } }, /** * <p>A string containing, in order, transform operations applied to the shape instance. The `transform` string can contain the following values: * * <dl> * <dt>rotate</dt><dd>Rotates the shape clockwise around it transformOrigin.</dd> * <dt>translate</dt><dd>Specifies a 2d translation.</dd> * <dt>skew</dt><dd>Skews the shape around the x-axis and y-axis.</dd> * <dt>scale</dt><dd>Specifies a 2d scaling operation.</dd> * <dt>translateX</dt><dd>Translates the shape along the x-axis.</dd> * <dt>translateY</dt><dd>Translates the shape along the y-axis.</dd> * <dt>skewX</dt><dd>Skews the shape around the x-axis.</dd> * <dt>skewY</dt><dd>Skews the shape around the y-axis.</dd> * <dt>matrix</dt><dd>Specifies a 2D transformation matrix comprised of the specified six values.</dd> * </dl> * </p> * <p>Applying transforms through the transform attribute will reset the transform matrix and apply a new transform. The shape class also contains * corresponding methods for each transform that will apply the transform to the current matrix. The below code illustrates how you might use the * `transform` attribute to instantiate a recangle with a rotation of 45 degrees.</p> var myRect = new Y.Rect({ type:"rect", width: 50, height: 40, transform: "rotate(45)" }; * <p>The code below would apply `translate` and `rotate` to an existing shape.</p> myRect.set("transform", "translate(40, 50) rotate(45)"); * @config transform * @type String */ transform: { setter: function(val) { var i, len, transform; this.matrix.init(); this._normalizedMatrix.init(); this._transforms = this.matrix.getTransformArray(val); len = this._transforms.length; for(i = 0;i < len; ++i) { transform = this._transforms[i]; } this._transform = val; return val; }, getter: function() { return this._transform; } }, /** * Indicates the x position of shape. * * @config x * @type Number */ x: { value: 0 }, /** * Indicates the y position of shape. * * @config y * @type Number */ y: { value: 0 }, /** * Unique id for class instance. * * @config id * @type String */ id: { valueFn: function() { return Y.guid(); }, setter: function(val) { var node = this.node; if(node) { node.setAttribute("id", val); } return val; } }, /** * * @config width */ width: { value: 0 }, /** * * @config height */ height: { value: 0 }, /** * Indicates whether the shape is visible. * * @config visible * @type Boolean */ visible: { value: true, setter: function(val){ var node = this.node, visibility = val ? "visible" : "hidden"; if(node) { node.style.visibility = visibility; } return val; } }, /** * Contains information about the fill of the shape. * <dl> * <dt>color</dt><dd>The color of the fill.</dd> * <dt>opacity</dt><dd>Number between 0 and 1 that indicates the opacity of the fill. The default value is 1.</dd> * <dt>type</dt><dd>Type of fill. * <dl> * <dt>solid</dt><dd>Solid single color fill. (default)</dd> * <dt>linear</dt><dd>Linear gradient fill.</dd> * <dt>radial</dt><dd>Radial gradient fill.</dd> * </dl> * </dd> * </dl> * <p>If a `linear` or `radial` is specified as the fill type. The following additional property is used: * <dl> * <dt>stops</dt><dd>An array of objects containing the following properties: * <dl> * <dt>color</dt><dd>The color of the stop.</dd> * <dt>opacity</dt><dd>Number between 0 and 1 that indicates the opacity of the stop. The default value is 1. * Note: No effect for IE 6 - 8</dd> * <dt>offset</dt><dd>Number between 0 and 1 indicating where the color stop is positioned.</dd> * </dl> * </dd> * <p>Linear gradients also have the following property:</p> * <dt>rotation</dt><dd>Linear gradients flow left to right by default. The rotation property allows you to change the * flow by rotation. (e.g. A rotation of 180 would make the gradient pain from right to left.)</dd> * <p>Radial gradients have the following additional properties:</p> * <dt>r</dt><dd>Radius of the gradient circle.</dd> * <dt>fx</dt><dd>Focal point x-coordinate of the gradient.</dd> * <dt>fy</dt><dd>Focal point y-coordinate of the gradient.</dd> * </dl> * <p>The corresponding `SVGShape` class implements the following additional properties.</p> * <dl> * <dt>cx</dt><dd> * <p>The x-coordinate of the center of the gradient circle. Determines where the color stop begins. The default value 0.5.</p> * <p><strong>Note: </strong>Currently, this property is not implemented for corresponding `CanvasShape` and * `VMLShape` classes which are used on Android or IE 6 - 8.</p> * </dd> * <dt>cy</dt><dd> * <p>The y-coordinate of the center of the gradient circle. Determines where the color stop begins. The default value 0.5.</p> * <p><strong>Note: </strong>Currently, this property is not implemented for corresponding `CanvasShape` and `VMLShape` * classes which are used on Android or IE 6 - 8.</p> * </dd> * </dl> * <p>These properties are not currently implemented in `CanvasShape` or `VMLShape`.</p> * * @config fill * @type Object */ fill: { valueFn: "_getDefaultFill", setter: function(val) { var i, fill, tmpl = this.get("fill") || this._getDefaultFill(); if(val) { //ensure, fill type is solid if color is explicitly passed. if(val.hasOwnProperty("color")) { val.type = "solid"; } for(i in val) { if(val.hasOwnProperty(i)) { tmpl[i] = val[i]; } } } fill = tmpl; if(fill && fill.color) { if(fill.color === undefined || fill.color === "none") { fill.color = null; } else { if(fill.color.toLowerCase().indexOf("rgba") > -1) { fill.opacity = Y.Color._getAlpha(fill.color); fill.color = Y.Color.toHex(fill.color); } } } this._fillFlag = true; return fill; } }, /** * Contains information about the stroke of the shape. * <dl> * <dt>color</dt><dd>The color of the stroke.</dd> * <dt>weight</dt><dd>Number that indicates the width of the stroke.</dd> * <dt>opacity</dt><dd>Number between 0 and 1 that indicates the opacity of the stroke. The default value is 1.</dd> * <dt>dashstyle</dt>Indicates whether to draw a dashed stroke. When set to "none", a solid stroke is drawn. When set * to an array, the first index indicates the length of the dash. The second index indicates the length of gap. * <dt>linecap</dt><dd>Specifies the linecap for the stroke. The following values can be specified: * <dl> * <dt>butt (default)</dt><dd>Specifies a butt linecap.</dd> * <dt>square</dt><dd>Specifies a sqare linecap.</dd> * <dt>round</dt><dd>Specifies a round linecap.</dd> * </dl> * </dd> * <dt>linejoin</dt><dd>Specifies a linejoin for the stroke. The following values can be specified: * <dl> * <dt>round (default)</dt><dd>Specifies that the linejoin will be round.</dd> * <dt>bevel</dt><dd>Specifies a bevel for the linejoin.</dd> * <dt>miter limit</dt><dd>An integer specifying the miter limit of a miter linejoin. If you want to specify a linejoin * of miter, you simply specify the limit as opposed to having separate miter and miter limit values.</dd> * </dl> * </dd> * </dl> * * @config stroke * @type Object */ stroke: { valueFn: "_getDefaultStroke", setter: function(val) { var i, stroke, wt, tmpl = this.get("stroke") || this._getDefaultStroke(); if(val) { if(val.hasOwnProperty("weight")) { wt = parseInt(val.weight, 10); if(!isNaN(wt)) { val.weight = wt; } } for(i in val) { if(val.hasOwnProperty(i)) { tmpl[i] = val[i]; } } } if(tmpl.color && tmpl.color.toLowerCase().indexOf("rgba") > -1) { tmpl.opacity = Y.Color._getAlpha(tmpl.color); tmpl.color = Y.Color.toHex(tmpl.color); } stroke = tmpl; this._strokeFlag = true; return stroke; } }, //Not used. Remove in future. autoSize: { value: false }, // Only implemented in SVG // Determines whether the instance will receive mouse events. // // @config pointerEvents // @type string // pointerEvents: { value: "visiblePainted" }, /** * Dom node for the shape. * * @config node * @type HTMLElement * @readOnly */ node: { readOnly: true, getter: function() { return this.node; } }, /** * Represents an SVG Path string. This will be parsed and added to shape's API to represent the SVG data across all * implementations. Note that when using VML or SVG implementations, part of this content will be added to the DOM using * respective VML/SVG attributes. If your content comes from an untrusted source, you will need to ensure that no * malicious code is included in that content. * * @config data * @type String */ data: { setter: function(val) { if(this.get("node")) { this._parsePathData(val); } return val; } }, /** * Reference to the container Graphic. * * @config graphic * @type Graphic */ graphic: { readOnly: true, getter: function() { return this._graphic; } } }; Y.VMLShape = VMLShape;