GraphToolWPF/Service/GraphInteractorImp.cs - master - anton.bessolitsyn/GraphTool

GraphToolWPF/Service/GraphInteractorImp.cs
207 строк7 KB
Anton Bessolitsyn
in progress
22 окт 2025, 10:25
22 окт 2025, 10:258675066
using GraphToolWPF.Customs;
using GraphToolWPF.Model;
using GraphToolWPF.View;
using GraphToolWPF.ViewModel;
using Multicad;
using Multicad.AplicationServices;
using Multicad.DatabaseServices;
using Multicad.DatabaseServices.StandardObjects;
using Multicad.Geometry;
using Multicad.Runtime;
using Multicad.Wpf.Controls.Converters;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Transactions;
using static Multicad.Geometry.Mesh;


namespace GraphToolWPF.Service
{
    internal class GraphInteractorImp : IGraphInteractor
    {
        private readonly IGraphContext _storage;
        private readonly List<BaseGraphEntity> highlightedEntities = new List<BaseGraphEntity>();
        public GraphInteractorImp(IGraphContext storage)
        {
            _storage = storage;
        }

        public void HandleErasedEdgeEvent(object? sender, EventArgs e)
        {

            if (sender is EdgeEntity entity)
            {
                var edge = _storage.GetVertex(entity.ID.ToGuid());
                if (edge != null)
                {
                    _storage.Remove(edge);
                }
            }
        }
        
        public void HandleErasedVertexEvent(object? sender, EventArgs e)
        {

            if (sender is VertexEntity entity)
            {
                var v = _storage.GetVertex(entity.ID.ToGuid());
                if (v != null)
                {
                    _storage.Remove(v);
                }
            }
        }

        public void HandleEditedOriginOfVertexEvent(object? sender, EventArgs e)
        {

            if (sender is VertexEntity entity)
            {
                var v = _storage.GetVertex(entity.ID.ToGuid());
                if (v != null)
                {
                    var startedEdges = _storage.Edges.Where(e => e.Start == v);
                    foreach (var startedEdge in startedEdges)
                    {
                        startedEdge.ApplyNewPositionOfStart();
                    }
                    var endedEdges = _storage.Edges.Where(e => e.End == v);
                    foreach (var endedEdge in endedEdges)
                    {
                        endedEdge.ApplyNewPositionOfEnd();
                    }

                }

            }

        }

        public void HandleEditedVertexEvent(object? sender, EventArgs e)
        {
            var gWnd = new GraphToolWindow();
            var gViewModel = new GraphToolViewModel(this, _storage, gWnd);
            gWnd.DataContext = gViewModel;
            gWnd.ShowDialog(McContext.MainWindowHandle);

        }

        public void HandleEditedP1ofEdgeEvent(object? sender, EventArgs e)
        {
            
            if (sender is EdgeEntity entity)
            {
                //if (VertexEntity.GetVertexEntity(entity.Vertex1)?.Origin != entity.P1)
                if (_storage.GetVertex(entity.Vertex1)?.Entity.Origin != entity.P1)
                    {
                    var v = VertexEntity.CreateEntity(entity.P1);
                    entity.SetVertex1(v.ID.ToGuid());
                }

                var edge = _storage.GetEdge(entity.ID.ToGuid());
                if (edge != null)
                {
                    var v = _storage.GetVertex(entity.Vertex1);                  
                    if (v != null && v != edge.End && v != edge.Start)
                    {
                        edge.SetStart(v);
                    }
                }

            }
        }
        public void HandleEditedP2ofEdgeEvent(object? sender, EventArgs e)
        {
            
            if (sender is EdgeEntity entity)
            {

                //if (VertexEntity.GetVertexEntity(entity.Vertex2)?.Origin != entity.P2)
                if (_storage.GetVertex(entity.Vertex2)?.Entity.Origin != entity.P2)
                {
                    var v = VertexEntity.CreateEntity(entity.P2);
                    SubscribeOnVertexEvents(v);
                    _storage.Add(v);
                    entity.SetVertex2(v.ID.ToGuid());
                }



                var edge = _storage.GetEdge(entity.ID.ToGuid());
                if (edge != null)
                {
                    var v = _storage.GetVertex(entity.Vertex2);
                    if (v != null && v != edge.End && v != edge.Start)
                    {
                        edge.SetEnd(v);
                    }
                }

            }
        }

        public void SubscribeOnVertexEvents(IVertexEvent vertex)
        {
            vertex.Erased += HandleErasedVertexEvent;//вероятно это уже и не надо 
            vertex.EditedOrigin += HandleEditedOriginOfVertexEvent;
            vertex.Edited += HandleEditedVertexEvent;
        }
        public void SubscribeOnEdgeEvents(IEdgeEvent edge)
        {
            edge.Erased += HandleErasedEdgeEvent;
            edge.EditedP1 += HandleEditedP1ofEdgeEvent;
            edge.EditedP2 += HandleEditedP2ofEdgeEvent;
        }

        static void GetTwoVertecies(out VertexEntity? v1, out VertexEntity? v2)
        {
            v1 = null; v2 = null;
            InputJig jig = new InputJig();
            jig.SetInputOptions(InputJig.InputReturnMode.Other);
            jig.ForceInputNumbers = true;
            //InputJig.PropertyInpector.SetSource(obj);

            InputResult res1 = jig.GetEntity("Укажите первую точку или выберете вершину", (uint)EntityGeomType.kAllEntities);
            InputResult res2 = jig.GetEntity("Укажите первую точку или выберете вершину", (uint)EntityGeomType.kAllEntities);
            if (res1.Result == InputResult.ResultCode.Normal && res2.Result == InputResult.ResultCode.Normal)
            {
                v1 = res1.ObjectId.GetObjectOfType<VertexEntity>();
                v2 = res2.ObjectId.GetObjectOfType<VertexEntity>();
            }
            return;
        }

        static void HighlightEntities(List<BaseGraphEntity> list)
        {
            list.ForEach(e => {e.DbEntity.Color= System.Drawing.Color.Blue; });
            //list.ForEach(e => {e.DbEntity.Highlight(true, System.Drawing.Color.Aquamarine);});
        }

        public void FindShortestPath()
        { 
            GetTwoVertecies(out var v1entity, out var v2entity);
            if (v1entity != null && v2entity != null)
            {
                var v1 = _storage.GetVertex(v1entity.ID.ToGuid());
                var v2 = _storage.GetVertex(v2entity.ID.ToGuid());
                if (v1 != null && v2 != null)
                {
                    var res = _storage.FindShortestPath(v1, v2);
                    var entities = _storage.MakePathToEntities(res.Item1);
                    HighlightEntities(entities);

                }
            }
            return;
        }

        public void UnHighlightGraph()
        {
            highlightedEntities.ForEach(e => { e.DbEntity.Color = Multicad.Constants.Colors.ByLayer; });
        }

    }
}