1 files changed, 577 insertions, 0 deletions
diff --git a/mcs/class/System.Drawing/System.Drawing/Pen.jvm.cs b/mcs/class/System.Drawing/System.Drawing/Pen.jvm.cs
new file mode 100755
index 00000000000..0536b9cb03b
--- /dev/null
+++ b/mcs/class/System.Drawing/System.Drawing/Pen.jvm.cs
@@ -0,0 +1,577 @@
+//
+// System.Drawing.Pen.cs
+//
+// Authors:
+//   Miguel de Icaza (miguel@ximian.com)
+//   Alexandre Pigolkine (pigolkine@gmx.de)
+//   Duncan Mak (duncan@ximian.com)
+//   Ravindra (rkumar@novell.com)
+//
+// (C) Ximian, Inc.  http://www.ximian.com
+// (C) Novell, Inc.  http://www.novell.com
+//
+
+using System;
+using System.Drawing.Drawing2D;
+using System.Runtime.InteropServices;
+
+using awt = java.awt;
+using geom = java.awt.geom;
+
+namespace System.Drawing 
+{
+
+	public sealed class Pen : MarshalByRefObject, ICloneable, IDisposable, awt.Stroke
+	{
+		#region Member Vars
+
+		static readonly float [] DASH_ARRAY = {4.0f,1.0f};
+		static readonly float [] DASHDOT_ARRAY = {4.0f,1.0f,1.0f,1.0f};
+		static readonly float [] DASHDOTDOT_ARRAY = {4.0f,1.0f,1.0f,1.0f,1.0f,1.0f};
+		static readonly float [] DOT_ARRAY = {1.0f,1.0f};
+
+		internal bool isModifiable = true;
+
+		Brush _brush;
+		DashStyle _dashStyle;
+		DashCap _dashCap;
+		LineCap _startCap;
+		LineCap _endCap;
+
+		LineJoin _lineJoin;
+
+		PenAlignment _alignment;
+		Matrix _transform;
+		float _width;
+		float _dashOffset;
+		float[] _dashPattern;
+		//float[] _compoundArray;
+
+		float _miterLimit;
+
+		#endregion
+
+		#region Ctors. and Dtor
+
+		public Pen (Brush brush) : this (brush, 1.0F)
+		{}
+
+		public Pen (Color color) : this (color, 1.0F)
+		{}
+
+		public Pen (Color color, float width) : this(new SolidBrush(color), width)
+		{}
+
+		public Pen (Brush brush, float width)
+		{
+			_brush = (Brush)brush.Clone();;
+			_width = width;
+			_dashStyle = DashStyle.Solid;
+			_startCap = LineCap.Flat;
+			_dashCap = DashCap.Flat;
+			_endCap = LineCap.Flat;
+			_alignment = PenAlignment.Center;
+			_lineJoin = LineJoin.Miter;
+			_miterLimit = 10f;
+			_transform = new Matrix();
+		}
+		#endregion
+		//
+		// Properties
+		//
+		#region Alignment [TODO]
+		public PenAlignment Alignment 
+		{
+			get 
+			{
+				return _alignment;
+			}
+
+			set 
+			{
+				EnsureModifiable();
+				_alignment = value;
+			}
+		}
+		#endregion
+
+		#region Brush
+		public Brush Brush 
+		{
+			get 
+			{
+				return _brush;
+			}
+
+			set 
+			{
+				EnsureModifiable();
+				if (value == null)
+					throw new ArgumentNullException("brush");
+				_brush = value;
+			}
+		}
+		#endregion
+
+		#region Color
+		public Color Color 
+		{
+			get 
+			{
+				if(Brush is SolidBrush)
+					return ((SolidBrush)Brush).Color;
+				else if(Brush is HatchBrush)
+					return ((HatchBrush)Brush).ForegroundColor;
+				else
+					return Color.Empty;
+			}
+
+			set 
+			{
+				EnsureModifiable();
+				_brush = new SolidBrush (value);
+			}
+		}
+		#endregion 
+
+		#region CompoundArray [TODO]
+		[MonoTODO]
+		public float[] CompoundArray {
+			get {
+				throw new NotImplementedException ();
+			}
+			set {
+				throw new NotImplementedException ();
+			}
+		}
+		#endregion
+            
+		#region CustomEndCap [TODO]
+		[MonoTODO]
+		public CustomLineCap CustomEndCap 
+		{
+			get 
+			{
+				throw new NotImplementedException ();
+			}
+			// do a check for isModifiable when implementing this property
+			set 
+			{
+				throw new NotImplementedException ();                                
+			}
+		}
+		#endregion 
+
+		#region CustomStartCap [TODO]
+		[MonoTODO]
+		public CustomLineCap CustomStartCap 
+		{
+			get 
+			{
+				throw new NotImplementedException ();                                
+			}
+
+			// do a check for isModifiable when implementing this property
+			set 
+			{
+				throw new NotImplementedException ();                                
+			}
+		}
+		#endregion
+
+		#region DashCap
+		[MonoTODO]
+		public DashCap DashCap {
+			get {
+				return _dashCap;
+			}
+
+			set {
+				EnsureModifiable();
+				_dashCap = value;
+			}
+		}
+		#endregion
+
+		#region DashOffset
+		public float DashOffset 
+		{
+
+			get 
+			{
+				return _dashOffset;
+			}
+
+			set 
+			{
+				EnsureModifiable();
+				_dashOffset = value;
+			}
+		}
+		#endregion
+
+		#region DashPattern
+
+		public float [] DashPattern 
+		{
+			get 
+			{
+				return (float [])_dashPattern.Clone();
+			}
+
+			set 
+			{
+				EnsureModifiable();
+
+				_dashPattern = value;
+				DashStyle = (_dashPattern == null) ? DashStyle.Solid : DashStyle.Custom;
+			}
+		}
+		#endregion
+
+		#region DashStyle
+		public DashStyle DashStyle 
+		{
+			get 
+			{
+				return _dashStyle;
+			}
+
+			set 
+			{
+				EnsureModifiable();
+				_dashStyle = value;
+			}
+		}
+		#endregion 
+
+		#region StartCap [TODO - now allways endcap]
+		[MonoTODO]
+		public LineCap StartCap {
+			get { 
+				return _startCap;
+			}
+
+			set {
+				EnsureModifiable();
+				_startCap = value;
+			}
+		}
+		#endregion
+
+		#region EndCap 
+		[MonoTODO]
+		public LineCap EndCap 
+		{
+			get 
+			{
+				return _endCap;
+			}
+
+			set 
+			{
+				EnsureModifiable();
+
+				_endCap = value;
+			}
+		}
+		#endregion
+ 
+		#region LineJoin [partial TODO - missed styles]
+		[MonoTODO]
+		public LineJoin LineJoin {
+			get {
+				return _lineJoin;
+			}
+
+			set {
+				EnsureModifiable();
+				_lineJoin = value;
+			}
+		}
+
+		#endregion
+
+		#region MiterLimit 
+		public float MiterLimit 
+		{
+
+			get 
+			{
+				return _miterLimit;
+			}
+
+			set 
+			{
+				EnsureModifiable();
+
+				_miterLimit = value;			
+			}
+	                    
+		}
+		#endregion
+
+		#region PenType
+		public PenType PenType 
+		{
+			get 
+			{
+				if (Brush is TextureBrush)
+					return PenType.TextureFill;
+				else if (Brush is HatchBrush)
+					return PenType.HatchFill;
+				else if (Brush is LinearGradientBrush)
+					return PenType.LinearGradient;
+				else if (Brush is PathGradientBrush)
+					return PenType.PathGradient;
+				else
+					return PenType.SolidColor;
+			}
+		}
+		#endregion
+
+		#region Transform
+		public Matrix Transform 
+		{
+			get 
+			{
+				return _transform.Clone();
+			}
+					
+			set 
+			{
+				EnsureModifiable();
+
+				value.CopyTo(_transform);
+			}
+		}
+		#endregion
+
+		#region Width
+		public float Width 
+		{
+			get 
+			{
+				return _width;
+			}
+			set 
+			{
+				EnsureModifiable();
+												
+				_width = value;
+			}
+		}
+		#endregion
+
+		#region Clone
+		public object Clone ()
+		{
+			Pen clone = (Pen)MemberwiseClone();
+			if (clone._transform != null)
+				clone._transform = clone._transform.Clone();
+			if (clone._dashPattern != null)
+				clone._dashPattern = (float[])clone._dashPattern.Clone();
+			return clone;
+		}
+		#endregion
+
+		#region Dispose 
+		public void Dispose ()
+		{
+			Dispose (true);
+		}
+		void Dispose (bool disposing)
+		{
+			if (!isModifiable && disposing)
+				throw new ArgumentException ("You may not change this Pen because it does not belong to you.");
+			// Restore the dtor if adding anything below
+		}
+		#endregion
+
+		#region Transform Funcs
+		public void MultiplyTransform (Matrix matrix)
+		{
+			_transform.Multiply (matrix);
+		}
+
+		public void MultiplyTransform (Matrix matrix, MatrixOrder order)
+		{
+			_transform.Multiply (matrix, order);
+		}
+
+		public void ResetTransform ()
+		{
+			_transform.Reset ();
+		}
+
+		public void RotateTransform (float angle)
+		{
+			_transform.Rotate (angle);
+		}
+
+		public void RotateTransform (float angle, MatrixOrder order)
+		{
+			_transform.Rotate (angle, order);
+		}
+
+		public void ScaleTransform (float sx, float sy)
+		{
+			_transform.Scale (sx, sy);
+		}
+
+		public void ScaleTransform (float sx, float sy, MatrixOrder order)
+		{
+			_transform.Scale (sx, sy, order);
+		}
+
+		public void TranslateTransform (float dx, float dy) {
+			_transform.Translate (dx, dy);
+		}
+
+		public void TranslateTransform (float dx, float dy, MatrixOrder order) {
+			_transform.Translate (dx, dy, order);
+		}
+		#endregion
+
+		public void SetLineCap (LineCap startCap, LineCap endCap, DashCap dashCap)
+		{
+			StartCap = startCap;
+			DashCap = dashCap;
+			EndCap = endCap;
+		}
+
+		void EnsureModifiable() {
+			if (!isModifiable)
+				throw new ArgumentException ("You may not change this Pen because it does not belong to you.");
+		}
+
+		internal double GetSquaredTransformedWidth(geom.AffineTransform coordsTransform) {
+			geom.AffineTransform transform = _transform.NativeObject;
+			double A = transform.getScaleX();	// m00
+			double B = transform.getShearY();	// m10
+			double C = transform.getShearX();	// m01
+			double D = transform.getScaleY();	// m11
+
+			double K = coordsTransform.getScaleX();	// m00
+			double L = coordsTransform.getShearY();	// m10
+			double M = coordsTransform.getShearX();	// m01
+			double N = coordsTransform.getScaleY();	// m11
+
+			double AD = A*D, BC = B*C, KN = K*N, LM = L*M;
+			double KN_LM = KN-LM;
+			return Math.Abs(Width*Width * (AD*KN_LM - BC*KN_LM));
+		}
+
+		
+		internal bool CanCreateBasicStroke {
+			get {
+				if (!_transform.IsIdentity)
+					return false;
+
+				//FIXME: add more logic when more features will
+				// be implemented.
+				return true;
+			}
+		}
+
+		internal awt.Stroke GetNativeObject(geom.AffineTransform outputTransform, PenFit penFit) {
+			return GetNativeObject(null, outputTransform, penFit);
+		}
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="outputTransform">transform which will be applied on the final shape</param>
+		/// <param name="fitPen">ensure the shape will wide enough to be visible</param>
+		/// <returns></returns>
+		internal awt.Stroke GetNativeObject(geom.AffineTransform penTransform, geom.AffineTransform outputTransform, PenFit penFit) {
+			float[] dashPattern = null;
+
+			switch (DashStyle) {
+				case DashStyle.Custom:
+					if (_dashPattern != null) {
+						dashPattern = new float[_dashPattern.Length];
+						for(int i = 0; i < _dashPattern.Length; i++) {
+
+							if (EndCap == LineCap.Flat)
+								dashPattern[i] = _dashPattern[i] * Width;
+							else {
+								if ((i & 1) == 0) {
+									// remove the size of caps from the opaque parts
+									dashPattern[i] = (_dashPattern[i] * Width) - Width;
+									if (_dashPattern[i] < 0)
+										dashPattern[i] = 0;
+								}
+								else
+									// add the size of caps to the transparent parts
+									dashPattern[i] = (_dashPattern[i] * Width) + Width;
+							}
+						}
+					}
+					break;
+				case DashStyle.Dash:
+					dashPattern = DASH_ARRAY;
+					break;
+				case DashStyle.DashDot:
+					dashPattern = DASHDOT_ARRAY;
+					break;
+				case DashStyle.DashDotDot:
+					dashPattern = DASHDOTDOT_ARRAY;
+					break;
+				
+					//				default:
+					//				case DashStyle.Solid:
+					//					break;
+			}
+
+			int join;
+			switch (LineJoin) {
+				case LineJoin.Bevel:
+					join = java.awt.BasicStroke.JOIN_BEVEL;
+					break;
+				default:
+				case LineJoin.Miter:
+				case LineJoin.MiterClipped:
+					join = java.awt.BasicStroke.JOIN_MITER;
+					break;
+				case LineJoin.Round:
+					join = java.awt.BasicStroke.JOIN_ROUND;
+					break;
+			}
+
+			// We go by End cap for now.
+			int cap;
+			switch (EndCap) {
+				default:
+				case LineCap.Square:
+				case LineCap.SquareAnchor:
+					cap = awt.BasicStroke.CAP_SQUARE;
+					break;
+				case LineCap.Round: 
+				case LineCap.RoundAnchor:
+					cap = awt.BasicStroke.CAP_ROUND;
+					break;
+				case LineCap.Flat:
+					cap = awt.BasicStroke.CAP_BUTT;
+					break;
+			}
+
+			geom.AffineTransform penT = _transform.NativeObject;
+			if (penTransform != null && !penTransform.isIdentity()) {
+				penT = (geom.AffineTransform)penT.clone();
+				penT.concatenate(penTransform);
+			}
+
+			return StrokeFactory.CreateStroke(Width, cap, 
+				join, MiterLimit, dashPattern, DashOffset,
+				penT, outputTransform, penFit);
+		}
+
+		#region Stroke Members
+
+		awt.Shape awt.Stroke.createStrokedShape(awt.Shape arg_0) {
+			return GetNativeObject(null, PenFit.NotThin).createStrokedShape(arg_0);
+		}
+
+		#endregion
+	}
+}