royale-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From alinak...@apache.org
Subject [royale-asjs] branch feature/MXRoyale updated: GraphicsUtilities.as Added
Date Mon, 30 Apr 2018 05:24:49 GMT
This is an automated email from the ASF dual-hosted git repository.

alinakazi pushed a commit to branch feature/MXRoyale
in repository https://gitbox.apache.org/repos/asf/royale-asjs.git


The following commit(s) were added to refs/heads/feature/MXRoyale by this push:
     new b0f88be  GraphicsUtilities.as Added
b0f88be is described below

commit b0f88bed6ada7c608d85e55393afd927e454b2d4
Author: alinakazi <ALINAKAZI1990@GMAIL.COM>
AuthorDate: Mon Apr 30 10:24:47 2018 +0500

    GraphicsUtilities.as Added
---
 .../mx/charts/chartClasses/GraphicsUtilities.as    | 642 +++++++++++++++++++++
 1 file changed, 642 insertions(+)

diff --git a/frameworks/projects/MXRoyale/src/main/royale/mx/charts/chartClasses/GraphicsUtilities.as
b/frameworks/projects/MXRoyale/src/main/royale/mx/charts/chartClasses/GraphicsUtilities.as
new file mode 100644
index 0000000..91c69c2
--- /dev/null
+++ b/frameworks/projects/MXRoyale/src/main/royale/mx/charts/chartClasses/GraphicsUtilities.as
@@ -0,0 +1,642 @@
+////////////////////////////////////////////////////////////////////////////////
+//
+//  Licensed to the Apache Software Foundation (ASF) under one or more
+//  contributor license agreements.  See the NOTICE file distributed with
+//  this work for additional information regarding copyright ownership.
+//  The ASF licenses this file to You under the Apache License, Version 2.0
+//  (the "License"); you may not use this file except in compliance with
+//  the License.  You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+package mx.charts.chartClasses
+{
+
+//import flash.display.Graphics;
+import org.apache.royale.geom.Point;
+import org.apache.royale.geom.Rectangle;
+import mx.graphics.IFill;
+import mx.graphics.IStroke;
+import mx.graphics.LinearGradient;
+//import mx.graphics.RadialGradient;
+import mx.graphics.SolidColor;
+
+/**
+ *  A set of internal graphics rendering utilities
+ *  used by the various chart classes.
+ *  
+ *  @langversion 3.0
+ *  @playerversion Flash 9
+ *  @playerversion AIR 1.1
+ *  @productversion Royale 0.9.3
+ */
+public class GraphicsUtilities
+{
+   /*  include "../../core/Version.as";
+ */
+	//--------------------------------------------------------------------------
+	//
+	//  Class constants
+	//
+	//--------------------------------------------------------------------------
+
+	/**
+	 *  @private
+	 */
+	/* private static var LINE_FORM:Object =
+	{
+		segment: 0,
+		step: 1,
+		vertical: 2,
+		horizontal: 3,
+		reverseStep: 4,
+		curve: 5
+	} */
+	
+	//--------------------------------------------------------------------------
+	//
+	//  Class methods
+	//
+	//--------------------------------------------------------------------------
+
+	/**
+	 *  Applies the values in a Stroke to the provded Graphics object. This utility function
+	 *  applies the Stroke passed in, or clears the line style of the provided Graphics object
+	 *	if the <code>ls</code> parameter is set to <code>null</code>.
+	 *
+	 *	@param g The Graphics object to modify.
+	 *	@param ls The IStroke instance to apply; set to <code>null</code> to render
with no Stroke.
+	 *  
+	 *  @langversion 3.0
+	 *  @playerversion Flash 9
+	 *  @playerversion AIR 1.1
+	 *  @productversion Royale 0.9.3
+	 */
+	public static function setLineStyle(g:Object, ls:IStroke):void //g:Graphics is replaced
with g:Object
+	{
+		/* if (!ls)
+			g.lineStyle(0, 0, 0);
+		else
+			ls.apply(g,null,null); */
+	}
+	
+	/**
+	 *  Fill a rectangle using the provided IFill and IStroke objects.
+	 *  This utility function fills the provided rectangle in the Graphics object
+	 *  with the provided Fill and Stroke. If no Stroke is provided, the rectangle is filled
+	 *  with no border. If no Fill is provided, the rectangle is drawn with no fill.
+	 *
+	 * 	@param g The Graphics object to draw into.
+	 *	@param left The left of the rectangle to fill.
+	 *	@param top The top of the rectangle to fill.
+	 *	@param right The right of the rectangle to fill.
+	 *	@param bottom The bottom of the rectangle to fill.
+	 *	@param fill The IFill object to fill the rectangle with. Set this parameter to null to
draw a rectangle with no Fill.
+	 *	@param ls The stroke object to draw the rectangle with. Set this parameter to null to
draw a rectangle with no Stroke.
+	 *  
+	 *  @langversion 3.0
+	 *  @playerversion Flash 9
+	 *  @playerversion AIR 1.1
+	 *  @productversion Royale 0.9.3
+	 */
+	/* public static function fillRect(g:Graphics, left:Number, top:Number,
+									right:Number, bottom:Number,
+									fill:Object = null, ls:Object = null):void
+	{
+		var fillIsColor:Boolean;		
+		
+		g.moveTo(left, top);
+
+		if (fill != null)
+		{
+			if (fill is IFill)
+			{
+				fillIsColor = false;
+				fill.begin(g,
+					new Rectangle(left, top, right - left, bottom - top),null);
+			}
+			else
+			{
+				fillIsColor = true;
+				g.beginFill(uint(fill));
+			}
+		}
+
+		if (ls != null)
+			ls.apply(g,null,null);
+		
+		g.lineTo(right, top);
+		g.lineTo(right, bottom);
+		g.lineTo(left, bottom);
+		g.lineTo(left, top);
+
+		if (fill != null)
+			g.endFill();
+	} */
+
+	/**
+	 *  @private
+	 */
+	/* private static function convertForm(v:Object):Number
+	{
+		if (typeof(v) == "number")
+		{
+			return Number(v);
+		}
+		else
+		{
+			switch (v)
+			{
+				case "segment":
+				default:
+				{
+					return LINE_FORM.segment;
+				}
+
+				case "curve":
+				{
+					return LINE_FORM.curve;
+				}
+
+				case "step":
+				{
+					return LINE_FORM.step;
+				}
+
+				case "horizontal":
+				{
+					return LINE_FORM.horizontal;
+				}
+
+				case "vertical":
+				{
+					return LINE_FORM.vertical;
+				}
+
+				case "reverseStep":
+				{
+					return LINE_FORM.reverseStep;
+				}
+			}
+		}
+		return NaN;			
+	} */
+
+	/**
+	 *  Draws a line connecting the datapoints using one of various forms.  
+	 *	@param	g     The Graphics object to draw into.
+	 *	@param	pts   An Array of datapoints that define the line.
+	 *	@param	start The index of the first point in the <code>pts</code> Array to
use when drawing the line.
+	 *	@param	end   The index of the last point, exclusive, to use when drawing the line.
+	 *	@param	hProp The name of the property in the objects contained in the <code>pts</code>
Array that defines the horizontal position of the points in the line.
+	 *	@param 	vProp The name of the property in the objects contained in the <code>pts</code>
Array that defines the vertical position of the points in the line.
+	 *	@param	stroke The Stroke used to render the line.
+	 *	@param	form  The form to render the line with. Valid values are "segment","horizontal","vertical","step","reverseStep",
or "curve". These forms are similar to the LineSeries class's <code>form</code>
property.
+	 *	@param	moveToStart Indicates whether to first move the pen to the beginning of the line
before drawing. Pass <code>false</code> to use this function to continue a line
in progress.
+ 	 *  
+ 	 *  @langversion 3.0
+ 	 *  @playerversion Flash 9
+ 	 *  @playerversion AIR 1.1
+ 	 *  @productversion Royale 0.9.3
+ 	 */
+	// public static function drawPolyLine(g:Graphics, pts:Array /* of Object */,
+										 // start:int, end:int,
+										 // hProp:String, vProp:String,
+										 // stroke:IStroke, form:Object,
+										 // moveToStart:Boolean = true):void
+	/*  {
+		if (start == end)
+			return;
+
+		var originalStart:int = start;
+		
+		form = convertForm(form);
+		
+		if (stroke)
+			stroke.apply(g,null,null);
+		
+		var len:Number;
+		var incr:int;
+		var i:int;
+		var w:Number;
+		var c:Number;
+		var a:Number;
+		
+		var reverse:Boolean = start > end;
+		
+		if (reverse)
+			incr = -1;
+		else
+			incr = 1;
+		
+		if (moveToStart)
+			g.moveTo(pts[start][hProp], pts[start][vProp]);
+		else
+			g.lineTo(pts[start][hProp], pts[start][vProp]);
+
+		start += incr;
+			
+		if (form == LINE_FORM.segment)
+		{
+			for (i = start; i != end;i += incr)
+			{
+				g.lineTo(pts[i][hProp], pts[i][vProp]);
+			}
+		}
+
+		else if (form == LINE_FORM.step)
+		{			
+			for (i = start; i != end; i += incr)
+			{
+				g.lineTo(pts[i][hProp], pts[i - incr][vProp]);
+				g.lineTo(pts[i][hProp], pts[i][vProp]);
+			}
+		}
+
+		else if (form == LINE_FORM.reverseStep)
+		{
+			for (i = start; i != end; i += incr)
+			{
+				g.lineTo(pts[i - incr][hProp], pts[i][vProp]);
+				g.lineTo(pts[i][hProp], pts[i][vProp]);
+			}
+		}
+
+		else if (form == LINE_FORM.horizontal)
+		{
+			if (reverse)
+			{
+				for (i = start; i != end; i += incr)
+				{
+					g.lineStyle(0, 0, 0);
+					g.lineTo(pts[i - incr][hProp], pts[i][vProp]);
+					if (stroke)
+						stroke.apply(g,null,null);
+					g.lineTo(pts[i][hProp], pts[i][vProp]);
+				}
+			}
+			else
+			{
+				for (i = start; i != end; i += incr)
+				{
+					g.lineStyle(0, 0, 0);
+					g.lineTo(pts[i - incr][hProp], pts[i - incr][vProp]);
+					if (stroke)
+						stroke.apply(g,null,null);
+					g.lineTo(pts[i][hProp], pts[i - incr][vProp]);
+				}
+			}
+		}
+
+		else if (form == LINE_FORM.vertical)
+		{
+			if (reverse)
+			{
+				for (i = start; i != end; i += incr)
+				{
+
+					g.lineStyle(0, 0, 0);
+					g.lineTo(pts[i - incr][hProp], pts[i][vProp]);
+					if (stroke)
+						stroke.apply(g,null,null);
+					g.lineTo(pts[i][hProp], pts[i][vProp]);
+				}
+			}
+			else
+			{
+				for (i = start; i != end; i += incr)
+				{
+					g.lineStyle(0, 0, 0);
+					g.lineTo(pts[i][hProp], pts[i - incr][vProp]);
+					if (stroke)
+						stroke.apply(g,null,null);
+					g.lineTo(pts[i][hProp], pts[i][vProp]);
+				}
+			}
+		}
+
+		else if (form == LINE_FORM.curve)
+		{
+			start = originalStart;
+			var innerEnd:int = end - incr;
+
+			// Check for coincident points at the head of the list.
+			// We'll skip over any of those			
+			while (start != end && ((start + incr) != end))
+			{
+				if (pts[start + incr][hProp] != pts[start][hProp] ||
+					pts[start + incr][vProp] != pts[start][vProp])
+				{
+					break;
+				}
+				start += incr;
+			}
+			if (start == end || start + incr == end)
+				return;
+				
+			if (Math.abs(end - start) == 2)
+			{
+				g.lineTo(pts[start + incr][hProp], pts[start + incr][vProp]);
+				return;
+			}
+
+			var tanLeft:Point = new Point();
+			var tanRight:Point = new Point();
+			var tangentLengthPercent:Number = 0.25;
+			
+			if (reverse)
+				tangentLengthPercent *= -1;
+			
+			var j:int= start;
+			
+			// First, find the normalized vector
+			// from the 0th point TO the 1st point
+			var v1:Point = new Point();
+			var v2:Point = new Point(pts[j + incr][hProp] - pts[j][hProp],
+									 pts[j + incr][vProp] - pts[j][vProp]);
+			var tan:Point = new Point();
+			var p1:Point = new Point();
+			var p2:Point = new Point();
+			var mp:Point = new Point();
+			
+			len = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
+			v2.x /= len;
+			v2.y /= len;
+			
+			// Now later on we'll be using the tangent to the curve
+			// to define the control point.
+			// But since we're at the end, we don't have a tangent.
+			// Instead, we'll just use the first segment itself as the tangent.
+			// The effect will be that the first curve will start along the
+			// polyline.
+			// Now extend the tangent to get a control point.
+			// The control point is expressed as a percentage
+			// of the horizontal distance beteen the two points.
+			var tanLenFactor:Number = pts[j + incr][hProp] - pts[j][hProp];
+			
+			var prevNonCoincidentPt:Object = pts[j];
+			
+			// Here's the basic idea.
+			// On any given iteration of this loop, we're going to draw the
+			// segment of the curve from the nth-1 sample to the nth sample.
+			// To do that, we're going to compute the 'tangent' of the curve
+			// at the two samples.
+			// We'll use these two tangents to find two control points
+			// between the two samples.
+			// Each control point is W pixels along the tangent at the sample,
+			// where W is some percentage of the horizontal distance
+			// between the samples.
+			// We then take the two control points, and find the midpoint
+			// of the line between them.
+			// Then we're ready to draw.
+			// We draw two quadratic beziers, one from sample N-1
+			// to the midpoint, with control point N-1, and one
+			// from the midpoint to sample N, with the control point N.
+			
+			for (j += incr; j != innerEnd; j += incr)
+			{
+				// Check and see if the next point is coincident.
+				// If it is, we'll skip forward.
+				if (pts[j + incr][hProp] == pts[j][hProp] &&
+				    pts[j + incr][vProp] == pts[j][vProp])
+				{
+					continue;
+				}
+					 
+				// v1 is the normalized vector from the nth point
+				// to the nth-1 point.
+				// Since we already computed from nth-1 to nth,
+				// we can just invert it.
+				v1.x = -v2.x
+				v1.y = -v2.y;
+				
+				// Now compute the normalized vector from nth to nth+1. 
+				v2.x = pts[j + incr][hProp] - pts[j][hProp];
+				v2.y = pts[j + incr][vProp] - pts[j][vProp];
+				
+				len = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
+				v2.x /= len;
+				v2.y /= len;
+				
+				// Now compute the 'tangent' of the C1 curve
+				// formed by the two vectors.
+				// Since they're normalized, that's easy to find...
+				// It's the vector that runs between the two endpoints.
+				// We normalize it, as well.
+				tan.x = v2.x - v1.x;
+				tan.y = v2.y - v1.y;
+				var tanlen:Number = Math.sqrt(tan.x * tan.x + tan.y * tan.y);
+				tan.x /= tanlen;
+				tan.y /= tanlen;
+
+				// Optionally, if the vertical direction of the curve
+				// reverses itself, we'll pin the tangent to be  horizontal.
+				// This works well for typical, well spaced chart lines,
+				// not so well for arbitrary curves.
+				if (v1.y * v2.y >= 0)
+					tan = new Point(1, 0);
+
+				// Find the scaled tangent we'll use
+				// to calculate the control point.
+				tanLeft.x = -tan.x * tanLenFactor * tangentLengthPercent;
+				tanLeft.y = -tan.y * tanLenFactor * tangentLengthPercent;
+
+				if (j == (incr+start))
+				{
+					// The first segment starts along the polyline,
+					// so we only draw a single quadratic.
+//					g.moveTo(pts[j - incr].x, pts[j - incr].y);
+					g.curveTo(pts[j][hProp] + tanLeft.x,
+							  pts[j][vProp] + tanLeft.y,
+							  pts[j][hProp],
+							  pts[j][vProp]);
+				}
+				else
+				{
+					// Determine the two control points...
+					p1.x = prevNonCoincidentPt[hProp] + tanRight.x;
+					p1.y = prevNonCoincidentPt[vProp] + tanRight.y;
+					
+					p2.x = pts[j][hProp] + tanLeft.x;
+					p2.y = pts[j][vProp] + tanLeft.y;
+					
+					// and the midpoint of the line between them.
+					mp.x = (p1.x+p2.x)/2
+					mp.y = (p1.y+p2.y)/2;
+					
+					// Now draw our two quadratics.
+					g.curveTo(p1.x, p1.y, mp.x, mp.y);
+					g.curveTo(p2.x, p2.y, pts[j][hProp], pts[j][vProp]);
+					
+				}
+
+				// We're about to move on to the nth to the nth+1 segment
+				// of the curve...so let's flip the tangent at n,
+				// and scale it for the horizontal distance from n to n+1.
+				tanLenFactor = pts[j + incr][hProp] - pts[j][hProp];
+				tanRight.x = tan.x * tanLenFactor * tangentLengthPercent;
+				tanRight.y = tan.y * tanLenFactor * tangentLengthPercent;
+				prevNonCoincidentPt = pts[j];
+			}
+
+			// Now in theory we're going to draw our last curve,
+			// which, like the first, is only a single quadratic,
+			// ending at the last sample.
+			// If we try and draw two curves back to back, in reverse order,
+			// they don't quite match.
+			// I'm not sure whether this is expected, based on the definition
+			// of a quadratic bezier, or a bug in the player.
+			// Regardless, to work around this, we'll draw the last segment
+			// backwards.
+			g.curveTo(prevNonCoincidentPt[hProp] + tanRight.x,
+					  prevNonCoincidentPt[vProp] + tanRight.y,
+					  pts[j][hProp], pts[j][vProp]);
+
+		}
+	} */
+	
+
+	/**
+	 *  Draws an arc in the target Graphics object.  
+	 *	@param	g	The Graphics object to draw into.
+	 *	@param	x	The horizontal origin of the arc.
+	 *	@param	y	The vertical origin of the arc.
+	 *	@param	startAngle	The starting angle, in radians, of the arc.
+	 *	@param	arc	The sweep, in radians, of the arc.
+	 *	@param	radius  The horizontal radius, in pixels, of the arc
+	 *	@param	yRadius The vertical radius, in pixels, of the arc. If unspecified, it is assumed
to be the same as the radius
+	 *	@param	continueFlag Indicates whether the routine should move the graphics pen to the
beginning of the arc before drawing.
+	 *  Set to <code>true</code> to continue drawing a line that is already in progress.
+	 *  
+	 *  @langversion 3.0
+	 *  @playerversion Flash 9
+	 *  @playerversion AIR 1.1
+	 *  @productversion Royale 0.9.3
+	 */
+	public static function drawArc(g:Object, x:Number, y:Number,
+								  startAngle:Number, arc:Number,
+								  radius:Number, yRadius:Number = NaN,
+								  continueFlag:Boolean = false):void //g:Graphics is replaced with g:Object
+	{
+		
+		/* if (isNaN(yRadius))
+			yRadius = radius;
+
+		var segAngle:Number
+		var theta:Number
+		var angle:Number
+		var angleMid:Number
+		var segs:Number
+		var ax:Number
+		var ay:Number
+		var bx:Number
+		var by:Number
+		var cx:Number
+		var cy:Number;
+		
+		if (Math.abs(arc) > 2 * Math.PI)
+			arc = 2 * Math.PI;
+
+		segs = Math.ceil(Math.abs(arc) / (Math.PI / 4));
+		segAngle = arc / segs;
+		theta = -segAngle;
+		angle = -startAngle;
+		
+		if (segs > 0)
+		{
+			ax = x + Math.cos(startAngle) * radius;
+			ay = y + Math.sin(-startAngle) * yRadius;
+			
+			if (continueFlag == true)
+				g.lineTo(ax, ay);
+			else
+				g.moveTo(ax, ay);
+			
+			for (var i:uint = 0; i < segs; i++)
+			{
+				angle += theta;
+				angleMid = angle - theta / 2;
+				
+				bx = x + Math.cos(angle) * radius;
+				by = y + Math.sin(angle) * yRadius;
+				cx = x + Math.cos(angleMid) * (radius / Math.cos(theta / 2));
+				cy = y + Math.sin(angleMid) * (yRadius / Math.cos(theta / 2));
+				
+				g.curveTo(cx, cy, bx, by);
+			}
+		} */
+	}
+	
+	/**
+	 *  Converts a style value into a Fill object. This convenience method converts a value
assigned through styles into a Fill object
+	 *	that can be used to fill an area on the screen. If the value is numeric, this function
converts it into a corresponding SolidColor.
+	 *	@param	v	The value to convert into a Fill.
+	 *	@return The corresponding IFill object.
+	 *  
+	 *  @langversion 3.0
+	 *  @playerversion Flash 9
+	 *  @playerversion AIR 1.1
+	 *  @productversion Royale 0.9.3
+	 */
+	/* public static function fillFromStyle(v:Object):IFill
+	{		
+		if (v is IFill)
+			return IFill(v);
+
+		else if (v != null)
+			return IFill(new SolidColor(uint(v)));
+
+		else
+			return null;		
+	} */
+
+	/**
+	 *  Converts a fill value into a solid color. This convenience method pulls a color value
out of a Fill
+	 *	that best approximates the Fill on the screen.
+	 *	@param	f	The Fill object to extract a color from.
+	 *	@return A color value representing the Fill.
+	 *  
+	 *  @langversion 3.0
+	 *  @playerversion Flash 9
+	 *  @playerversion AIR 1.1
+	 *  @productversion Royale 0.9.3
+	 */
+	/* public static function colorFromFill(f:Object):uint
+	{
+		var color:uint;
+
+		if (f == null)
+		{
+		}
+		else if (f is SolidColor)
+		{
+			color = SolidColor(f).color;
+		}
+		else if (f is LinearGradient &&
+				 LinearGradient(f).entries.length > 0)
+		{
+			color = LinearGradient(f).entries[0].color;
+		}
+		else if (f is RadialGradient &&
+				 RadialGradient(f).entries.length > 0)
+		{
+			color = RadialGradient(f).entries[0].color;
+		}
+		else if (f is Number || f is uint || f is int)
+		{
+			color = uint(f);
+		}
+
+		return color;
+	} */
+}
+
+}

-- 
To stop receiving notification emails like this one, please contact
alinakazi@apache.org.

Mime
View raw message