コード例 #1
0
ファイル: Picking.cs プロジェクト: OkanPinar/FFEyeshot
        private object GetSelectedItem(devDept.Eyeshot.Entities.Entity ent)
        {
            List <System.Reflection.PropertyInfo> props = null;

            if (ent is BlockReference br)
            {
                var block = Blocks[br.BlockName];
                props = new List <System.Reflection.PropertyInfo>(block.GetType().GetProperties());

                var checkProp = props.Where(item => item.Name == "Parent").DefaultIfEmpty().First();
                if (checkProp != null)
                {
                    return(checkProp.GetValue(block));
                }
                else
                {
                    return(block);
                }
            }
            else
            {
                props = new List <System.Reflection.PropertyInfo>(ent.GetType().GetProperties());

                var checkProp = props.Where(item => item.Name == "Parent").DefaultIfEmpty().First();
                if (checkProp != null)
                {
                    return(checkProp.GetValue(ent));
                }

                else
                {
                    return(ent);
                }
            }
        }
コード例 #2
0
        public SnapPoint[] GetSnapPoints()
        {
            //changed PickBoxSize to define a range for display snapPoints
            int oldSize = PickBoxSize;

            PickBoxSize = 10;

            PickBoxSize = oldSize;

            List <SnapPoint> snapPoints = new List <SnapPoint>();

            if (CurrentIndex != -1)
            {
                devDept.Eyeshot.Entities.Entity ent = Entities[CurrentIndex];

                if (ent is Entity.IFFEntity ffEntity)
                {
                    snapPoints.AddRange(ffEntity.GetSnapPoints(StateSnap));
                }

                else if (ent is Point point)
                {
                    foreach (var activeObjectSnap in StateSnap.EnabledSnapTypes)
                    {
                        switch (activeObjectSnap)
                        {
                        case SnapState.SnapType.POINT:
                            Point3D point3d = point.Vertices[0];
                            snapPoints.Add(new SnapPoint(point3d, SnapState.SnapType.POINT));
                            break;
                        }
                    }
                }
                else if (ent is Line line) //line
                {
                    foreach (var activeObjectSnap in StateSnap.EnabledSnapTypes)
                    {
                        switch (activeObjectSnap)
                        {
                        case SnapState.SnapType.END:
                            snapPoints.Add(new SnapPoint(line.StartPoint, SnapState.SnapType.END));
                            snapPoints.Add(new SnapPoint(line.EndPoint, SnapState.SnapType.END));
                            break;

                        case SnapState.SnapType.MID:
                            snapPoints.Add(new SnapPoint(line.MidPoint, SnapState.SnapType.MID));
                            break;
                        }
                    }
                }
                else if (ent is LinearPath polyline)//polyline
                {
                    List <SnapPoint> polyLineSnapPoints = new List <SnapPoint>();

                    foreach (var activeObjectSnap in StateSnap.EnabledSnapTypes)
                    {
                        switch (activeObjectSnap)
                        {
                        case SnapState.SnapType.END:
                            foreach (var ver in polyline.Vertices)
                            {
                                polyLineSnapPoints.Add(new SnapPoint(ver, SnapState.SnapType.END));
                            }
                            snapPoints.AddRange(polyLineSnapPoints);
                            break;
                        }
                    }
                }
                else if (ent is CompositeCurve composite)//composite
                {
                    List <SnapPoint> polyLineSnapPoints = new List <SnapPoint>();

                    foreach (var activeObjectSnap in StateSnap.EnabledSnapTypes)
                    {
                        switch (activeObjectSnap)
                        {
                        case SnapState.SnapType.END:
                            foreach (ICurve curveSeg in composite.CurveList)
                            {
                                polyLineSnapPoints.Add(new SnapPoint(curveSeg.EndPoint, SnapState.SnapType.END));
                            }
                            polyLineSnapPoints.Add(new SnapPoint(composite.CurveList[0].StartPoint, SnapState.SnapType.END));
                            snapPoints.AddRange(polyLineSnapPoints);
                            break;
                        }
                    }
                }
                else if (ent is Arc arc) //Arc
                {
                    foreach (var activeObjectSnap in StateSnap.EnabledSnapTypes)
                    {
                        switch (activeObjectSnap)
                        {
                        case SnapState.SnapType.END:
                            snapPoints.AddRange(new SnapPoint[] { new SnapPoint(arc.StartPoint, SnapState.SnapType.END),
                                                                  new SnapPoint(arc.EndPoint, SnapState.SnapType.END) });
                            break;

                        case SnapState.SnapType.MID:
                            snapPoints.AddRange(new SnapPoint[] { new SnapPoint(arc.MidPoint, SnapState.SnapType.MID) });
                            break;

                        case SnapState.SnapType.CENTER:
                            snapPoints.AddRange(new SnapPoint[] { new SnapPoint(arc.Center, SnapState.SnapType.CENTER) });
                            break;
                        }
                    }
                }
                else if (ent is Circle circle) //Circle
                {
                    foreach (var activeObjectSnap in StateSnap.EnabledSnapTypes)
                    {
                        switch (activeObjectSnap)
                        {
                        case SnapState.SnapType.END:
                            snapPoints.AddRange(new SnapPoint[] { new SnapPoint(circle.EndPoint, SnapState.SnapType.END) });
                            break;

                        case SnapState.SnapType.MID:
                            snapPoints.AddRange(new SnapPoint[] { new SnapPoint(circle.PointAt(circle.Domain.Mid), SnapState.SnapType.MID) });
                            break;

                        case SnapState.SnapType.CENTER:
                            snapPoints.AddRange(new SnapPoint[] { new SnapPoint(circle.Center, SnapState.SnapType.CENTER) });
                            break;

                        case SnapState.SnapType.QUAD:
                            Point3D quad1 = new Point3D(circle.Center.X, circle.Center.Y + circle.Radius);
                            Point3D quad2 = new Point3D(circle.Center.X + circle.Radius, circle.Center.Y);
                            Point3D quad3 = new Point3D(circle.Center.X, circle.Center.Y - circle.Radius);
                            Point3D quad4 = new Point3D(circle.Center.X - circle.Radius, circle.Center.Y);

                            snapPoints.AddRange(new SnapPoint[] { new SnapPoint(quad1, SnapState.SnapType.QUAD),
                                                                  new SnapPoint(quad2, SnapState.SnapType.QUAD),
                                                                  new SnapPoint(quad3, SnapState.SnapType.QUAD),
                                                                  new SnapPoint(quad4, SnapState.SnapType.QUAD) });
                            break;
                        }
                    }
                }

                else if (ent is Curve curve) // Spline
                {
                    foreach (var activeObjectSnap in StateSnap.EnabledSnapTypes)
                    {
                        switch (activeObjectSnap)
                        {
                        case SnapState.SnapType.END:
                            snapPoints.AddRange(new SnapPoint[] { new SnapPoint(curve.StartPoint, SnapState.SnapType.END),
                                                                  new SnapPoint(curve.EndPoint, SnapState.SnapType.END) });
                            break;

                        case SnapState.SnapType.MID:
                            snapPoints.AddRange(new SnapPoint[] { new SnapPoint(curve.PointAt(0.5), SnapState.SnapType.MID) });
                            break;
                        }
                    }
                }

                else if (ent is EllipticalArc) //Elliptical Arc
                {
                    EllipticalArc elArc = (EllipticalArc)ent;
                    foreach (var activeObjectSnap in StateSnap.EnabledSnapTypes)
                    {
                        switch (activeObjectSnap)
                        {
                        case SnapState.SnapType.END:
                            snapPoints.AddRange(new SnapPoint[] { new SnapPoint(elArc.StartPoint, SnapState.SnapType.END),
                                                                  new SnapPoint(elArc.EndPoint, SnapState.SnapType.END) });
                            break;

                        case SnapState.SnapType.CENTER:
                            snapPoints.AddRange(new SnapPoint[] { new SnapPoint(elArc.Center, SnapState.SnapType.CENTER) });
                            break;
                        }
                    }
                }
                else if (ent is Ellipse) //Ellipse
                {
                    Ellipse ellipse = (Ellipse)ent;
                    foreach (var activeObjectSnap in StateSnap.EnabledSnapTypes)
                    {
                        switch (activeObjectSnap)
                        {
                        case SnapState.SnapType.END:
                            snapPoints.AddRange(new SnapPoint[] { new SnapPoint(ellipse.EndPoint, SnapState.SnapType.END) });
                            break;

                        case SnapState.SnapType.MID:
                            snapPoints.AddRange(new SnapPoint[] { new SnapPoint(ellipse.PointAt(ellipse.Domain.Mid), SnapState.SnapType.MID) });
                            break;

                        case SnapState.SnapType.CENTER:
                            snapPoints.AddRange(new SnapPoint[] { new SnapPoint(ellipse.Center, SnapState.SnapType.CENTER) });
                            break;
                        }
                    }
                }

                //else if (ent is Entities.NSphere) //Mesh
                //{
                //    Entities.NSphere mesh = (Entities.NSphere)ent;
                //    foreach (var activeObjectSnap in CurrentSnapTypes)
                //    {
                //        snapPoints.Add(new SnapPoint(mesh.center, SnapType.END));

                //        break;
                //    }
                //}
            }

            return(snapPoints.ToArray());
        }