You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3760 lines
98 KiB
3760 lines
98 KiB
/*
|
|
YUI 3.17.2 (build 9c3c78e)
|
|
Copyright 2014 Yahoo! Inc. All rights reserved.
|
|
Licensed under the BSD License.
|
|
http://yuilibrary.com/license/
|
|
*/
|
|
|
|
YUI.add('graphics-vml', function (Y, NAME) {
|
|
|
|
var IMPLEMENTATION = "vml",
|
|
SHAPE = "shape",
|
|
SPLITPATHPATTERN = /[a-z][^a-z]*/ig,
|
|
SPLITARGSPATTERN = /[\-]?[0-9]*[0-9|\.][0-9]*/g,
|
|
Y_LANG = Y.Lang,
|
|
IS_NUM = Y_LANG.isNumber,
|
|
IS_ARRAY = Y_LANG.isArray,
|
|
Y_DOM = Y.DOM,
|
|
Y_SELECTOR = Y.Selector,
|
|
DOCUMENT = Y.config.doc,
|
|
AttributeLite = Y.AttributeLite,
|
|
VMLShape,
|
|
VMLCircle,
|
|
VMLPath,
|
|
VMLRect,
|
|
VMLEllipse,
|
|
VMLGraphic,
|
|
VMLPieSlice,
|
|
_getClassName = Y.ClassNameManager.getClassName;
|
|
|
|
function VMLDrawing() {}
|
|
|
|
/**
|
|
* <a href="http://www.w3.org/TR/NOTE-VML">VML</a> implementation of the <a href="Drawing.html">`Drawing`</a> class.
|
|
* `VMLDrawing` is not intended to be used directly. Instead, use the <a href="Drawing.html">`Drawing`</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="Drawing.html">`Drawing`</a> class will point to the `VMLDrawing` class.
|
|
*
|
|
* @module graphics
|
|
* @class VMLDrawing
|
|
* @constructor
|
|
*/
|
|
VMLDrawing.prototype = {
|
|
/**
|
|
* Maps path to methods
|
|
*
|
|
* @property _pathSymbolToMethod
|
|
* @type Object
|
|
* @private
|
|
*/
|
|
_pathSymbolToMethod: {
|
|
M: "moveTo",
|
|
m: "relativeMoveTo",
|
|
L: "lineTo",
|
|
l: "relativeLineTo",
|
|
C: "curveTo",
|
|
c: "relativeCurveTo",
|
|
Q: "quadraticCurveTo",
|
|
q: "relativeQuadraticCurveTo",
|
|
z: "closePath",
|
|
Z: "closePath"
|
|
},
|
|
|
|
/**
|
|
* Value for rounding up to coordsize
|
|
*
|
|
* @property _coordSpaceMultiplier
|
|
* @type Number
|
|
* @private
|
|
*/
|
|
_coordSpaceMultiplier: 100,
|
|
|
|
/**
|
|
* Rounds dimensions and position values based on the coordinate space.
|
|
*
|
|
* @method _round
|
|
* @param {Number} The value for rounding
|
|
* @return Number
|
|
* @private
|
|
*/
|
|
_round:function(val)
|
|
{
|
|
return Math.round(val * this._coordSpaceMultiplier);
|
|
},
|
|
|
|
/**
|
|
* Concatanates the path.
|
|
*
|
|
* @method _addToPath
|
|
* @param {String} val The value to add to the path string.
|
|
* @private
|
|
*/
|
|
_addToPath: function(val)
|
|
{
|
|
this._path = this._path || "";
|
|
if(this._movePath)
|
|
{
|
|
this._path += this._movePath;
|
|
this._movePath = null;
|
|
}
|
|
this._path += val;
|
|
},
|
|
|
|
/**
|
|
* Current x position of the drawing.
|
|
*
|
|
* @property _currentX
|
|
* @type Number
|
|
* @private
|
|
*/
|
|
_currentX: 0,
|
|
|
|
/**
|
|
* Current y position of the drqwing.
|
|
*
|
|
* @property _currentY
|
|
* @type Number
|
|
* @private
|
|
*/
|
|
_currentY: 0,
|
|
|
|
/**
|
|
* Draws a bezier curve.
|
|
*
|
|
* @method curveTo
|
|
* @param {Number} cp1x x-coordinate for the first control point.
|
|
* @param {Number} cp1y y-coordinate for the first control point.
|
|
* @param {Number} cp2x x-coordinate for the second control point.
|
|
* @param {Number} cp2y y-coordinate for the second control point.
|
|
* @param {Number} x x-coordinate for the end point.
|
|
* @param {Number} y y-coordinate for the end point.
|
|
* @chainable
|
|
*/
|
|
curveTo: function() {
|
|
this._curveTo.apply(this, [Y.Array(arguments), false]);
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Draws a bezier curve.
|
|
*
|
|
* @method relativeCurveTo
|
|
* @param {Number} cp1x x-coordinate for the first control point.
|
|
* @param {Number} cp1y y-coordinate for the first control point.
|
|
* @param {Number} cp2x x-coordinate for the second control point.
|
|
* @param {Number} cp2y y-coordinate for the second control point.
|
|
* @param {Number} x x-coordinate for the end point.
|
|
* @param {Number} y y-coordinate for the end point.
|
|
* @chainable
|
|
*/
|
|
relativeCurveTo: function() {
|
|
this._curveTo.apply(this, [Y.Array(arguments), true]);
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Implements curveTo methods.
|
|
*
|
|
* @method _curveTo
|
|
* @param {Array} args The arguments to be used.
|
|
* @param {Boolean} relative Indicates whether or not to use relative coordinates.
|
|
* @private
|
|
*/
|
|
_curveTo: function(args, relative) {
|
|
var w,
|
|
h,
|
|
x,
|
|
y,
|
|
cp1x,
|
|
cp1y,
|
|
cp2x,
|
|
cp2y,
|
|
pts,
|
|
right,
|
|
left,
|
|
bottom,
|
|
top,
|
|
i,
|
|
len,
|
|
path,
|
|
command = relative ? " v " : " c ",
|
|
relativeX = relative ? parseFloat(this._currentX) : 0,
|
|
relativeY = relative ? parseFloat(this._currentY) : 0;
|
|
len = args.length - 5;
|
|
path = command;
|
|
for(i = 0; i < len; i = i + 6)
|
|
{
|
|
cp1x = parseFloat(args[i]);
|
|
cp1y = parseFloat(args[i + 1]);
|
|
cp2x = parseFloat(args[i + 2]);
|
|
cp2y = parseFloat(args[i + 3]);
|
|
x = parseFloat(args[i + 4]);
|
|
y = parseFloat(args[i + 5]);
|
|
if(i > 0)
|
|
{
|
|
path = path + ", ";
|
|
}
|
|
path = path +
|
|
this._round(cp1x) +
|
|
", " +
|
|
this._round(cp1y) +
|
|
", " +
|
|
this._round(cp2x) +
|
|
", " +
|
|
this._round(cp2y) +
|
|
", " +
|
|
this._round(x) +
|
|
", " +
|
|
this._round(y);
|
|
cp1x = cp1x + relativeX;
|
|
cp1y = cp1y + relativeY;
|
|
cp2x = cp2x + relativeX;
|
|
cp2y = cp2y + relativeY;
|
|
x = x + relativeX;
|
|
y = y + relativeY;
|
|
right = Math.max(x, Math.max(cp1x, cp2x));
|
|
bottom = Math.max(y, Math.max(cp1y, cp2y));
|
|
left = Math.min(x, Math.min(cp1x, cp2x));
|
|
top = Math.min(y, Math.min(cp1y, cp2y));
|
|
w = Math.abs(right - left);
|
|
h = Math.abs(bottom - top);
|
|
pts = [[this._currentX, this._currentY] , [cp1x, cp1y], [cp2x, cp2y], [x, y]];
|
|
this._setCurveBoundingBox(pts, w, h);
|
|
this._currentX = x;
|
|
this._currentY = y;
|
|
}
|
|
this._addToPath(path);
|
|
},
|
|
|
|
/**
|
|
* Draws a quadratic bezier curve.
|
|
*
|
|
* @method quadraticCurveTo
|
|
* @param {Number} cpx x-coordinate for the control point.
|
|
* @param {Number} cpy y-coordinate for the control point.
|
|
* @param {Number} x x-coordinate for the end point.
|
|
* @param {Number} y y-coordinate for the end point.
|
|
* @chainable
|
|
*/
|
|
quadraticCurveTo: function() {
|
|
this._quadraticCurveTo.apply(this, [Y.Array(arguments), false]);
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Draws a quadratic bezier curve relative to the current position.
|
|
*
|
|
* @method relativeQuadraticCurveTo
|
|
* @param {Number} cpx x-coordinate for the control point.
|
|
* @param {Number} cpy y-coordinate for the control point.
|
|
* @param {Number} x x-coordinate for the end point.
|
|
* @param {Number} y y-coordinate for the end point.
|
|
* @chainable
|
|
*/
|
|
relativeQuadraticCurveTo: function() {
|
|
this._quadraticCurveTo.apply(this, [Y.Array(arguments), true]);
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Implements quadraticCurveTo methods.
|
|
*
|
|
* @method _quadraticCurveTo
|
|
* @param {Array} args The arguments to be used.
|
|
* @param {Boolean} relative Indicates whether or not to use relative coordinates.
|
|
* @private
|
|
*/
|
|
_quadraticCurveTo: function(args, relative) {
|
|
var cpx,
|
|
cpy,
|
|
cp1x,
|
|
cp1y,
|
|
cp2x,
|
|
cp2y,
|
|
x,
|
|
y,
|
|
currentX = this._currentX,
|
|
currentY = this._currentY,
|
|
i,
|
|
len = args.length - 3,
|
|
bezierArgs = [],
|
|
relativeX = relative ? parseFloat(this._currentX) : 0,
|
|
relativeY = relative ? parseFloat(this._currentY) : 0;
|
|
for(i = 0; i < len; i = i + 4)
|
|
{
|
|
cpx = parseFloat(args[i]) + relativeX;
|
|
cpy = parseFloat(args[i + 1]) + relativeY;
|
|
x = parseFloat(args[i + 2]) + relativeX;
|
|
y = parseFloat(args[i + 3]) + relativeY;
|
|
cp1x = currentX + 0.67*(cpx - currentX);
|
|
cp1y = currentY + 0.67*(cpy - currentY);
|
|
cp2x = cp1x + (x - currentX) * 0.34;
|
|
cp2y = cp1y + (y - currentY) * 0.34;
|
|
bezierArgs.push(cp1x);
|
|
bezierArgs.push(cp1y);
|
|
bezierArgs.push(cp2x);
|
|
bezierArgs.push(cp2y);
|
|
bezierArgs.push(x);
|
|
bezierArgs.push(y);
|
|
}
|
|
this._curveTo.apply(this, [bezierArgs, false]);
|
|
},
|
|
|
|
/**
|
|
* Draws a rectangle.
|
|
*
|
|
* @method drawRect
|
|
* @param {Number} x x-coordinate
|
|
* @param {Number} y y-coordinate
|
|
* @param {Number} w width
|
|
* @param {Number} h height
|
|
* @chainable
|
|
*/
|
|
drawRect: function(x, y, w, h) {
|
|
this.moveTo(x, y);
|
|
this.lineTo(x + w, y);
|
|
this.lineTo(x + w, y + h);
|
|
this.lineTo(x, y + h);
|
|
this.lineTo(x, y);
|
|
this._currentX = x;
|
|
this._currentY = y;
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Draws a rectangle with rounded corners.
|
|
*
|
|
* @method drawRect
|
|
* @param {Number} x x-coordinate
|
|
* @param {Number} y y-coordinate
|
|
* @param {Number} w width
|
|
* @param {Number} h height
|
|
* @param {Number} ew width of the ellipse used to draw the rounded corners
|
|
* @param {Number} eh height of the ellipse used to draw the rounded corners
|
|
* @chainable
|
|
*/
|
|
drawRoundRect: function(x, y, w, h, ew, eh) {
|
|
this.moveTo(x, y + eh);
|
|
this.lineTo(x, y + h - eh);
|
|
this.quadraticCurveTo(x, y + h, x + ew, y + h);
|
|
this.lineTo(x + w - ew, y + h);
|
|
this.quadraticCurveTo(x + w, y + h, x + w, y + h - eh);
|
|
this.lineTo(x + w, y + eh);
|
|
this.quadraticCurveTo(x + w, y, x + w - ew, y);
|
|
this.lineTo(x + ew, y);
|
|
this.quadraticCurveTo(x, y, x, y + eh);
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Draws a circle. Used internally by `CanvasCircle` class.
|
|
*
|
|
* @method drawCircle
|
|
* @param {Number} x y-coordinate
|
|
* @param {Number} y x-coordinate
|
|
* @param {Number} r radius
|
|
* @chainable
|
|
* @protected
|
|
*/
|
|
drawCircle: function(x, y, radius) {
|
|
var startAngle = 0,
|
|
endAngle = 360,
|
|
circum = radius * 2;
|
|
|
|
endAngle *= 65535;
|
|
this._drawingComplete = false;
|
|
this._trackSize(x + circum, y + circum);
|
|
this.moveTo((x + circum), (y + radius));
|
|
this._addToPath(
|
|
" ae " +
|
|
this._round(x + radius) +
|
|
", " +
|
|
this._round(y + radius) +
|
|
", " +
|
|
this._round(radius) +
|
|
", " +
|
|
this._round(radius) +
|
|
", " +
|
|
startAngle +
|
|
", " +
|
|
endAngle
|
|
);
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Draws an ellipse.
|
|
*
|
|
* @method drawEllipse
|
|
* @param {Number} x x-coordinate
|
|
* @param {Number} y y-coordinate
|
|
* @param {Number} w width
|
|
* @param {Number} h height
|
|
* @chainable
|
|
* @protected
|
|
*/
|
|
drawEllipse: function(x, y, w, h) {
|
|
var startAngle = 0,
|
|
endAngle = 360,
|
|
radius = w * 0.5,
|
|
yRadius = h * 0.5;
|
|
endAngle *= 65535;
|
|
this._drawingComplete = false;
|
|
this._trackSize(x + w, y + h);
|
|
this.moveTo((x + w), (y + yRadius));
|
|
this._addToPath(
|
|
" ae " +
|
|
this._round(x + radius) +
|
|
", " +
|
|
this._round(x + radius) +
|
|
", " +
|
|
this._round(y + yRadius) +
|
|
", " +
|
|
this._round(radius) +
|
|
", " +
|
|
this._round(yRadius) +
|
|
", " +
|
|
startAngle +
|
|
", " +
|
|
endAngle
|
|
);
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Draws a diamond.
|
|
*
|
|
* @method drawDiamond
|
|
* @param {Number} x y-coordinate
|
|
* @param {Number} y x-coordinate
|
|
* @param {Number} width width
|
|
* @param {Number} height height
|
|
* @chainable
|
|
* @protected
|
|
*/
|
|
drawDiamond: function(x, y, width, height)
|
|
{
|
|
var midWidth = width * 0.5,
|
|
midHeight = height * 0.5;
|
|
this.moveTo(x + midWidth, y);
|
|
this.lineTo(x + width, y + midHeight);
|
|
this.lineTo(x + midWidth, y + height);
|
|
this.lineTo(x, y + midHeight);
|
|
this.lineTo(x + midWidth, y);
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Draws a wedge.
|
|
*
|
|
* @method drawWedge
|
|
* @param {Number} x x-coordinate of the wedge's center point
|
|
* @param {Number} y y-coordinate of the wedge's center point
|
|
* @param {Number} startAngle starting angle in degrees
|
|
* @param {Number} arc sweep of the wedge. Negative values draw clockwise.
|
|
* @param {Number} radius radius of wedge. If [optional] yRadius is defined, then radius is the x radius.
|
|
* @param {Number} yRadius [optional] y radius for wedge.
|
|
* @chainable
|
|
* @private
|
|
*/
|
|
drawWedge: function(x, y, startAngle, arc, radius)
|
|
{
|
|
var diameter = radius * 2;
|
|
if(Math.abs(arc) > 360)
|
|
{
|
|
arc = 360;
|
|
}
|
|
this._currentX = x;
|
|
this._currentY = y;
|
|
startAngle *= -65535;
|
|
arc *= 65536;
|
|
startAngle = Math.round(startAngle);
|
|
arc = Math.round(arc);
|
|
this.moveTo(x, y);
|
|
this._addToPath(
|
|
" ae " +
|
|
this._round(x) +
|
|
", " +
|
|
this._round(y) +
|
|
", " +
|
|
this._round(radius) +
|
|
" " +
|
|
this._round(radius) +
|
|
", " +
|
|
startAngle +
|
|
", " +
|
|
arc
|
|
);
|
|
this._trackSize(diameter, diameter);
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Draws a line segment from the current drawing position to the specified x and y coordinates.
|
|
*
|
|
* @method lineTo
|
|
* @param {Number} point1 x-coordinate for the end point.
|
|
* @param {Number} point2 y-coordinate for the end point.
|
|
* @chainable
|
|
*/
|
|
lineTo: function()
|
|
{
|
|
this._lineTo.apply(this, [Y.Array(arguments), false]);
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Draws a line segment using the current line style from the current drawing position to the relative x and y coordinates.
|
|
*
|
|
* @method relativeLineTo
|
|
* @param {Number} point1 x-coordinate for the end point.
|
|
* @param {Number} point2 y-coordinate for the end point.
|
|
* @chainable
|
|
*/
|
|
relativeLineTo: function()
|
|
{
|
|
this._lineTo.apply(this, [Y.Array(arguments), true]);
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Implements lineTo methods.
|
|
*
|
|
* @method _lineTo
|
|
* @param {Array} args The arguments to be used.
|
|
* @param {Boolean} relative Indicates whether or not to use relative coordinates.
|
|
* @private
|
|
*/
|
|
_lineTo: function(args, relative) {
|
|
var point1 = args[0],
|
|
i,
|
|
len,
|
|
x,
|
|
y,
|
|
path = relative ? " r " : " l ",
|
|
relativeX = relative ? parseFloat(this._currentX) : 0,
|
|
relativeY = relative ? parseFloat(this._currentY) : 0;
|
|
if (typeof point1 === "string" || typeof point1 === "number") {
|
|
len = args.length - 1;
|
|
for (i = 0; i < len; i = i + 2) {
|
|
x = parseFloat(args[i]);
|
|
y = parseFloat(args[i + 1]);
|
|
path += ' ' + this._round(x) + ', ' + this._round(y);
|
|
x = x + relativeX;
|
|
y = y + relativeY;
|
|
this._currentX = x;
|
|
this._currentY = y;
|
|
this._trackSize.apply(this, [x, y]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
len = args.length;
|
|
for (i = 0; i < len; i = i + 1) {
|
|
x = parseFloat(args[i][0]);
|
|
y = parseFloat(args[i][1]);
|
|
path += ' ' + this._round(x) + ', ' + this._round(y);
|
|
x = x + relativeX;
|
|
y = y + relativeY;
|
|
this._currentX = x;
|
|
this._currentY = y;
|
|
this._trackSize.apply(this, [x, y]);
|
|
}
|
|
}
|
|
this._addToPath(path);
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Moves the current drawing position to specified x and y coordinates.
|
|
*
|
|
* @method moveTo
|
|
* @param {Number} x x-coordinate for the end point.
|
|
* @param {Number} y y-coordinate for the end point.
|
|
* @chainable
|
|
*/
|
|
moveTo: function()
|
|
{
|
|
this._moveTo.apply(this, [Y.Array(arguments), false]);
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Moves the current drawing position relative to specified x and y coordinates.
|
|
*
|
|
* @method relativeMoveTo
|
|
* @param {Number} x x-coordinate for the end point.
|
|
* @param {Number} y y-coordinate for the end point.
|
|
* @chainable
|
|
*/
|
|
relativeMoveTo: function()
|
|
{
|
|
this._moveTo.apply(this, [Y.Array(arguments), true]);
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Implements moveTo methods.
|
|
*
|
|
* @method _moveTo
|
|
* @param {Array} args The arguments to be used.
|
|
* @param {Boolean} relative Indicates whether or not to use relative coordinates.
|
|
* @private
|
|
*/
|
|
_moveTo: function(args, relative) {
|
|
var x = parseFloat(args[0]),
|
|
y = parseFloat(args[1]),
|
|
command = relative ? " t " : " m ",
|
|
relativeX = relative ? parseFloat(this._currentX) : 0,
|
|
relativeY = relative ? parseFloat(this._currentY) : 0;
|
|
this._movePath = command + this._round(x) + ", " + this._round(y);
|
|
x = x + relativeX;
|
|
y = y + relativeY;
|
|
this._trackSize(x, y);
|
|
this._currentX = x;
|
|
this._currentY = y;
|
|
},
|
|
|
|
/**
|
|
* Draws the graphic.
|
|
*
|
|
* @method _draw
|
|
* @private
|
|
*/
|
|
_closePath: function()
|
|
{
|
|
var fill = this.get("fill"),
|
|
stroke = this.get("stroke"),
|
|
node = this.node,
|
|
w = this.get("width"),
|
|
h = this.get("height"),
|
|
path = this._path,
|
|
pathEnd = "",
|
|
multiplier = this._coordSpaceMultiplier;
|
|
this._fillChangeHandler();
|
|
this._strokeChangeHandler();
|
|
if(path)
|
|
{
|
|
if(fill && fill.color)
|
|
{
|
|
pathEnd += ' x';
|
|
}
|
|
if(stroke)
|
|
{
|
|
pathEnd += ' e';
|
|
}
|
|
}
|
|
if(path)
|
|
{
|
|
node.path = path + pathEnd;
|
|
}
|
|
if(!isNaN(w) && !isNaN(h))
|
|
{
|
|
node.coordOrigin = this._left + ", " + this._top;
|
|
node.coordSize = (w * multiplier) + ", " + (h * multiplier);
|
|
node.style.position = "absolute";
|
|
node.style.width = w + "px";
|
|
node.style.height = h + "px";
|
|
}
|
|
this._path = path;
|
|
this._movePath = null;
|
|
this._updateTransform();
|
|
},
|
|
|
|
/**
|
|
* Completes a drawing operation.
|
|
*
|
|
* @method end
|
|
* @chainable
|
|
*/
|
|
end: function()
|
|
{
|
|
this._closePath();
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Ends a fill and stroke
|
|
*
|
|
* @method closePath
|
|
* @chainable
|
|
*/
|
|
closePath: function()
|
|
{
|
|
this._addToPath(" x e");
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Clears the path.
|
|
*
|
|
* @method clear
|
|
* @chainable
|
|
*/
|
|
clear: function()
|
|
{
|
|
this._right = 0;
|
|
this._bottom = 0;
|
|
this._width = 0;
|
|
this._height = 0;
|
|
this._left = 0;
|
|
this._top = 0;
|
|
this._path = "";
|
|
this._movePath = null;
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Returns the points on a curve
|
|
*
|
|
* @method getBezierData
|
|
* @param Array points Array containing the begin, end and control points of a curve.
|
|
* @param Number t The value for incrementing the next set of points.
|
|
* @return Array
|
|
* @private
|
|
*/
|
|
getBezierData: function(points, t) {
|
|
var n = points.length,
|
|
tmp = [],
|
|
i,
|
|
j;
|
|
|
|
for (i = 0; i < n; ++i){
|
|
tmp[i] = [points[i][0], points[i][1]]; // save input
|
|
}
|
|
|
|
for (j = 1; j < n; ++j) {
|
|
for (i = 0; i < n - j; ++i) {
|
|
tmp[i][0] = (1 - t) * tmp[i][0] + t * tmp[parseInt(i + 1, 10)][0];
|
|
tmp[i][1] = (1 - t) * tmp[i][1] + t * tmp[parseInt(i + 1, 10)][1];
|
|
}
|
|
}
|
|
return [ tmp[0][0], tmp[0][1] ];
|
|
},
|
|
|
|
/**
|
|
* Calculates the bounding box for a curve
|
|
*
|
|
* @method _setCurveBoundingBox
|
|
* @param Array pts Array containing points for start, end and control points of a curve.
|
|
* @param Number w Width used to calculate the number of points to describe the curve.
|
|
* @param Number h Height used to calculate the number of points to describe the curve.
|
|
* @private
|
|
*/
|
|
_setCurveBoundingBox: function(pts, w, h)
|
|
{
|
|
var i,
|
|
left = this._currentX,
|
|
right = left,
|
|
top = this._currentY,
|
|
bottom = top,
|
|
len = Math.round(Math.sqrt((w * w) + (h * h))),
|
|
t = 1/len,
|
|
xy;
|
|
for(i = 0; i < len; ++i)
|
|
{
|
|
xy = this.getBezierData(pts, t * i);
|
|
left = isNaN(left) ? xy[0] : Math.min(xy[0], left);
|
|
right = isNaN(right) ? xy[0] : Math.max(xy[0], right);
|
|
top = isNaN(top) ? xy[1] : Math.min(xy[1], top);
|
|
bottom = isNaN(bottom) ? xy[1] : Math.max(xy[1], bottom);
|
|
}
|
|
left = Math.round(left * 10)/10;
|
|
right = Math.round(right * 10)/10;
|
|
top = Math.round(top * 10)/10;
|
|
bottom = Math.round(bottom * 10)/10;
|
|
this._trackSize(right, bottom);
|
|
this._trackSize(left, top);
|
|
},
|
|
|
|
/**
|
|
* Updates the size of the graphics object
|
|
*
|
|
* @method _trackSize
|
|
* @param {Number} w width
|
|
* @param {Number} h height
|
|
* @private
|
|
*/
|
|
_trackSize: function(w, h) {
|
|
if (w > this._right) {
|
|
this._right = w;
|
|
}
|
|
if(w < this._left)
|
|
{
|
|
this._left = w;
|
|
}
|
|
if (h < this._top)
|
|
{
|
|
this._top = h;
|
|
}
|
|
if (h > this._bottom)
|
|
{
|
|
this._bottom = h;
|
|
}
|
|
this._width = this._right - this._left;
|
|
this._height = this._bottom - this._top;
|
|
},
|
|
|
|
_left: 0,
|
|
|
|
_right: 0,
|
|
|
|
_top: 0,
|
|
|
|
_bottom: 0,
|
|
|
|
_width: 0,
|
|
|
|
_height: 0
|
|
};
|
|
Y.VMLDrawing = VMLDrawing;
|
|
/**
|
|
* <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;
|
|
/**
|
|
* <a href="http://www.w3.org/TR/NOTE-VML">VML</a> implementation of the <a href="Path.html">`Path`</a> class.
|
|
* `VMLPath` is not intended to be used directly. Instead, use the <a href="Path.html">`Path`</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="Path.html">`Path`</a> class will point to the `VMLPath` class.
|
|
*
|
|
* @module graphics
|
|
* @class VMLPath
|
|
* @extends VMLShape
|
|
*/
|
|
VMLPath = function()
|
|
{
|
|
VMLPath.superclass.constructor.apply(this, arguments);
|
|
};
|
|
|
|
VMLPath.NAME = "path";
|
|
Y.extend(VMLPath, Y.VMLShape);
|
|
VMLPath.ATTRS = Y.merge(Y.VMLShape.ATTRS, {
|
|
/**
|
|
* Indicates the width of the shape
|
|
*
|
|
* @config width
|
|
* @type Number
|
|
*/
|
|
width: {
|
|
getter: function()
|
|
{
|
|
var val = Math.max(this._right - this._left, 0);
|
|
return val;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Indicates the height of the shape
|
|
*
|
|
* @config height
|
|
* @type Number
|
|
*/
|
|
height: {
|
|
getter: function()
|
|
{
|
|
return Math.max(this._bottom - this._top, 0);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Indicates the path used for the node.
|
|
*
|
|
* @config path
|
|
* @type String
|
|
* @readOnly
|
|
*/
|
|
path: {
|
|
readOnly: true,
|
|
|
|
getter: function()
|
|
{
|
|
return this._path;
|
|
}
|
|
}
|
|
});
|
|
Y.VMLPath = VMLPath;
|
|
/**
|
|
* <a href="http://www.w3.org/TR/NOTE-VML">VML</a> implementation of the <a href="Rect.html">`Rect`</a> class.
|
|
* `VMLRect` is not intended to be used directly. Instead, use the <a href="Rect.html">`Rect`</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="Rect.html">`Rect`</a> class will point to the `VMLRect` class.
|
|
*
|
|
* @module graphics
|
|
* @class VMLRect
|
|
* @constructor
|
|
*/
|
|
VMLRect = function()
|
|
{
|
|
VMLRect.superclass.constructor.apply(this, arguments);
|
|
};
|
|
VMLRect.NAME = "rect";
|
|
Y.extend(VMLRect, Y.VMLShape, {
|
|
/**
|
|
* Indicates the type of shape
|
|
*
|
|
* @property _type
|
|
* @type String
|
|
* @private
|
|
*/
|
|
_type: "rect"
|
|
});
|
|
VMLRect.ATTRS = Y.VMLShape.ATTRS;
|
|
Y.VMLRect = VMLRect;
|
|
/**
|
|
* <a href="http://www.w3.org/TR/NOTE-VML">VML</a> implementation of the <a href="Ellipse.html">`Ellipse`</a> class.
|
|
* `VMLEllipse` is not intended to be used directly. Instead, use the <a href="Ellipse.html">`Ellipse`</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="Ellipse.html">`Ellipse`</a> class will point to the `VMLEllipse` class.
|
|
*
|
|
* @module graphics
|
|
* @class VMLEllipse
|
|
* @constructor
|
|
*/
|
|
VMLEllipse = function()
|
|
{
|
|
VMLEllipse.superclass.constructor.apply(this, arguments);
|
|
};
|
|
|
|
VMLEllipse.NAME = "ellipse";
|
|
|
|
Y.extend(VMLEllipse, Y.VMLShape, {
|
|
/**
|
|
* Indicates the type of shape
|
|
*
|
|
* @property _type
|
|
* @type String
|
|
* @private
|
|
*/
|
|
_type: "oval"
|
|
});
|
|
VMLEllipse.ATTRS = Y.merge(Y.VMLShape.ATTRS, {
|
|
/**
|
|
* Horizontal radius for the ellipse.
|
|
*
|
|
* @config xRadius
|
|
* @type Number
|
|
*/
|
|
xRadius: {
|
|
lazyAdd: false,
|
|
|
|
getter: function()
|
|
{
|
|
var val = this.get("width");
|
|
val = Math.round((val/2) * 100)/100;
|
|
return val;
|
|
},
|
|
|
|
setter: function(val)
|
|
{
|
|
var w = val * 2;
|
|
this.set("width", w);
|
|
return val;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Vertical radius for the ellipse.
|
|
*
|
|
* @config yRadius
|
|
* @type Number
|
|
* @readOnly
|
|
*/
|
|
yRadius: {
|
|
lazyAdd: false,
|
|
|
|
getter: function()
|
|
{
|
|
var val = this.get("height");
|
|
val = Math.round((val/2) * 100)/100;
|
|
return val;
|
|
},
|
|
|
|
setter: function(val)
|
|
{
|
|
var h = val * 2;
|
|
this.set("height", h);
|
|
return val;
|
|
}
|
|
}
|
|
});
|
|
Y.VMLEllipse = VMLEllipse;
|
|
/**
|
|
* <a href="http://www.w3.org/TR/NOTE-VML">VML</a> implementation of the <a href="Circle.html">`Circle`</a> class.
|
|
* `VMLCircle` is not intended to be used directly. Instead, use the <a href="Circle.html">`Circle`</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="Circle.html">`Circle`</a> class will point to the `VMLCircle` class.
|
|
*
|
|
* @module graphics
|
|
* @class VMLCircle
|
|
* @constructor
|
|
*/
|
|
VMLCircle = function()
|
|
{
|
|
VMLCircle.superclass.constructor.apply(this, arguments);
|
|
};
|
|
|
|
VMLCircle.NAME = "circle";
|
|
|
|
Y.extend(VMLCircle, VMLShape, {
|
|
/**
|
|
* Indicates the type of shape
|
|
*
|
|
* @property _type
|
|
* @type String
|
|
* @private
|
|
*/
|
|
_type: "oval"
|
|
});
|
|
|
|
VMLCircle.ATTRS = Y.merge(VMLShape.ATTRS, {
|
|
/**
|
|
* Radius for the circle.
|
|
*
|
|
* @config radius
|
|
* @type Number
|
|
*/
|
|
radius: {
|
|
lazyAdd: false,
|
|
|
|
value: 0
|
|
},
|
|
|
|
/**
|
|
* Indicates the width of the shape
|
|
*
|
|
* @config width
|
|
* @type Number
|
|
*/
|
|
width: {
|
|
setter: function(val)
|
|
{
|
|
this.set("radius", val/2);
|
|
return val;
|
|
},
|
|
|
|
getter: function()
|
|
{
|
|
var radius = this.get("radius"),
|
|
val = radius && radius > 0 ? radius * 2 : 0;
|
|
return val;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Indicates the height of the shape
|
|
*
|
|
* @config height
|
|
* @type Number
|
|
*/
|
|
height: {
|
|
setter: function(val)
|
|
{
|
|
this.set("radius", val/2);
|
|
return val;
|
|
},
|
|
|
|
getter: function()
|
|
{
|
|
var radius = this.get("radius"),
|
|
val = radius && radius > 0 ? radius * 2 : 0;
|
|
return val;
|
|
}
|
|
}
|
|
});
|
|
Y.VMLCircle = VMLCircle;
|
|
/**
|
|
* Draws pie slices
|
|
*
|
|
* @module graphics
|
|
* @class VMLPieSlice
|
|
* @constructor
|
|
*/
|
|
VMLPieSlice = function()
|
|
{
|
|
VMLPieSlice.superclass.constructor.apply(this, arguments);
|
|
};
|
|
VMLPieSlice.NAME = "vmlPieSlice";
|
|
Y.extend(VMLPieSlice, Y.VMLShape, Y.mix({
|
|
/**
|
|
* Indicates the type of shape
|
|
*
|
|
* @property _type
|
|
* @type String
|
|
* @private
|
|
*/
|
|
_type: "shape",
|
|
|
|
/**
|
|
* Change event listener
|
|
*
|
|
* @private
|
|
* @method _updateHandler
|
|
*/
|
|
_draw: function()
|
|
{
|
|
var x = this.get("cx"),
|
|
y = this.get("cy"),
|
|
startAngle = this.get("startAngle"),
|
|
arc = this.get("arc"),
|
|
radius = this.get("radius");
|
|
this.clear();
|
|
this.drawWedge(x, y, startAngle, arc, radius);
|
|
this.end();
|
|
}
|
|
}, Y.VMLDrawing.prototype));
|
|
VMLPieSlice.ATTRS = Y.mix({
|
|
cx: {
|
|
value: 0
|
|
},
|
|
|
|
cy: {
|
|
value: 0
|
|
},
|
|
/**
|
|
* Starting angle in relation to a circle in which to begin the pie slice drawing.
|
|
*
|
|
* @config startAngle
|
|
* @type Number
|
|
*/
|
|
startAngle: {
|
|
value: 0
|
|
},
|
|
|
|
/**
|
|
* Arc of the slice.
|
|
*
|
|
* @config arc
|
|
* @type Number
|
|
*/
|
|
arc: {
|
|
value: 0
|
|
},
|
|
|
|
/**
|
|
* Radius of the circle in which the pie slice is drawn
|
|
*
|
|
* @config radius
|
|
* @type Number
|
|
*/
|
|
radius: {
|
|
value: 0
|
|
}
|
|
}, Y.VMLShape.ATTRS);
|
|
Y.VMLPieSlice = VMLPieSlice;
|
|
/**
|
|
* <a href="http://www.w3.org/TR/NOTE-VML">VML</a> implementation of the <a href="Graphic.html">`Graphic`</a> class.
|
|
* `VMLGraphic` is not intended to be used directly. Instead, use the <a href="Graphic.html">`Graphic`</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="Graphic.html">`Graphic`</a> class will point to the `VMLGraphic` class.
|
|
*
|
|
* @module graphics
|
|
* @class VMLGraphic
|
|
* @constructor
|
|
*/
|
|
VMLGraphic = function() {
|
|
VMLGraphic.superclass.constructor.apply(this, arguments);
|
|
};
|
|
|
|
VMLGraphic.NAME = "vmlGraphic";
|
|
|
|
VMLGraphic.ATTRS = {
|
|
/**
|
|
* Whether or not to render the `Graphic` automatically after to a specified parent node after init. This can be a Node
|
|
* instance or a CSS selector string.
|
|
*
|
|
* @config render
|
|
* @type Node | String
|
|
*/
|
|
render: {},
|
|
|
|
/**
|
|
* 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;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Key value pairs in which a shape instance is associated with its id.
|
|
*
|
|
* @config shapes
|
|
* @type Object
|
|
* @readOnly
|
|
*/
|
|
shapes: {
|
|
readOnly: true,
|
|
|
|
getter: function()
|
|
{
|
|
return this._shapes;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Object containing size and coordinate data for the content of a Graphic in relation to the coordSpace node.
|
|
*
|
|
* @config contentBounds
|
|
* @type Object
|
|
*/
|
|
contentBounds: {
|
|
readOnly: true,
|
|
|
|
getter: function()
|
|
{
|
|
return this._contentBounds;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* The html element that represents to coordinate system of the Graphic instance.
|
|
*
|
|
* @config node
|
|
* @type HTMLElement
|
|
*/
|
|
node: {
|
|
readOnly: true,
|
|
|
|
getter: function()
|
|
{
|
|
return this._node;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Indicates the width of the `Graphic`.
|
|
*
|
|
* @config width
|
|
* @type Number
|
|
*/
|
|
width: {
|
|
setter: function(val)
|
|
{
|
|
if(this._node)
|
|
{
|
|
this._node.style.width = val + "px";
|
|
}
|
|
return val;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Indicates the height of the `Graphic`.
|
|
*
|
|
* @config height
|
|
* @type Number
|
|
*/
|
|
height: {
|
|
setter: function(val)
|
|
{
|
|
if(this._node)
|
|
{
|
|
this._node.style.height = val + "px";
|
|
}
|
|
return val;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Determines the sizing of the Graphic.
|
|
*
|
|
* <dl>
|
|
* <dt>sizeContentToGraphic</dt><dd>The Graphic's width and height attributes are, either explicitly set through the
|
|
* <code>width</code> and <code>height</code> attributes or are determined by the dimensions of the parent element. The
|
|
* content contained in the Graphic will be sized to fit with in the Graphic instance's dimensions. When using this
|
|
* setting, the <code>preserveAspectRatio</code> attribute will determine how the contents are sized.</dd>
|
|
* <dt>sizeGraphicToContent</dt><dd>(Also accepts a value of true) The Graphic's width and height are determined by the
|
|
* size and positioning of the content.</dd>
|
|
* <dt>false</dt><dd>The Graphic's width and height attributes are, either explicitly set through the <code>width</code>
|
|
* and <code>height</code> attributes or are determined by the dimensions of the parent element. The contents of the
|
|
* Graphic instance are not affected by this setting.</dd>
|
|
* </dl>
|
|
*
|
|
*
|
|
* @config autoSize
|
|
* @type Boolean | String
|
|
* @default false
|
|
*/
|
|
autoSize: {
|
|
value: false
|
|
},
|
|
|
|
/**
|
|
* Determines how content is sized when <code>autoSize</code> is set to <code>sizeContentToGraphic</code>.
|
|
*
|
|
* <dl>
|
|
* <dt>none<dt><dd>Do not force uniform scaling. Scale the graphic content of the given element non-uniformly if necessary
|
|
* such that the element's bounding box exactly matches the viewport rectangle.</dd>
|
|
* <dt>xMinYMin</dt><dd>Force uniform scaling position along the top left of the Graphic's node.</dd>
|
|
* <dt>xMidYMin</dt><dd>Force uniform scaling horizontally centered and positioned at the top of the Graphic's node.<dd>
|
|
* <dt>xMaxYMin</dt><dd>Force uniform scaling positioned horizontally from the right and vertically from the top.</dd>
|
|
* <dt>xMinYMid</dt>Force uniform scaling positioned horizontally from the left and vertically centered.</dd>
|
|
* <dt>xMidYMid (the default)</dt><dd>Force uniform scaling with the content centered.</dd>
|
|
* <dt>xMaxYMid</dt><dd>Force uniform scaling positioned horizontally from the right and vertically centered.</dd>
|
|
* <dt>xMinYMax</dt><dd>Force uniform scaling positioned horizontally from the left and vertically from the bottom.</dd>
|
|
* <dt>xMidYMax</dt><dd>Force uniform scaling horizontally centered and position vertically from the bottom.</dd>
|
|
* <dt>xMaxYMax</dt><dd>Force uniform scaling positioned horizontally from the right and vertically from the bottom.</dd>
|
|
* </dl>
|
|
*
|
|
* @config preserveAspectRatio
|
|
* @type String
|
|
* @default xMidYMid
|
|
*/
|
|
preserveAspectRatio: {
|
|
value: "xMidYMid"
|
|
},
|
|
|
|
/**
|
|
* The contentBounds will resize to greater values but not values. (for performance)
|
|
* When resizing the contentBounds down is desirable, set the resizeDown value to true.
|
|
*
|
|
* @config resizeDown
|
|
* @type Boolean
|
|
*/
|
|
resizeDown: {
|
|
resizeDown: false
|
|
},
|
|
|
|
/**
|
|
* Indicates the x-coordinate for the instance.
|
|
*
|
|
* @config x
|
|
* @type Number
|
|
*/
|
|
x: {
|
|
getter: function()
|
|
{
|
|
return this._x;
|
|
},
|
|
|
|
setter: function(val)
|
|
{
|
|
this._x = val;
|
|
if(this._node)
|
|
{
|
|
this._node.style.left = val + "px";
|
|
}
|
|
return val;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Indicates the y-coordinate for the instance.
|
|
*
|
|
* @config y
|
|
* @type Number
|
|
*/
|
|
y: {
|
|
getter: function()
|
|
{
|
|
return this._y;
|
|
},
|
|
|
|
setter: function(val)
|
|
{
|
|
this._y = val;
|
|
if(this._node)
|
|
{
|
|
this._node.style.top = val + "px";
|
|
}
|
|
return val;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Indicates whether or not the instance will automatically redraw after a change is made to a shape.
|
|
* This property will get set to false when batching operations.
|
|
*
|
|
* @config autoDraw
|
|
* @type Boolean
|
|
* @default true
|
|
* @private
|
|
*/
|
|
autoDraw: {
|
|
value: true
|
|
},
|
|
|
|
visible: {
|
|
value: true,
|
|
|
|
setter: function(val)
|
|
{
|
|
this._toggleVisible(val);
|
|
return val;
|
|
}
|
|
}
|
|
};
|
|
|
|
Y.extend(VMLGraphic, Y.GraphicBase, {
|
|
/**
|
|
* 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,
|
|
attr = arguments[0],
|
|
redrawAttrs = {
|
|
autoDraw: true,
|
|
autoSize: true,
|
|
preserveAspectRatio: true,
|
|
resizeDown: true
|
|
},
|
|
key,
|
|
forceRedraw = false;
|
|
AttributeLite.prototype.set.apply(host, arguments);
|
|
if(host._state.autoDraw === true && Y.Object.size(this._shapes) > 0)
|
|
{
|
|
if(Y_LANG.isString && redrawAttrs[attr])
|
|
{
|
|
forceRedraw = true;
|
|
}
|
|
else if(Y_LANG.isObject(attr))
|
|
{
|
|
for(key in redrawAttrs)
|
|
{
|
|
if(redrawAttrs.hasOwnProperty(key) && attr[key])
|
|
{
|
|
forceRedraw = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(forceRedraw)
|
|
{
|
|
host._redraw();
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Storage for `x` attribute.
|
|
*
|
|
* @property _x
|
|
* @type Number
|
|
* @private
|
|
*/
|
|
_x: 0,
|
|
|
|
/**
|
|
* Storage for `y` attribute.
|
|
*
|
|
* @property _y
|
|
* @type Number
|
|
* @private
|
|
*/
|
|
_y: 0,
|
|
|
|
/**
|
|
* Gets the current position of the graphic instance in page coordinates.
|
|
*
|
|
* @method getXY
|
|
* @return Array The XY position of the shape.
|
|
*/
|
|
getXY: function()
|
|
{
|
|
var node = this.parentNode,
|
|
x = this.get("x"),
|
|
y = this.get("y"),
|
|
xy;
|
|
if(node)
|
|
{
|
|
xy = Y.DOM.getXY(node);
|
|
xy[0] += x;
|
|
xy[1] += y;
|
|
}
|
|
else
|
|
{
|
|
xy = Y.DOM._getOffset(this._node);
|
|
}
|
|
return xy;
|
|
},
|
|
|
|
/**
|
|
* Initializes the class.
|
|
*
|
|
* @method initializer
|
|
* @private
|
|
*/
|
|
initializer: function() {
|
|
var render = this.get("render"),
|
|
visibility = this.get("visible") ? "visible" : "hidden";
|
|
this._shapes = {};
|
|
this._contentBounds = {
|
|
left: 0,
|
|
top: 0,
|
|
right: 0,
|
|
bottom: 0
|
|
};
|
|
this._node = this._createGraphic();
|
|
this._node.style.left = this.get("x") + "px";
|
|
this._node.style.top = this.get("y") + "px";
|
|
this._node.style.visibility = visibility;
|
|
this._node.setAttribute("id", this.get("id"));
|
|
if(render)
|
|
{
|
|
this.render(render);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Adds the graphics node to the dom.
|
|
*
|
|
* @method render
|
|
* @param {HTMLElement} parentNode node in which to render the graphics node into.
|
|
*/
|
|
render: function(render) {
|
|
var parentNode = render || DOCUMENT.body,
|
|
node = this._node,
|
|
w,
|
|
h;
|
|
if(render instanceof Y.Node)
|
|
{
|
|
parentNode = render._node;
|
|
}
|
|
else if(Y.Lang.isString(render))
|
|
{
|
|
parentNode = Y.Selector.query(render, DOCUMENT.body, true);
|
|
}
|
|
w = this.get("width") || parseInt(Y.DOM.getComputedStyle(parentNode, "width"), 10);
|
|
h = this.get("height") || parseInt(Y.DOM.getComputedStyle(parentNode, "height"), 10);
|
|
parentNode.appendChild(node);
|
|
this.parentNode = parentNode;
|
|
this.set("width", w);
|
|
this.set("height", h);
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Removes all nodes.
|
|
*
|
|
* @method destroy
|
|
*/
|
|
destroy: function()
|
|
{
|
|
this.removeAllShapes();
|
|
if(this._node)
|
|
{
|
|
this._removeChildren(this._node);
|
|
if(this._node.parentNode)
|
|
{
|
|
this._node.parentNode.removeChild(this._node);
|
|
}
|
|
this._node = null;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Generates a shape instance by type.
|
|
*
|
|
* @method addShape
|
|
* @param {Object} cfg attributes for the shape
|
|
* @return Shape
|
|
*/
|
|
addShape: function(cfg)
|
|
{
|
|
cfg.graphic = this;
|
|
if(!this.get("visible"))
|
|
{
|
|
cfg.visible = false;
|
|
}
|
|
var ShapeClass = this._getShapeClass(cfg.type),
|
|
shape = new ShapeClass(cfg);
|
|
this._appendShape(shape);
|
|
shape._appendStrokeAndFill();
|
|
return shape;
|
|
},
|
|
|
|
/**
|
|
* Adds a shape instance to the graphic instance.
|
|
*
|
|
* @method _appendShape
|
|
* @param {Shape} shape The shape instance to be added to the graphic.
|
|
* @private
|
|
*/
|
|
_appendShape: function(shape)
|
|
{
|
|
var node = shape.node,
|
|
parentNode = this._frag || this._node;
|
|
if(this.get("autoDraw") || this.get("autoSize") === "sizeContentToGraphic")
|
|
{
|
|
parentNode.appendChild(node);
|
|
}
|
|
else
|
|
{
|
|
this._getDocFrag().appendChild(node);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Removes a shape instance from from the graphic instance.
|
|
*
|
|
* @method removeShape
|
|
* @param {Shape|String} shape The instance or id of the shape to be removed.
|
|
*/
|
|
removeShape: function(shape)
|
|
{
|
|
if(!(shape instanceof VMLShape))
|
|
{
|
|
if(Y_LANG.isString(shape))
|
|
{
|
|
shape = this._shapes[shape];
|
|
}
|
|
}
|
|
if(shape && (shape instanceof VMLShape))
|
|
{
|
|
shape._destroy();
|
|
this._shapes[shape.get("id")] = null;
|
|
delete this._shapes[shape.get("id")];
|
|
}
|
|
if(this.get("autoDraw"))
|
|
{
|
|
this._redraw();
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Removes all shape instances from the dom.
|
|
*
|
|
* @method removeAllShapes
|
|
*/
|
|
removeAllShapes: function()
|
|
{
|
|
var shapes = this._shapes,
|
|
i;
|
|
for(i in shapes)
|
|
{
|
|
if(shapes.hasOwnProperty(i))
|
|
{
|
|
shapes[i].destroy();
|
|
}
|
|
}
|
|
this._shapes = {};
|
|
},
|
|
|
|
/**
|
|
* Removes all child nodes.
|
|
*
|
|
* @method _removeChildren
|
|
* @param node
|
|
* @private
|
|
*/
|
|
_removeChildren: function(node)
|
|
{
|
|
if(node.hasChildNodes())
|
|
{
|
|
var child;
|
|
while(node.firstChild)
|
|
{
|
|
child = node.firstChild;
|
|
this._removeChildren(child);
|
|
node.removeChild(child);
|
|
}
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Clears the graphics object.
|
|
*
|
|
* @method clear
|
|
*/
|
|
clear: function() {
|
|
this.removeAllShapes();
|
|
this._removeChildren(this._node);
|
|
},
|
|
|
|
/**
|
|
* Toggles visibility
|
|
*
|
|
* @method _toggleVisible
|
|
* @param {Boolean} val indicates visibilitye
|
|
* @private
|
|
*/
|
|
_toggleVisible: function(val)
|
|
{
|
|
var i,
|
|
shapes = this._shapes,
|
|
visibility = val ? "visible" : "hidden";
|
|
if(shapes)
|
|
{
|
|
for(i in shapes)
|
|
{
|
|
if(shapes.hasOwnProperty(i))
|
|
{
|
|
shapes[i].set("visible", val);
|
|
}
|
|
}
|
|
}
|
|
if(this._node)
|
|
{
|
|
this._node.style.visibility = visibility;
|
|
}
|
|
if(this._node)
|
|
{
|
|
this._node.style.visibility = visibility;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Sets the size of the graphics object.
|
|
*
|
|
* @method setSize
|
|
* @param w {Number} width to set for the instance.
|
|
* @param h {Number} height to set for the instance.
|
|
*/
|
|
setSize: function(w, h) {
|
|
w = Math.round(w);
|
|
h = Math.round(h);
|
|
this._node.style.width = w + 'px';
|
|
this._node.style.height = h + 'px';
|
|
},
|
|
|
|
/**
|
|
* Sets the positon of the graphics object.
|
|
*
|
|
* @method setPosition
|
|
* @param {Number} x x-coordinate for the object.
|
|
* @param {Number} y y-coordinate for the object.
|
|
*/
|
|
setPosition: function(x, y)
|
|
{
|
|
x = Math.round(x);
|
|
y = Math.round(y);
|
|
this._node.style.left = x + "px";
|
|
this._node.style.top = y + "px";
|
|
},
|
|
|
|
/**
|
|
* Creates a group element
|
|
*
|
|
* @method _createGraphic
|
|
* @private
|
|
*/
|
|
_createGraphic: function() {
|
|
var group = DOCUMENT.createElement(
|
|
'<group xmlns="urn:schemas-microsft.com:vml"' +
|
|
' style="behavior:url(#default#VML);padding:0px 0px 0px 0px;display:block;position:absolute;top:0px;left:0px;zoom:1;"' +
|
|
'/>'
|
|
);
|
|
return group;
|
|
},
|
|
|
|
/**
|
|
* Creates a graphic node
|
|
*
|
|
* @method _createGraphicNode
|
|
* @param {String} type node type to create
|
|
* @param {String} pe specified pointer-events value
|
|
* @return HTMLElement
|
|
* @private
|
|
*/
|
|
_createGraphicNode: function(type)
|
|
{
|
|
return DOCUMENT.createElement(
|
|
'<' +
|
|
type +
|
|
' xmlns="urn:schemas-microsft.com:vml"' +
|
|
' style="behavior:url(#default#VML);display:inline-block;zoom:1;"' +
|
|
'/>'
|
|
);
|
|
|
|
},
|
|
|
|
/**
|
|
* Returns a shape based on the id of its dom node.
|
|
*
|
|
* @method getShapeById
|
|
* @param {String} id Dom id of the shape's node attribute.
|
|
* @return Shape
|
|
*/
|
|
getShapeById: function(id)
|
|
{
|
|
return this._shapes[id];
|
|
},
|
|
|
|
/**
|
|
* Returns a shape class. Used by `addShape`.
|
|
*
|
|
* @method _getShapeClass
|
|
* @param {Shape | String} val Indicates which shape class.
|
|
* @return Function
|
|
* @private
|
|
*/
|
|
_getShapeClass: function(val)
|
|
{
|
|
var shape = this._shapeClass[val];
|
|
if(shape)
|
|
{
|
|
return shape;
|
|
}
|
|
return val;
|
|
},
|
|
|
|
/**
|
|
* Look up for shape classes. Used by `addShape` to retrieve a class for instantiation.
|
|
*
|
|
* @property _shapeClass
|
|
* @type Object
|
|
* @private
|
|
*/
|
|
_shapeClass: {
|
|
circle: Y.VMLCircle,
|
|
rect: Y.VMLRect,
|
|
path: Y.VMLPath,
|
|
ellipse: Y.VMLEllipse,
|
|
pieslice: Y.VMLPieSlice
|
|
},
|
|
|
|
/**
|
|
* Allows for creating multiple shapes in order to batch appending and redraw operations.
|
|
*
|
|
* @method batch
|
|
* @param {Function} method Method to execute.
|
|
*/
|
|
batch: function(method)
|
|
{
|
|
var autoDraw = this.get("autoDraw");
|
|
this.set("autoDraw", false);
|
|
method.apply();
|
|
this.set("autoDraw", autoDraw);
|
|
},
|
|
|
|
/**
|
|
* Returns a document fragment to for attaching shapes.
|
|
*
|
|
* @method _getDocFrag
|
|
* @return DocumentFragment
|
|
* @private
|
|
*/
|
|
_getDocFrag: function()
|
|
{
|
|
if(!this._frag)
|
|
{
|
|
this._frag = DOCUMENT.createDocumentFragment();
|
|
}
|
|
return this._frag;
|
|
},
|
|
|
|
/**
|
|
* Adds a shape to the redraw queue and calculates the contentBounds.
|
|
*
|
|
* @method addToRedrawQueue
|
|
* @param shape {VMLShape}
|
|
* @protected
|
|
*/
|
|
addToRedrawQueue: function(shape)
|
|
{
|
|
var shapeBox,
|
|
box;
|
|
this._shapes[shape.get("id")] = shape;
|
|
if(!this.get("resizeDown"))
|
|
{
|
|
shapeBox = shape.getBounds();
|
|
box = this._contentBounds;
|
|
box.left = box.left < shapeBox.left ? box.left : shapeBox.left;
|
|
box.top = box.top < shapeBox.top ? box.top : shapeBox.top;
|
|
box.right = box.right > shapeBox.right ? box.right : shapeBox.right;
|
|
box.bottom = box.bottom > shapeBox.bottom ? box.bottom : shapeBox.bottom;
|
|
box.width = box.right - box.left;
|
|
box.height = box.bottom - box.top;
|
|
this._contentBounds = box;
|
|
}
|
|
if(this.get("autoDraw"))
|
|
{
|
|
this._redraw();
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Redraws all shapes.
|
|
*
|
|
* @method _redraw
|
|
* @private
|
|
*/
|
|
_redraw: function()
|
|
{
|
|
var autoSize = this.get("autoSize"),
|
|
preserveAspectRatio,
|
|
node = this.parentNode,
|
|
nodeWidth = parseFloat(Y.DOM.getComputedStyle(node, "width")),
|
|
nodeHeight = parseFloat(Y.DOM.getComputedStyle(node, "height")),
|
|
xCoordOrigin = 0,
|
|
yCoordOrigin = 0,
|
|
box = this.get("resizeDown") ? this._getUpdatedContentBounds() : this._contentBounds,
|
|
left = box.left,
|
|
right = box.right,
|
|
top = box.top,
|
|
bottom = box.bottom,
|
|
contentWidth = right - left,
|
|
contentHeight = bottom - top,
|
|
aspectRatio,
|
|
xCoordSize,
|
|
yCoordSize,
|
|
scaledWidth,
|
|
scaledHeight,
|
|
visible = this.get("visible");
|
|
this._node.style.visibility = "hidden";
|
|
if(autoSize)
|
|
{
|
|
if(autoSize === "sizeContentToGraphic")
|
|
{
|
|
preserveAspectRatio = this.get("preserveAspectRatio");
|
|
if(preserveAspectRatio === "none" || contentWidth/contentHeight === nodeWidth/nodeHeight)
|
|
{
|
|
xCoordOrigin = left;
|
|
yCoordOrigin = top;
|
|
xCoordSize = contentWidth;
|
|
yCoordSize = contentHeight;
|
|
}
|
|
else
|
|
{
|
|
if(contentWidth * nodeHeight/contentHeight > nodeWidth)
|
|
{
|
|
aspectRatio = nodeHeight/nodeWidth;
|
|
xCoordSize = contentWidth;
|
|
yCoordSize = contentWidth * aspectRatio;
|
|
scaledHeight = (nodeWidth * (contentHeight/contentWidth)) * (yCoordSize/nodeHeight);
|
|
yCoordOrigin = this._calculateCoordOrigin(preserveAspectRatio.slice(5).toLowerCase(), scaledHeight, yCoordSize);
|
|
yCoordOrigin = top + yCoordOrigin;
|
|
xCoordOrigin = left;
|
|
}
|
|
else
|
|
{
|
|
aspectRatio = nodeWidth/nodeHeight;
|
|
xCoordSize = contentHeight * aspectRatio;
|
|
yCoordSize = contentHeight;
|
|
scaledWidth = (nodeHeight * (contentWidth/contentHeight)) * (xCoordSize/nodeWidth);
|
|
xCoordOrigin = this._calculateCoordOrigin(preserveAspectRatio.slice(1, 4).toLowerCase(), scaledWidth, xCoordSize);
|
|
xCoordOrigin = xCoordOrigin + left;
|
|
yCoordOrigin = top;
|
|
}
|
|
}
|
|
this._node.style.width = nodeWidth + "px";
|
|
this._node.style.height = nodeHeight + "px";
|
|
this._node.coordOrigin = xCoordOrigin + ", " + yCoordOrigin;
|
|
}
|
|
else
|
|
{
|
|
xCoordSize = contentWidth;
|
|
yCoordSize = contentHeight;
|
|
this._node.style.width = contentWidth + "px";
|
|
this._node.style.height = contentHeight + "px";
|
|
this._state.width = contentWidth;
|
|
this._state.height = contentHeight;
|
|
|
|
}
|
|
this._node.coordSize = xCoordSize + ", " + yCoordSize;
|
|
}
|
|
else
|
|
{
|
|
this._node.style.width = nodeWidth + "px";
|
|
this._node.style.height = nodeHeight + "px";
|
|
this._node.coordSize = nodeWidth + ", " + nodeHeight;
|
|
}
|
|
if(this._frag)
|
|
{
|
|
this._node.appendChild(this._frag);
|
|
this._frag = null;
|
|
}
|
|
if(visible)
|
|
{
|
|
this._node.style.visibility = "visible";
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Determines the value for either an x or y coordinate to be used for the <code>coordOrigin</code> of the Graphic.
|
|
*
|
|
* @method _calculateCoordOrigin
|
|
* @param {String} position The position for placement. Possible values are min, mid and max.
|
|
* @param {Number} size The total scaled size of the content.
|
|
* @param {Number} coordsSize The coordsSize for the Graphic.
|
|
* @return Number
|
|
* @private
|
|
*/
|
|
_calculateCoordOrigin: function(position, size, coordsSize)
|
|
{
|
|
var coord;
|
|
switch(position)
|
|
{
|
|
case "min" :
|
|
coord = 0;
|
|
break;
|
|
case "mid" :
|
|
coord = (size - coordsSize)/2;
|
|
break;
|
|
case "max" :
|
|
coord = (size - coordsSize);
|
|
break;
|
|
}
|
|
return coord;
|
|
},
|
|
|
|
/**
|
|
* Recalculates and returns the `contentBounds` for the `Graphic` instance.
|
|
*
|
|
* @method _getUpdatedContentBounds
|
|
* @return {Object}
|
|
* @private
|
|
*/
|
|
_getUpdatedContentBounds: function()
|
|
{
|
|
var bounds,
|
|
i,
|
|
shape,
|
|
queue = this._shapes,
|
|
box = {};
|
|
for(i in queue)
|
|
{
|
|
if(queue.hasOwnProperty(i))
|
|
{
|
|
shape = queue[i];
|
|
bounds = shape.getBounds();
|
|
box.left = Y_LANG.isNumber(box.left) ? Math.min(box.left, bounds.left) : bounds.left;
|
|
box.top = Y_LANG.isNumber(box.top) ? Math.min(box.top, bounds.top) : bounds.top;
|
|
box.right = Y_LANG.isNumber(box.right) ? Math.max(box.right, bounds.right) : bounds.right;
|
|
box.bottom = Y_LANG.isNumber(box.bottom) ? Math.max(box.bottom, bounds.bottom) : bounds.bottom;
|
|
}
|
|
}
|
|
box.left = Y_LANG.isNumber(box.left) ? box.left : 0;
|
|
box.top = Y_LANG.isNumber(box.top) ? box.top : 0;
|
|
box.right = Y_LANG.isNumber(box.right) ? box.right : 0;
|
|
box.bottom = Y_LANG.isNumber(box.bottom) ? box.bottom : 0;
|
|
this._contentBounds = box;
|
|
return box;
|
|
},
|
|
|
|
/**
|
|
* Inserts shape on the top of the tree.
|
|
*
|
|
* @method _toFront
|
|
* @param {VMLShape} Shape to add.
|
|
* @private
|
|
*/
|
|
_toFront: function(shape)
|
|
{
|
|
var contentNode = this._node;
|
|
if(shape instanceof Y.VMLShape)
|
|
{
|
|
shape = shape.get("node");
|
|
}
|
|
if(contentNode && shape)
|
|
{
|
|
contentNode.appendChild(shape);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Inserts shape as the first child of the content node.
|
|
*
|
|
* @method _toBack
|
|
* @param {VMLShape} Shape to add.
|
|
* @private
|
|
*/
|
|
_toBack: function(shape)
|
|
{
|
|
var contentNode = this._node,
|
|
targetNode;
|
|
if(shape instanceof Y.VMLShape)
|
|
{
|
|
shape = shape.get("node");
|
|
}
|
|
if(contentNode && shape)
|
|
{
|
|
targetNode = contentNode.firstChild;
|
|
if(targetNode)
|
|
{
|
|
contentNode.insertBefore(shape, targetNode);
|
|
}
|
|
else
|
|
{
|
|
contentNode.appendChild(shape);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
Y.VMLGraphic = VMLGraphic;
|
|
|
|
|
|
|
|
}, '3.17.2', {"requires": ["graphics", "color-base"]});
|
|
|