GraphToolWPF/Customs/EdgeEntity.cs - master - anton.bessolitsyn/GraphTool

GraphToolWPF/Customs/EdgeEntity.cs
233 строки7 KB
Anton Bessolitsyn
in progress
22 окт 2025, 10:25
22 окт 2025, 10:258675066
using GraphToolWPF.Model;
using Microsoft.VisualBasic;
using Multicad;
using Multicad.CustomObjectBase;
using Multicad.DatabaseServices;
using Multicad.Geometry;
using Multicad.Runtime;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static Multicad.Geometry.Mesh;

namespace GraphToolWPF.Customs
{
    [CustomEntity("E80CAB89-8970-447a-A5DF-AA3BA30D0001", "edge-entity", "ребро графа")]

    internal class EdgeEntity : BaseGraphEntity, IEdgeEvent
    {
        public static new Guid TypeID
        {
            get
            {
                return GetTypeID(typeof(EdgeEntity));
            }
        }

        #region EVENTS

        public event EventHandler<EventArgs>? EditedP1;
        public event EventHandler<EventArgs>? EditedP2;
        public event EventHandler<EventArgs>? Erased;
        #endregion

        //protected VertexEntity? _vpnt1;         
        //protected VertexEntity? _vpnt2;

        protected Point3d _pnt1 = new Point3d(50, 50, 0);
        public Point3d P1
        {
            get
            {
                return _pnt1;
            }
            set
            {
                if (_pnt1 == value || !TryModify()) return;//без этого не будет сохранятся Undo и перерисовыватся объект
                _pnt1 = value;

                if (VertexEntity.GetVertexEntity(_vertex1)?.Origin != _pnt1)
                {
                    var v = VertexEntity.CreateEntity(_pnt1);
                    _vertex1 = v.ID.ToGuid();
                }
                EditedP1?.Invoke(this, EventArgs.Empty);
                
            }
        }

        protected Point3d _pnt2 = new Point3d(150, 150, 0);        
        public Point3d P2
        {
            get
            {
                return _pnt2;
            }
            set
            {
                if (_pnt2 == value || !TryModify()) return;//без этого не будет сохранятся Undo и перерисовыватся объект
                _pnt2 = value;
                
                EditedP2?.Invoke(this, EventArgs.Empty);
            }
        }


        protected Guid _vertex1 = Guid.Empty;
        public Guid Vertex1
        {
            get
            {
                return _vertex1;
            }
        }
        public void SetVertex1(Guid vertex)
        { _vertex2 = vertex; }


        protected Guid _vertex2 = Guid.Empty;
        public Guid Vertex2
        {
            get
            {
                return _vertex2;
            }
        }
        public void SetVertex2(Guid vertex)
        { _vertex2 = vertex; }

        public double Length { get => _vec.Length; }

        public EdgeEntity(IGraphInteractor interactor) : base()
        {
            interactor.SubscribeOnEdgeEvents(this);
        }
        public EdgeEntity() : base() { }

        protected override void DrawEntity(GeometryBuilder dc)
        {
            dc.DrawLine(_pnt1, _pnt2);
        }

        public override void OnErase()
        {
            Erased?.Invoke(this, EventArgs.Empty);
            base.OnErase();
            //OnPersistentReactorEx
        }
        
        public hresult PlaceObject(VertexEntity v1, VertexEntity v2)
        { 
            _pnt1 = v1.Origin;
            _vertex1 = v1.ID.ToGuid();
            _pnt2 = v2.Origin;
            _vertex2 = v2.ID.ToGuid();
            _vec = _pnt2 - _pnt1;
            return PlaceObject(PlaceFlags.Wout_Position);
        }
        public override hresult PlaceObject(PlaceFlags lInsertType)
        {
            //if (lInsertType == PlaceFlags.Wout_Position && AdditionalParameters?.Count > 0)
            //{
            //    //var v1 = (VertexEntity)AdditionalParameters[0].Value;
            //    //var v2 = (VertexEntity)AdditionalParameters[1].Value;
                
            //}

            DbEntity.AddToCurrentDocument();
            return hresult.s_Ok;
        }

        //[CommandMethod("gt_EdgeEntity", CommandFlags.NoCheck | CommandFlags.NoPrefix)]
        static public EdgeEntity CreateEntity()
        {
            EdgeEntity obj = new EdgeEntity();
            obj.DbEntity.Color = Multicad.Constants.Colors.ByLayer;
            obj.PlaceObject();
            return obj;
        }

        static public EdgeEntity CreateEntity(out VertexEntity? v1, out VertexEntity? v2 )
        {
            //McDbEntity.G Ver
            EdgeEntity obj = new EdgeEntity();
            v1 = null; v2 = null;
            InputJig jig = new InputJig();
            jig.SetInputOptions(InputJig.InputReturnMode.Other);
            jig.ForceInputNumbers = true;
            //InputJig.PropertyInpector.SetSource(obj);
            
            InputResult res1 = jig.GetPoint("Укажите первую точку или выберете вершину");
            InputResult res2 = jig.GetPoint("Укажите вторую точку или выберете вершину");
            if (res1.Result == InputResult.ResultCode.Normal && res2.Result == InputResult.ResultCode.Normal)
            {
                v1 = VertexEntity.GetVertexEntity(res1.ObjectId.ToGuid()) ?? VertexEntity.CreateEntity(res1.Point);              
                v2 = VertexEntity.GetVertexEntity(res2.ObjectId.ToGuid()) ?? VertexEntity.CreateEntity(res2.Point);
                if (v1 != null && v2 != null)
                {
                    obj.DbEntity.Color = Multicad.Constants.Colors.ByLayer;
                    obj.PlaceObject(v1, v2);
                }
            }

            return obj; 
        }

        //static public EdgeEntity CreateEntity(IGraphInteractor interactor)
        //{
        //    EdgeEntity obj = new EdgeEntity(interactor);
        //    obj.DbEntity.Color = Multicad.Constants.Colors.ByLayer;
        //    obj.PlaceObject();
        //    return obj;
        //}

        public override bool GetGripPoints(GripPointsInfo info)
        {

            info.AppendGrip(new McSmartGrip<EdgeEntity>(_pnt1, (obj, grip, offset) => { obj.TryModify(); obj.P1 += offset; }));
            info.AppendGrip(new McSmartGrip<EdgeEntity>(_pnt2, (obj, grip, offset) => { obj.TryModify(); obj.P2 += offset; }));
            return true;
        }
        //public Guid[] GetVertexGuids()
        //{
        //    var guids = new Guid[2];
        //    guids[0] = _vertex1;
        //    guids[1] = _vertex2;
        //    return guids;
        //}

        public override hresult write(McStream S)
        {
            S.PutVersion(1, 0);
            S.PutPoint(_pnt1);
            S.PutPoint(_pnt2);
            S.PutGUID(_vertex1);
            S.PutGUID(_vertex2);

            return base.write(S);
        }
        public override hresult read(McStream S)
        {
            short major, minor;
            if (!S.GetVersion(out major, out minor))
                return hresult.e_MakeMeProxy;

            if (major == 1)
            {
                if (!S.GetPoint(out _pnt1))
                    return hresult.e_Fail;
                if (!S.GetPoint(out _pnt2))
                    return hresult.e_Fail;
                if (!S.GetGUID(out _vertex1))
                    return hresult.e_Fail;
                if (!S.GetGUID(out _vertex2))
                    return hresult.e_Fail;
            }

            return base.read(S);
        }
    }
}