source: branches/HeuristicLab.Visualization/HeuristicLab.Visualization/3.3/Primitives/Group.cs @ 10513

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Drawing;
using System.Linq;
using System.Windows.Forms;

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);
      }
    }
    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;
      }
    }

    public Group(IChart chart)
      : base(chart) {
      myPrimitives = new LinkedList<IPrimitive>();
      myPrimitivesLookup = 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();
    }
    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();
    }
    public virtual bool Contains(IPrimitive primitive) {
      return myPrimitivesLookup.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;
      }
    }
    public virtual void Clear() {
      foreach (IPrimitive primitive in myPrimitives) {
        primitive.Group = null;
        primitive.Update -= new EventHandler(primitive_Update);
      }
      myPrimitives.Clear();
      myPrimitivesLookup.Clear();
      OnUpdate();
    }

    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);
        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));
    }

    public override void Move(Offset delta) {
      bool updateEnabled = UpdateEnabled;
      UpdateEnabled = false;
      foreach (IPrimitive primitive in myPrimitives)
        primitive.Move(delta);
      UpdateEnabled = updateEnabled;
      OnUpdate();
    }

    public override bool ContainsPoint(PointD point) {
      return GetPrimitive(point) != null;
    }

    public override Cursor GetCursor(PointD point) {
      IPrimitive primitive = GetPrimitive(point);
      if (primitive != null) return primitive.GetCursor(point);
      else return 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);
    }

    public void OneLayerUp(IPrimitive primitive) {
      if (!Contains(primitive))
        throw new ArgumentException("Primitive not found");

      var curr = myPrimitives.Find(primitive);
      if (curr == null) return;
      var prev = curr.Previous;
      var temp = curr.Value;
      curr.Value = prev.Value;
      prev.Value = temp;

      OnUpdate();
    }

    public void OneLayerDown(IPrimitive primitive) {
      if (!Contains(primitive))
        throw new ArgumentException("Primitive not found");

      var curr = myPrimitives.Find(primitive);
      if (curr == null) return;
      var next = curr.Next;
      var temp = curr.Value;
      curr.Value = next.Value;
      next.Value = temp;
    }
    public void IntoForeground(IPrimitive primitive) {
      if (!Contains(primitive))
        throw new ArgumentException("Primitive not found");

      myPrimitives.Remove(primitive);
      myPrimitives.AddFirst(primitive);
      OnUpdate();
    }
    public void IntoBackground(IPrimitive primitive) {
      if (!Contains(primitive))
        throw new ArgumentException("Primitive not found");

      myPrimitives.Remove(primitive);
      myPrimitives.AddLast(primitive);
      OnUpdate();
    }

    public override void Draw(Graphics graphics) {
      var current = myPrimitives.Last;
      while (current != null) {
        var primitive = current.Value;
        primitive.PreDraw(graphics);
        primitive.Draw(graphics);
        primitive.PostDraw(graphics);
        current = current.Previous;
      }
    }

    private void primitive_Update(object sender, EventArgs e) {
      OnUpdate();
    }
  }
}