Changeset 13045 for branches/HeuristicLab.Visualization/HeuristicLab.Visualization/3.3/Primitives/Group.cs

Timestamp:

10/21/15 14:18:31 (9 years ago)

Author:

jkarder

Message:

#1265: merged changes from abeham

File:

• branches/HeuristicLab.Visualization/HeuristicLab.Visualization/3.3/Primitives/Group.cs (modified) (7 diffs)

branches/HeuristicLab.Visualization/HeuristicLab.Visualization/3.3/Primitives/Group.cs

@@ -21 +21 @@
 
 using System;
+using System.Collections;
 using System.Collections.Generic;
-using System.Collections.ObjectModel;
 using System.Drawing;
 using System.Linq;
@@ -29 +29 @@
 namespace HeuristicLab.Visualization {
   public class Group : PrimitiveBase, IGroup {
-    private LinkedList<IPrimitive> myPrimitives;
-    private HashSet<IPrimitive> myPrimitivesLookup;
-    public virtual ReadOnlyCollection<IPrimitive> Primitives {
-      get { return new ReadOnlyCollection<IPrimitive>(new List<IPrimitive>(myPrimitives)); }
-    }
-    public virtual ReadOnlyCollection<IPrimitive> SelectedPrimitives {
-      get {
-        List<IPrimitive> selected = new List<IPrimitive>();
-        foreach (IPrimitive primitive in myPrimitives) {
-          if (primitive.Selected) selected.Add(primitive);
-        }
-        return new ReadOnlyCollection<IPrimitive>(selected);
-      }
-    }
+    private readonly LinkedList<IPrimitive> primitives;
+    private readonly HashSet<IPrimitive> primitivesLookup;
+
+    public virtual IEnumerable<IPrimitive> Primitives {
+      get { return primitives.ToArray(); }
+    }
+    public virtual IEnumerable<IPrimitive> SelectedPrimitives {
+      get { return primitives.Where(x => x.Selected).ToArray(); }
+    }
+
     public override bool Selected {
       get { return base.Selected; }
       set {
-        bool updateEnabled = UpdateEnabled;
-        UpdateEnabled = false;
-        foreach (IPrimitive primitive in myPrimitives)
-          primitive.Selected = value;
-        UpdateEnabled = updateEnabled;
-        base.Selected = value;
+        SuppressEvents = true;
+        try {
+          foreach (var primitive in primitives)
+            primitive.Selected = value;
+          base.Selected = value;
+        } finally {
+          SuppressEvents = false;
+          OnRedrawRequired();
+        }
       }
     }
@@ -57 +56 @@
     public Group(IChart chart)
       : base(chart) {
-      myPrimitives = new LinkedList<IPrimitive>();
-      myPrimitivesLookup = new HashSet<IPrimitive>();
+      primitives = new LinkedList<IPrimitive>();
+      primitivesLookup = new HashSet<IPrimitive>();
     }
 
     public virtual void Add(IPrimitive primitive) {
-      if (Contains(primitive))
-        throw new ArgumentException("Primitive already added");
-
-      myPrimitives.AddFirst(primitive);
-      myPrimitivesLookup.Add(primitive);
-      primitive.Group = this;
-      primitive.Update += new EventHandler(primitive_Update);
-      OnUpdate();
+      if (Contains(primitive)) throw new ArgumentException("Primitive already added");
+      primitives.AddFirst(primitive);
+      primitivesLookup.Add(primitive);
+      primitive.RedrawRequired += PrimitiveOnRedrawRequired;
+      OnRedrawRequired();
     }
     public virtual void AddRange(IEnumerable<IPrimitive> primitives) {
-      foreach (IPrimitive primitive in primitives) {
-        if (Contains(primitive))
-          throw new ArgumentException("Primitive already added");
-
-        myPrimitives.AddFirst(primitive);
-        myPrimitivesLookup.Add(primitive);
-        primitive.Group = this;
-        primitive.Update += new EventHandler(primitive_Update);
-      }
-      OnUpdate();
-    }
+      foreach (var primitive in this.primitives) {
+        if (Contains(primitive)) throw new ArgumentException("Primitive already added");
+        this.primitives.AddFirst(primitive);
+        primitivesLookup.Add(primitive);
+        primitive.RedrawRequired += PrimitiveOnRedrawRequired;
+      }
+      OnRedrawRequired();
+    }
+
     public virtual bool Contains(IPrimitive primitive) {
-      return myPrimitivesLookup.Contains(primitive);
-    }
+      return primitivesLookup.Contains(primitive);
+    }
+
     public virtual bool Remove(IPrimitive primitive) {
-      if (myPrimitives.Remove(primitive)) {
-        primitive.Group = null;
-        primitive.Update -= new EventHandler(primitive_Update);
-        OnUpdate();
-        return true;
-      } else {
-        return false;
-      }
-    }
+      if (!primitives.Remove(primitive)) return false;
+      primitivesLookup.Remove(primitive);
+
+      primitive.RedrawRequired -= PrimitiveOnRedrawRequired;
+      OnRedrawRequired();
+      return true;
+    }
+
     public virtual void Clear() {
-      foreach (IPrimitive primitive in myPrimitives) {
-        primitive.Group = null;
-        primitive.Update -= new EventHandler(primitive_Update);
-      }
-      myPrimitives.Clear();
-      myPrimitivesLookup.Clear();
-      OnUpdate();
+      foreach (var primitive in primitives) {
+        primitive.RedrawRequired -= PrimitiveOnRedrawRequired;
+      }
+      primitives.Clear();
+      primitivesLookup.Clear();
+      OnRedrawRequired();
     }
 
     public virtual IPrimitive GetPrimitive(PointD point) {
-      return myPrimitives.FirstOrDefault(primitive => primitive.ContainsPoint(point));
-    }
-
-    public IPrimitive GetPrimitive(double x, double y) {
-      return GetPrimitive(new PointD(x, y));
-    }
-    public virtual IList<IPrimitive> GetAllPrimitives(PointD point) {
-      var primitives = new List<IPrimitive>();
-      foreach (var primitive in myPrimitives.Where(primitive => primitive.ContainsPoint(point))) {
-        primitives.Add(primitive);
+      return primitives.FirstOrDefault(primitive => primitive.ContainsPoint(point));
+    }
+
+    public virtual IEnumerable<IPrimitive> GetAllPrimitives(PointD point) {
+      var result = new List<IPrimitive>();
+      foreach (var primitive in primitives.Where(primitive => primitive.ContainsPoint(point))) {
+        result.Add(primitive);
         var group = primitive as IGroup;
         if (group != null)
-          primitives.AddRange(group.Primitives);
-      }
-      return primitives;
-    }
-    public IList<IPrimitive> GetAllPrimitives(double x, double y) {
-      return GetAllPrimitives(new PointD(x, y));
+          result.AddRange(group.GetAllPrimitives(point));
+      }
+      return result;
     }
 
     public override void Move(Offset delta) {
-      bool updateEnabled = UpdateEnabled;
-      UpdateEnabled = false;
-      foreach (IPrimitive primitive in myPrimitives)
-        primitive.Move(delta);
-      UpdateEnabled = updateEnabled;
-      OnUpdate();
+      SuppressEvents = true;
+      try {
+        foreach (var primitive in primitives)
+          primitive.Move(delta);
+      } finally {
+        SuppressEvents = false;
+        OnRedrawRequired();
+      }
+    }
+
+    public override void Move(PointD point, Offset delta) {
+      SuppressEvents = true;
+      try {
+        foreach (var primitive in primitives)
+          primitive.Move(point, delta);
+      } finally {
+        SuppressEvents = false;
+        OnRedrawRequired();
+      }
+    }
+
+    public override void SnapToGrid(IGrid grid) {
+      SuppressEvents = true;
+      try {
+        foreach (var primitive in primitives)
+          primitive.SnapToGrid(grid);
+      } finally {
+        SuppressEvents = false;
+        OnRedrawRequired();
+      }
+    }
+
+    public override void SnapToGrid(PointD point, IGrid grid) {
+      SuppressEvents = true;
+      try {
+        foreach (var primitive in primitives)
+          primitive.SnapToGrid(point, grid);
+      } finally {
+        SuppressEvents = false;
+        OnRedrawRequired();
+      }
     }
 
@@ -141 +163 @@
 
     public override Cursor GetCursor(PointD point) {
-      IPrimitive primitive = GetPrimitive(point);
-      if (primitive != null) return primitive.GetCursor(point);
-      else return base.GetCursor(point);
-    }
+      var primitive = GetPrimitive(point);
+      return primitive != null ? primitive.GetCursor(point) : base.GetCursor(point);
+    }
+
     public override string GetToolTipText(PointD point) {
-      IPrimitive primitive = GetPrimitive(point);
-      if (primitive != null) return primitive.GetToolTipText(point);
-      else return base.GetToolTipText(point);
+      var primitive = GetPrimitive(point);
+      return primitive != null ? primitive.GetToolTipText(point) : base.GetToolTipText(point);
     }
 
     public void OneLayerUp(IPrimitive primitive) {
-      if (!Contains(primitive))
-        throw new ArgumentException("Primitive not found");
-
-      var curr = myPrimitives.Find(primitive);
+      if (!Contains(primitive)) throw new ArgumentException("Primitive not found");
+
+      var curr = primitives.Find(primitive);
       if (curr == null) return;
       var prev = curr.Previous;
@@ -162 +182 @@
       prev.Value = temp;
 
-      OnUpdate();
-    }
-
+      OnRedrawRequired();
+    }
     public void OneLayerDown(IPrimitive primitive) {
-      if (!Contains(primitive))
-        throw new ArgumentException("Primitive not found");
-
-      var curr = myPrimitives.Find(primitive);
+      if (!Contains(primitive)) throw new ArgumentException("Primitive not found");
+
+      var curr = primitives.Find(primitive);
       if (curr == null) return;
       var next = curr.Next;
@@ -177 +195 @@
     }
     public void IntoForeground(IPrimitive primitive) {
-      if (!Contains(primitive))
-        throw new ArgumentException("Primitive not found");
-
-      myPrimitives.Remove(primitive);
-      myPrimitives.AddFirst(primitive);
-      OnUpdate();
+      if (!Contains(primitive)) throw new ArgumentException("Primitive not found");
+      primitives.Remove(primitive);
+      primitives.AddFirst(primitive);
+      OnRedrawRequired();
     }
     public void IntoBackground(IPrimitive primitive) {
-      if (!Contains(primitive))
-        throw new ArgumentException("Primitive not found");
-
-      myPrimitives.Remove(primitive);
-      myPrimitives.AddLast(primitive);
-      OnUpdate();
+      if (!Contains(primitive)) throw new ArgumentException("Primitive not found");
+
+      primitives.Remove(primitive);
+      primitives.AddLast(primitive);
+      OnRedrawRequired();
     }
 
     public override void Draw(Graphics graphics) {
-      var current = myPrimitives.Last;
+      var current = primitives.Last;
       while (current != null) {
         var primitive = current.Value;
@@ -204 +219 @@
     }
 
-    private void primitive_Update(object sender, EventArgs e) {
-      OnUpdate();
+    private void PrimitiveOnRedrawRequired(object sender, EventArgs e) {
+      if (SuppressEvents) return;
+      OnRedrawRequired();
+    }
+
+    public IEnumerator<IPrimitive> GetEnumerator() {
+      return primitives.GetEnumerator();
+    }
+
+    IEnumerator IEnumerable.GetEnumerator() {
+      return GetEnumerator();
     }
   }