+++ /dev/null
-if(!dojo._hasResource["dojox.gfx.arc"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
-dojo._hasResource["dojox.gfx.arc"] = true;
-dojo.provide("dojox.gfx.arc");
-
-dojo.require("dojox.gfx.matrix");
-
-(function(){
- var m = dojox.gfx.matrix,
- unitArcAsBezier = function(alpha){
- // summary: return a start point, 1st and 2nd control points, and an end point of
- // a an arc, which is reflected on the x axis
- // alpha: Number: angle in radians, the arc will be 2 * angle size
- var cosa = Math.cos(alpha), sina = Math.sin(alpha),
- p2 = {x: cosa + (4 / 3) * (1 - cosa), y: sina - (4 / 3) * cosa * (1 - cosa) / sina};
- return { // Object
- s: {x: cosa, y: -sina},
- c1: {x: p2.x, y: -p2.y},
- c2: p2,
- e: {x: cosa, y: sina}
- };
- },
- twoPI = 2 * Math.PI, pi4 = Math.PI / 4, pi8 = Math.PI / 8,
- pi48 = pi4 + pi8, curvePI4 = unitArcAsBezier(pi8);
-
- dojo.mixin(dojox.gfx.arc, {
- unitArcAsBezier: unitArcAsBezier,
- curvePI4: curvePI4,
- arcAsBezier: function(last, rx, ry, xRotg, large, sweep, x, y){
- // summary: calculates an arc as a series of Bezier curves
- // given the last point and a standard set of SVG arc parameters,
- // it returns an array of arrays of parameters to form a series of
- // absolute Bezier curves.
- // last: Object: a point-like object as a start of the arc
- // rx: Number: a horizontal radius for the virtual ellipse
- // ry: Number: a vertical radius for the virtual ellipse
- // xRotg: Number: a rotation of an x axis of the virtual ellipse in degrees
- // large: Boolean: which part of the ellipse will be used (the larger arc if true)
- // sweep: Boolean: direction of the arc (CW if true)
- // x: Number: the x coordinate of the end point of the arc
- // y: Number: the y coordinate of the end point of the arc
-
- // calculate parameters
- large = Boolean(large);
- sweep = Boolean(sweep);
- var xRot = m._degToRad(xRotg),
- rx2 = rx * rx, ry2 = ry * ry,
- pa = m.multiplyPoint(
- m.rotate(-xRot),
- {x: (last.x - x) / 2, y: (last.y - y) / 2}
- ),
- pax2 = pa.x * pa.x, pay2 = pa.y * pa.y,
- c1 = Math.sqrt((rx2 * ry2 - rx2 * pay2 - ry2 * pax2) / (rx2 * pay2 + ry2 * pax2));
- if(isNaN(c1)){ c1 = 0; }
- var ca = {
- x: c1 * rx * pa.y / ry,
- y: -c1 * ry * pa.x / rx
- };
- if(large == sweep){
- ca = {x: -ca.x, y: -ca.y};
- }
- // the center
- var c = m.multiplyPoint(
- [
- m.translate(
- (last.x + x) / 2,
- (last.y + y) / 2
- ),
- m.rotate(xRot)
- ],
- ca
- );
- // calculate the elliptic transformation
- var elliptic_transform = m.normalize([
- m.translate(c.x, c.y),
- m.rotate(xRot),
- m.scale(rx, ry)
- ]);
- // start, end, and size of our arc
- var inversed = m.invert(elliptic_transform),
- sp = m.multiplyPoint(inversed, last),
- ep = m.multiplyPoint(inversed, x, y),
- startAngle = Math.atan2(sp.y, sp.x),
- endAngle = Math.atan2(ep.y, ep.x),
- theta = startAngle - endAngle; // size of our arc in radians
- if(sweep){ theta = -theta; }
- if(theta < 0){
- theta += twoPI;
- }else if(theta > twoPI){
- theta -= twoPI;
- }
-
- // draw curve chunks
- var alpha = pi8, curve = curvePI4, step = sweep ? alpha : -alpha,
- result = [];
- for(var angle = theta; angle > 0; angle -= pi4){
- if(angle < pi48){
- alpha = angle / 2;
- curve = unitArcAsBezier(alpha);
- step = sweep ? alpha : -alpha;
- angle = 0; // stop the loop
- }
- var c1, c2, e,
- M = m.normalize([elliptic_transform, m.rotate(startAngle + step)]);
- if(sweep){
- c1 = m.multiplyPoint(M, curve.c1);
- c2 = m.multiplyPoint(M, curve.c2);
- e = m.multiplyPoint(M, curve.e );
- }else{
- c1 = m.multiplyPoint(M, curve.c2);
- c2 = m.multiplyPoint(M, curve.c1);
- e = m.multiplyPoint(M, curve.s );
- }
- // draw the curve
- result.push([c1.x, c1.y, c2.x, c2.y, e.x, e.y]);
- startAngle += 2 * step;
- }
- return result; // Object
- }
- });
-})();
-
-}
projects / eow / blobdiff