HatchTests

src/ACadSharp.Tests/Entities/HatchTests.cs

@@ -0,0 +1,117 @@
+using ACadSharp.Entities;
+using CSMath;
+using CSUtilities.Extensions;
+using System;
+using System.Collections.Generic;
+using Xunit;
+
+namespace ACadSharp.Tests.Entities
+{
+	public class HatchTests
+	{
+		[Fact]
+		public void CreateHatch()
+		{
+			Hatch hatch = new Hatch();
+			hatch.IsSolid = true;
+
+			hatch.SeedPoints.Add(new XY());
+
+			List<Hatch.BoundaryPath.Line> edges = new List<Hatch.BoundaryPath.Line>();
+
+			//edges
+			Hatch.BoundaryPath.Line edge1 = new Hatch.BoundaryPath.Line
+			{
+				Start = new CSMath.XY(0, 0),
+				End = new CSMath.XY(1, 0)
+			};
+			edges.Add(edge1);
+
+			Hatch.BoundaryPath.Line edge2 = new Hatch.BoundaryPath.Line
+			{
+				Start = new CSMath.XY(1, 0),
+				End = new CSMath.XY(1, 1)
+			};
+			edges.Add(edge2);
+
+			Hatch.BoundaryPath.Line edge3 = new Hatch.BoundaryPath.Line
+			{
+				Start = new CSMath.XY(1, 1),
+				End = new CSMath.XY(0, 1)
+			};
+			edges.Add(edge3);
+
+			Hatch.BoundaryPath.Line edge4 = new Hatch.BoundaryPath.Line
+			{
+				Start = new CSMath.XY(0, 1),
+				End = new CSMath.XY(0, 0)
+			};
+			edges.Add(edge4);
+
+
+			Hatch.BoundaryPath path = new Hatch.BoundaryPath();
+			foreach (var item in edges)
+			{
+				path.Edges.Add(item);
+			}
+
+			hatch.Paths.Add(path);
+
+			Assert.NotEmpty(hatch.Paths);
+			Assert.NotEmpty(path.Edges);
+			Assert.False(path.IsPolyline);
+		}
+
+		[Fact]
+		public void CreatePolylineHatch()
+		{
+			Hatch hatch = new Hatch();
+			hatch.IsSolid = true;
+
+			Hatch.BoundaryPath path = new Hatch.BoundaryPath();
+
+			Hatch.BoundaryPath.Polyline pline = new Hatch.BoundaryPath.Polyline();
+			pline.Vertices.Add(new XYZ(0, 0, 0));
+			pline.Vertices.Add(new XYZ(1, 0, 0));
+			pline.Vertices.Add(new XYZ(1, 1, 0));
+			pline.Vertices.Add(new XYZ(0, 1, 0));
+			pline.Vertices.Add(new XYZ(0, 0, 0));
+
+			path.Edges.Add(pline);
+			path.Flags = path.Flags.AddFlag(BoundaryPathFlags.Polyline);
+			hatch.Paths.Add(path);
+
+			Assert.True(path.IsPolyline);
+		}
+
+		[Fact]
+		public void PolylineHatchNotAllowMoreEdges()
+		{
+			Hatch hatch = new Hatch();
+			hatch.IsSolid = true;
+
+			Hatch.BoundaryPath path = new Hatch.BoundaryPath();
+
+			Hatch.BoundaryPath.Polyline pline = new Hatch.BoundaryPath.Polyline();
+			pline.Vertices.Add(new XYZ(0, 0, 0));
+			pline.Vertices.Add(new XYZ(1, 0, 0));
+			pline.Vertices.Add(new XYZ(1, 1, 0));
+			pline.Vertices.Add(new XYZ(0, 1, 0));
+			pline.Vertices.Add(new XYZ(0, 0, 0));
+
+			path.Edges.Add(pline);
+
+			Assert.Throws<InvalidOperationException>(() =>
+			{
+				path.Edges.Add(new Hatch.BoundaryPath.Line());
+			}
+			);
+
+			Assert.Throws<InvalidOperationException>(() =>
+			{
+				path.Edges.Add(new Hatch.BoundaryPath.Polyline());
+			}
+			);
+		}
+	}
+}

src/ACadSharp.Tests/IO/WriterSingleObjectTests.cs

@@ -340,7 +340,11 @@ public void CreateHatch()
 
 
 				Hatch.BoundaryPath path = new Hatch.BoundaryPath();
-				path.Edges.AddRange(edges);
+				foreach (var item in edges)
+				{
+					path.Edges.Add(item);
+				}
+
 				hatch.Paths.Add(path);
 
 				this.Document.Entities.Add(hatch);

src/ACadSharp/CadDocument.cs

@@ -423,7 +423,7 @@ private void onRemove(object sender, CollectionChangedEventArgs e)
 			}
 		}
 
-		internal void RegisterCollection<T>(IObservableCollection<T> collection)
+		internal void RegisterCollection<T>(IObservableCadCollection<T> collection)
 			where T : CadObject
 		{
 			switch (collection)
@@ -498,7 +498,7 @@ internal void RegisterCollection<T>(IObservableCollection<T> collection)
 			}
 		}
 
-		internal void UnregisterCollection<T>(IObservableCollection<T> collection)
+		internal void UnregisterCollection<T>(IObservableCadCollection<T> collection)
 			where T : CadObject
 		{
 			switch (collection)

src/ACadSharp/CadObjectCollection.cs

@@ -6,7 +6,7 @@
 
 namespace ACadSharp
 {
-	public class CadObjectCollection<T> : IObservableCollection<T>
+	public class CadObjectCollection<T> : IObservableCadCollection<T>
 		where T : CadObject
 	{
 		public event EventHandler<CollectionChangedEventArgs> OnAdd;

src/ACadSharp/Entities/Hatch.BoundaryPath.cs

@@ -1,17 +1,42 @@
 using ACadSharp.Attributes;
+using CSUtilities.Extensions;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.Linq;
 
 namespace ACadSharp.Entities
 {
 	public partial class Hatch
 	{
 		public partial class BoundaryPath
 		{
+			public bool IsPolyline { get { return this.Edges.OfType<Polyline>().Any(); } }
+
 			/// <summary>
 			/// Boundary path type flag
 			/// </summary>
 			[DxfCodeValue(92)]
-			public BoundaryPathFlags Flags { get; set; }
+			public BoundaryPathFlags Flags
+			{
+				get
+				{
+					if (this.IsPolyline)
+					{
+						this._flags = this._flags.AddFlag(BoundaryPathFlags.Polyline);
+					}
+					else
+					{
+						this._flags = this._flags.RemoveFlag(BoundaryPathFlags.Polyline);
+					}
+
+					return this._flags;
+				}
+				set
+				{
+					this._flags = value;
+				}
+			}
 
 			/// <summary>
 			/// Number of edges in this boundary path
@@ -20,18 +45,54 @@ public partial class BoundaryPath
 			/// only if boundary is not a polyline
 			/// </remarks>
 			[DxfCodeValue(DxfReferenceType.Count, 93)]
-			public List<Edge> Edges { get; set; } = new List<Edge>();
+			public ObservableCollection<Edge> Edges { get; } = new();
 
 			/// <summary>
 			/// Source boundary objects
 			/// </summary>
 			[DxfCodeValue(DxfReferenceType.Count, 97)]
 			public List<Entity> Entities { get; set; } = new List<Entity>();
 
+			private BoundaryPathFlags _flags;
+
+			public BoundaryPath()
+			{
+				Edges.CollectionChanged += this.onEdgesCollectionChanged;
+			}
+
 			public BoundaryPath Clone()
 			{
 				throw new System.NotImplementedException();
 			}
+
+			private void onEdgesCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
+			{
+				switch (e.Action)
+				{
+					case System.Collections.Specialized.NotifyCollectionChangedAction.Add:
+						onAdd(e);
+						break;
+					case System.Collections.Specialized.NotifyCollectionChangedAction.Remove:
+						break;
+					case System.Collections.Specialized.NotifyCollectionChangedAction.Replace:
+						break;
+					case System.Collections.Specialized.NotifyCollectionChangedAction.Move:
+						break;
+					case System.Collections.Specialized.NotifyCollectionChangedAction.Reset:
+						break;
+				}
+			}
+
+			private void onAdd(NotifyCollectionChangedEventArgs e)
+			{
+				foreach (Edge edge in e.NewItems)
+				{
+					if (this.Edges.Count > 1 && this.IsPolyline)
+					{
+						throw new System.InvalidOperationException();
+					}
+				}
+			}
 		}
 	}
 }

src/ACadSharp/IObservableCollection.cs → src/ACadSharp/IObservableCadCollection.cs

@@ -3,7 +3,7 @@
 
 namespace ACadSharp
 {
-	public interface IObservableCollection<T> : IEnumerable<T>
+	public interface IObservableCadCollection<T> : IEnumerable<T>
 		where T : CadObject
 	{
 		/// <summary>

src/ACadSharp/Objects/CadDictionary.cs

@@ -16,7 +16,7 @@ namespace ACadSharp.Objects
 	/// </remarks>
 	[DxfName(DxfFileToken.ObjectDictionary)]
 	[DxfSubClass(DxfSubclassMarker.Dictionary)]
-	public class CadDictionary : NonGraphicalObject, IObservableCollection<NonGraphicalObject>
+	public class CadDictionary : NonGraphicalObject, IObservableCadCollection<NonGraphicalObject>
 	{
 		public event EventHandler<CollectionChangedEventArgs> OnAdd;
 		public event EventHandler<CollectionChangedEventArgs> OnRemove;

src/ACadSharp/Tables/Collections/Table.cs

@@ -8,7 +8,7 @@
 namespace ACadSharp.Tables.Collections
 {
 	[DxfSubClass(DxfSubclassMarker.Table)]
-	public abstract class Table<T> : CadObject, ITable, IObservableCollection<T>
+	public abstract class Table<T> : CadObject, ITable, IObservableCadCollection<T>
 		where T : TableEntry
 	{
 		public event EventHandler<CollectionChangedEventArgs> OnAdd;