private void AddNewLinear()
 {
     // Добавляем элемент в модель
     // Если в модели уже были узлы начала и конца этого нового элемента
     // то новые узлы не добавляем. В противном случае - добавляем и узлы
     if (EditedComp?.CompType == ComponentTypes.ctLinear)
     {
         ComponentLinear lin   = (ComponentLinear)EditedComp;
         ComponentNode   node1 = modelVM.GetNodeAtPoint(lin.Start);
         ComponentNode   node2 = modelVM.GetNodeAtPoint(lin.End);
         if (node1 == null)
         {
             RModel.CompsList.Add(lin.StartNode);
             node1 = lin.StartNode;
         }
         if (node2 == null)
         {
             RModel.CompsList.Add(lin.EndNode);
             node2 = lin.EndNode;
         }
         EditedComp = new ComponentLinear(node1, node2, RModel);
         RModel.EnableChangeTracking();
         RModel.CompsList.Add(EditedComp);
         RModel.DisableChangeTracking();
     }
 }
        private void CreateNewLinear(IssoPoint2D pt1)
        {
            // НОВЫЙ ЛИНЕЙНЫЙ КОМПОНЕНТ
            // Компонент идёт в паре с двумя узлами.
            // Первый узел - в точке, указанной пользователем (pt1)
            // Если в этой точке уже есть другой узел, то берём его как начало элемента
            // Если тут нет узла - создаём его, и берём как стартовый
            // Если пользователь указал точку, лежащую на линейном компоненте - создаём в этом месте
            // узел, разделяя компонент на две части, и берём его как стартовый
            ComponentNode node = modelVM.GetNodeAtPoint(pt1);

            if (node == null)
            {
                IssoPoint2D    pt2;
                ComponentBasic b = modelVM.GetComponent(pt1, out pt2);
                if (b?.CompType == ComponentTypes.ctLinear)
                {
                    modelVM.SplitLinearAt((ComponentLinear)b, pt2);
                    node = modelVM.GetNodeAtPoint(pt2);
                }
                node = new ComponentNode(pt1);
            }
            pt1.X       += 0.1f;
            EditedComp   = new ComponentLinear(node, new ComponentNode(pt1), RModel);
            EditorAction = EditorActions.NewLinearLastPoint;
        }
        private void ApplySnap(ComponentLinear linear, IssoPoint2D pt1)
        {
            ComponentNode node = modelVM.GetNodeAtPoint(pt1);

            if (node != null)
            {
                linear.End = node.Location;
            }
            else
            {
                // Используем выравнивание. Если угол близок к 0, 90, 180, 270 и т.п. - выравниваем.
                float a = IssoBind.OrthoAngle(linear.AngleD);
                if ((a == 0) || (a == 180))
                {
                    linear.EndNode.MoveTo(new IssoPoint2D()
                    {
                        X = pt1.X, Y = linear.Start.Y
                    });
                }
                if ((a == 90) || (a == 270) || (a == -90))
                {
                    linear.EndNode.MoveTo(new IssoPoint2D()
                    {
                        Y = pt1.Y, X = linear.Start.X
                    });
                }
            }
        }
Пример #4
0
        public static bool Contains(ComponentLinear linear, IssoPoint2D pt, ModelViewSurface surface)
        {
            SKPath pin = new SKPath();
            // Определим начало координат - это всегда точка, расположенная левее
            IssoPoint2D ptstart, ptend;

            if (linear.Start.X < linear.End.X)
            {
                ptstart = linear.Start;
                ptend   = linear.End;
            }
            else
            {
                ptstart = linear.End;
                ptend   = linear.Start;
            }
            double ang = Math.Asin((ptend.Y - ptstart.Y) / linear.Length);
            float  dy  = 7 / surface.scaleFactor;

            pin.MoveTo(ptstart.X, ptstart.Y - dy);
            pin.LineTo(ptstart.X, ptstart.Y + dy);
            pin.LineTo(ptstart.X + linear.Length, ptstart.Y + dy);
            pin.LineTo(ptstart.X + linear.Length, ptstart.Y - dy);
            pin.Close();
            pin.Transform(SKMatrix.MakeRotation((float)ang, ptstart.X, ptstart.Y));
            return(pin.Contains(pt.X, pt.Y));
        }
Пример #5
0
        internal void SplitLinearAt(ComponentLinear l, IssoPoint2D pt2)
        {
            if (CloseEnough(pt2, l.Start) || CloseEnough(pt2, l.End))
            {
                return;
            }
            ComponentLinear lin = l.SplitAt(pt2);

            model.EnableChangeTracking();
            model.CompsList.Add(lin.StartNode);
            model.CompsList.Add(lin);
            model.DisableChangeTracking();
        }
 private void ChangeDstLoadEnd(IssoPoint2D pt1)
 {
     if (EditedComp?.CompType == ComponentTypes.ctDistributedLoad)
     {
         // Определяем, какому линейному компоненту принадлежит начальный узел нагрузки
         ComponentLoad   load = (ComponentLoad)EditedComp;
         ComponentLinear lin  = (ComponentLinear)modelVM.GetComponent(pt1, out IssoPoint2D pt2, ComponentTypes.ctLinear);
         if (lin != null)
         {
             load.SetLastNodeAt(pt2);
         }
     }
 }
Пример #7
0
 internal ComponentLinear GetLinear(IssoPoint2D p1, IssoPoint2D p2)
 {
     // Возвращаем линейный компонент, которому принадлежат обе точки p1 и p2
     for (int i = 0; i < model.CompsList.Count; i++)
     {
         if (model.CompsList[i].CompType == ComponentTypes.ctLinear)
         {
             ComponentLinear lin = (ComponentLinear)model.CompsList[i];
             if (IssoDist.PointsOnLine(new IssoPoint2D[] { p1, p2 }, new IssoPoint2D[] { lin.Start, lin.End }))
             {
                 return(lin);
             }
         }
     }
     return(null);
 }
Пример #8
0
        public static void Draw(ComponentLinear linear, ModelViewSurface surface, SKCanvas canvas)
        {
            SKPaint paint = new SKPaint
            {
                Style       = SKPaintStyle.Stroke,
                Color       = Color.WhiteSmoke.ToSKColor(),
                IsAntialias = true,
                StrokeWidth = 2
            };

            if (linear.CompState == ComponentState.csSelected)
            {
                paint.StrokeWidth += 3;
                paint.Color        = Color.CornflowerBlue.ToSKColor();
            }

            SKPoint pt1 = IssoConvert.IssoPoint2DToSkPoint(linear.Start, surface.ScaleFactor, surface.Origin, surface.ViewHeight);
            SKPoint pt2 = IssoConvert.IssoPoint2DToSkPoint(linear.End, surface.ScaleFactor, surface.Origin, surface.ViewHeight);

            canvas.DrawLine(pt1, pt2, paint);

            SKPaint fillPaint = new SKPaint()
            {
                Style = SKPaintStyle.Fill, Color = Color.Black.ToSKColor(), IsAntialias = true
            };
            float  hr = surface.ViewHeight / 110;
            double a  = Math.Atan2(pt2.Y - pt1.Y, pt2.X - pt1.X);

            if (linear.HingeStart)
            {
                canvas.DrawCircle(pt1.X + hr * (float)Math.Cos(a), pt1.Y + hr * (float)Math.Sin(a), hr, fillPaint);
                canvas.DrawCircle(pt1.X + hr * (float)Math.Cos(a), pt1.Y + hr * (float)Math.Sin(a), hr, paint);
            }
            if (linear.HingeEnd)
            {
                canvas.DrawCircle(pt2.X + hr * (float)Math.Cos(a + Math.PI), pt2.Y + hr * (float)Math.Sin(a + Math.PI), hr, fillPaint);
                canvas.DrawCircle(pt2.X + hr * (float)Math.Cos(a + Math.PI), pt2.Y + hr * (float)Math.Sin(a + Math.PI), hr, paint);
            }
        }
        private void SetDistLoad(IssoPoint2D pt1)
        {
            if (EditedComp?.CompType == ComponentTypes.ctDistributedLoad)
            {
                ComponentLoad load = (ComponentLoad)EditedComp;
                IssoPoint2D   p1   = load.AppNodes[0].Location;
                IssoPoint2D   p2   = load.AppNodes[1].Location;

                ComponentLinear lin = modelVM.GetLinear(p1, p2);

                if (lin != null)
                {
                    modelVM.SplitLinearAt(lin, p1);
                    lin = modelVM.GetLinear(p1, p2);
                    modelVM.SplitLinearAt(lin, p2);
                    lin = modelVM.GetLinear(p1, p2);
                    RModel.EnableChangeTracking();
                    RModel.CompsList.Add(new ComponentLoad(ComponentTypes.ctDistributedLoad, -10, lin));
                    RModel.DisableChangeTracking();
                }
                EditorAction = EditorActions.None;
            }
        }