void Subject_ChangedForm(IShape subject, ChangeFormState state)
 {
     if (isAttracted || dragged != subject || !state.HasFlag(ChangeFormState.Coords)) return;
     using (StartFinishAction.Create(() => isAttracted = true, () => isAttracted = false))
     {
         RectangleF rect = subject.Rectangle;
         PointF center = subject.GetCenter(), minDist = new PointF(10, 10), dist = new PointF();
         guidlines = subject.GetCenter();
         hit = 0;
         bool lHit = false;
         foreach (var guide in guides.Where(s => s != subject).Select(s => s.GetCenter()))
         {
             if ((dist.X = Math.Abs(center.X - guide.X)) < minDist.X)
             {
                 minDist.X = dist.X;
                 guidlines.X = guide.X;
                 hit |= 1;
             }
             if ((dist.Y = Math.Abs(center.Y - guide.Y)) < minDist.Y)
             {
                 minDist.Y = dist.Y;
                 guidlines.Y = guide.Y;
                 hit |= 2;
             }
             if (hit == 3) break;
             //if (hit = Math.Abs(rect.Left - guide.X) <= 10)
             //    subject.Left = guide.X;
             //if (hit |= Math.Abs(rect.Top - guide.Y) <= 10)
             //    subject.Top = guide.Y;
             //if (hit) break;
         }
         subject.ToCenterPoint(guidlines);
     }
 }

 public static IConnection Connect(this RadDiagram diagram, IShape a, IShape b, string name = null)
 {
     var c = diagram.AddConnection(a, b);
     if (!string.IsNullOrEmpty(name))
         c.Name = name;
     return c;
 }

 public StaticPhysicalEntity(IShape shape, float weight = 1, bool inelasticCollision = false, bool elasticCollision = false)
 {
     Shape = shape;
     InelasticCollision = inelasticCollision;
     ElasticCollision = elasticCollision;
     Weight = weight;
 }

        private static void Main()
        {
            var shapes = new IShape[]
            {
                new Rectangle(1.5, 2),
                new Rhombus(4, 5),
                new Circle(30),
                new Circle(1),
                new Circle(2),
                new Rhombus(2, 3),
                new Rectangle(1.1, 1),
            };

            shapes = shapes.ToList().OrderByDescending(a => a.GetType().Name).ToArray(); // this is optional

            var longestTypePad = shapes.Max(a => a.GetType().Name).Length + 2;
            var longestShapePad = shapes.Max(a => a.ToString()).Length + 2;

            foreach (var shape in shapes)
            {
                Console.WriteLine("{0} -> {1} Area: {2,-8:F2} Perimeter: {3:F2}",
                    shape.GetType().Name.PadRight(longestTypePad),
                    shape.ToString().PadRight(longestShapePad),
                    shape.CalculateArea(),
                    shape.CalculatePerimeter());
            }
        }

 public AbstractPrefixTreeFilter(IShape queryShape, string fieldName, SpatialPrefixTree grid, int detailLevel)
 {
     this.queryShape = queryShape;
     this.fieldName = fieldName;
     this.grid = grid;
     this.detailLevel = detailLevel;
 }

 public IntersectsPrefixTreeFilter(IShape queryShape, string fieldName, 
                                   SpatialPrefixTree grid, int detailLevel,
                                   int prefixGridScanLevel, bool hasIndexedLeaves)
     : base(queryShape, fieldName, grid, detailLevel, prefixGridScanLevel)
 {
     this.hasIndexedLeaves = hasIndexedLeaves;
 }

        public static Vector2 collide(IShape a, IShape b)
        {
            if (a is RectangleShape && b is RectangleShape)
            {
                return intersectRectangles((RectangleShape)a, (RectangleShape)b);
            }

            if (a is Circle && b is RectangleShape)
            {
                if (b is Line) return -circleLineDetect((Line)b, (Circle)a);
                return intersectCircleRectangle((Circle) a, (RectangleShape) b);
            }

            if (a is RectangleShape && b is Circle)
            {
                if (a is Line) return circleLineDetect((Line)a, (Circle)b);
                return -intersectCircleRectangle((Circle) b, (RectangleShape) a);
            }

            if (a is Circle && b is Circle)
            {
                return intersectCircles((Circle)a, (Circle)b);
            }

            return Vector2.Zero;
        }

 protected BuildShapeContext(IShape shape, IContent content, string groupId, IShapeFactory shapeFactory) {
     Shape = shape;
     ContentItem = content.ContentItem;
     New = shapeFactory;
     GroupId = groupId;
     FindPlacement = (partType, differentiator, defaultLocation) => new PlacementInfo {Location = defaultLocation, Source = String.Empty};
 }

 public void Draw(IShape shape)
 {
     if (shape is Rectangle) { DrawRectangle(); }
     else if (shape is Circle) { DrawCircle(); }
     // If we want to introduce new shape(s),
     // we have to MODIFY this entity right HERE...
 }

 public UpdateEditorContext(IShape model, IContent content, IUpdateModel updater, string groupInfoId, IShapeFactory shapeFactory, ShapeTable shapeTable, string path)
     : base(model, content, groupInfoId, shapeFactory) {
     
     ShapeTable = shapeTable;
     Updater = updater;
     Path = path;
 }

 public void Add(IShape item)
 {
     if (!base.List.Contains(item))
     {
         base.List.Add(item);
     }
 }

 public void Remove(IShape shape)
 {
     if (_shapeList.Contains(shape))
     {
         _shapeList.Remove(shape);
     }
 }

 public void Add(IShape shape)
 {
     if (shape != null)
     {
         _shapeList.Add(shape);
     }
 }

        private static PlacementInfo FindPlacementImpl(ShapeTable shapeTable, IShape shape, string differentiator, string displayType)
        {
            ShapeDescriptor descriptor;
            var shapeType = shape.Metadata.Type;

            if (shapeTable.Descriptors.TryGetValue(shapeType, out descriptor))
            {
                var placementContext = new ShapePlacementContext
                {
                    Shape = shape,
                    DisplayType = displayType,
                    Differentiator = differentiator
                };

                var placement = descriptor.Placement(placementContext);
                if (placement != null)
                {
                    placement.Source = placementContext.Source;
                    return placement;
                }
            }

            return null;

        }

 public SpatialArgs(SpatialOperation operation, IShape shape)
 {
     if (operation == null || shape == null)
         throw new ArgumentException("operation and shape are required");
     this.Operation = operation;
     this.Shape = shape;
 }

 void Subject_ShapeDrawed(IShape subject, Graphics gr, Size size)
 {
     if (hit == 0 || dragged != subject) return;
     if ((hit & 1) != 0)
         gr.DrawLine(Pens.DeepSkyBlue, guidlines.X, -size.Height, guidlines.X, size.Height);
     if ((hit & 2) != 0)
         gr.DrawLine(Pens.DeepSkyBlue, -size.Width, guidlines.Y, size.Width, guidlines.Y);
 }

 protected BuildShapeContext(IShape shape, string groupId, IShapeFactory shapeFactory, IShape layout)
 {
     Shape = shape;
     ShapeFactory = shapeFactory;
     GroupId = groupId;
     Layout = layout;
     FindPlacement = FindDefaultPlacement;
 }

    public AddMultiPointShapeCommand(IController controller, IShape shape)
      : base(controller) {
      if (shape == null)
        throw new ArgumentNullException("The shape is 'null' and cannot be inserted.");
      this.Text = "Add " + shape.EntityName;


      this.shape = shape;
    }

 protected ModelShapeContext(object model, IShape shape, String displayType, IShapeFactory shapeFactory, ModelShapeContext parentContext)
 {
     Model = model;
     Shape = shape;
     New = shapeFactory;
     FindPlacement = (partType, differentiator, defaultLocation) => new PlacementInfo {Location = defaultLocation, Source = String.Empty};
     ParentContext = parentContext;
     DisplayType = displayType;
 }

 protected ShapeDto(IShape shape,Func<double,double> conversionFunction)
 {
     Area        = ConvertToDto(ConvertToDto(shape.Area, conversionFunction),conversionFunction);
     Perimeter   = ConvertToDto(shape.Perimeter, conversionFunction);
     Center      = shape.Center;
     Min         = shape.Bounds.Min;
     Max         = shape.Bounds.Max;
     Width       = ConvertToDto(shape.Bounds.Width,conversionFunction);
     Height      = ConvertToDto(shape.Bounds.Height, conversionFunction);
 }