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

GraphToolWPF/Customs/BaseGraphEntity.cs
525 строк17 KB
Anton Bessolitsyn
in progress
22 окт 2025, 10:25
22 окт 2025, 10:258675066
using Multicad;
using Multicad.CustomObjectBase;
using Multicad.DatabaseServices;
using Multicad.Geometry;
using Multicad.Runtime;
using Multicad.Wpf.Dialogs;

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Globalization;
using System.IO;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;


namespace GraphToolWPF.Customs
{
    //internal class CustomObject
    //{
    //
    //}
    [CustomEntity("E80CAB89-8970-447a-A5DF-AA3BA30D0000", "graph-tool-entity", "базовый объект")]
    internal class BaseGraphEntity : McCustomBase, IMcDynamicProperties, IMcStreamSerializable
    {
        /// <summary>
        /// Простой способ получить ID класса, используется в конструкциях ObjectFlter.AddType(class.TypeID) или obj.IsKindOf(class.TypeID)
        /// </summary>
        public static new Guid TypeID
        {
            get
            {
                return GetTypeID(typeof(BaseGraphEntity));
            }
        }

        protected Point3d _pnt = new Point3d(50, 50, 0);
        protected Vector3d _vec;
        protected String _Text = "Text field";
        protected bool _bShowLine = true;


        public BaseGraphEntity()
        {
            onCreate(CreateObjectFlags.Default);
        }

        public BaseGraphEntity(Multicad.DatabaseServices.CreateObjectFlags flags)
        {
            onCreate(flags);
        }

        private void onCreate(Multicad.DatabaseServices.CreateObjectFlags flags)
        {            
            //_DynamicColor = Multicad.Constants.Colors.ByLayer;
            //_DynamicLineTypeName = "ByLayer";
            //_DynamicLineWeight = Multicad.Constants.LineWeights.ByLayer;
            //_HTextAlign = Multicad.Geometry.HorizTextAlign.Center;
        }
      
        public virtual Point3d Origin
        {
            get
            {
                return _pnt;
            }
            set
            {
                if (!TryModify()) return;//без этого не будет сохранятся Undo и перерисовыватся объект
                _pnt = value;
            }
        }
        
        // Реализация статического булевого свойства с переопределённым списком значений
        //public class BooleanTypeConverter : BooleanConverter
        //{
        //    static string gstYes = "Ага";
        //    static string gstNo = "Неа";
        //    public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destType)
        //    {
        //        return (bool)value ? gstYes : gstNo;
        //    }

        //    public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
        //    {
        //        return (string)value == gstYes ? true : false;
        //    }

        //    public override bool GetStandardValuesSupported(ITypeDescriptorContext context)
        //    {
        //        return true;
        //    }

        //    public override bool GetStandardValuesExclusive(ITypeDescriptorContext context)
        //    {
        //        return true; // true - только выбор из списка
        //    }

        //    public override StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
        //    {
        //        System.Collections.ObjectModel.Collection<string> items = new System.Collections.ObjectModel.Collection<string>();
        //        items.Add(gstYes);
        //        items.Add(gstNo);
        //        return new StandardValuesCollection(items);
        //    }
        //}
        //[DisplayName("Показать линию")]
        //[Category("Тестовый объект")]
        //[TypeConverter(typeof(BooleanTypeConverter))]
        //public bool ShowLine
        //{
        //    get
        //    {
        //        return _bShowLine;
        //    }

        //    set
        //    {
        //        if (!this.TryModify())
        //        {
        //            return; // без этого не будет сохранятся Undo и перерисовыватся объект
        //        }
        //        this._bShowLine = value;
        //    }
        //}

        public bool TryModify()
        {
            TryModify(0);
            return true;
        }

        //
        // Summary:
        //     Вызов событий объекта, param содержит значение параметра зависящее от события,
        public virtual hresult OnEvent(Events ev, object param)
        {
            return hresult.e_NotImplemented;
        }
        public override hresult OnUpdate()
        {
            return base.OnUpdate();
        }
        public override bool OnGetOsnapPoints(OsnapMode osnapMode, Point3d pickPoint, Point3d lastPoint, List<Point3d> osnapPoints)
        {
            return base.OnGetOsnapPoints(osnapMode, pickPoint, lastPoint, osnapPoints);
        }

        // Summary:
        //     Редактирование объекта
        public virtual hresult OnEdit()
        {
            Point3d origin = Point3d.Origin;
            return OnEdit(origin, EditFlags.None);
        }
        public override McGeomParam OnGetParamAtPoint(Point3d pnt)
        {
            return base.OnGetParamAtPoint(pnt);
        }

        public override void OnDraw(GeometryBuilder dc)
        {
            dc.Clear();
            dc.LineType = Multicad.Constants.LineTypes.ByObject;
            dc.LineWidth = Multicad.Constants.LineWeights.ByObject;
            dc.Color = Multicad.Constants.Colors.ByObject;            
            DrawEntity(dc);
            
        }

        protected virtual void DrawEntity(GeometryBuilder dc)
        {
            dc.DrawCircle(_pnt, 5 * DbEntity.Scale);
        }

       

        public override void OnTransform(Matrix3d tfm)
        {
            if (!TryModify()) return;
            _pnt = _pnt.TransformBy(tfm);
        }

        public override bool GetGripPoints(GripPointsInfo info)        
        {
            info.AppendGrip(new McSmartGrip<BaseGraphEntity>(_pnt, (obj, grip, offset) => { obj.TryModify(); obj._pnt += offset; }));
            return true;
        }

        //public override hresult PlaceObject(PlaceFlags lInsertType)
        //{
        //    InputJig jig = new InputJig();
        //    jig.SetInputOptions(InputJig.InputReturnMode.Other);
        //    jig.ForceInputNumbers = true;
        //    InputJig.PropertyInpector.SetSource(this);
        //    InputResult res = jig.GetPoint("Select first point:");
        //    if (res.Result != InputResult.ResultCode.Normal)
        //        return hresult.e_Fail;
        //    _pnt = res.Point;
        //    DbEntity.AddToCurrentDocument();
        //    //Исключаем себя из привязки, что бы osnap точки не липли к самому себе
        //    jig.ExcludeObject(ID);

        //    //Мониторинг движения мышкой
        //    //jig.MouseMove = (s, a) => {
        //    //    TryModify(); _vec = a.Point - _pnt; DbEntity.Update();
        //    //    InputJig.PropertyInpector.UpdateProperties();
        //    //};
        //    //res = jig.GetPoint("Select second point:");
        //    //if (res.Result != InputResult.ResultCode.Normal)
        //    //{
        //    //    DbEntity.Erase();
        //    //    return hresult.e_Fail;
        //    //}
        //    //_vec = res.Point - _pnt;
        //    InputJig.PropertyInpector.SetSource(null);
        //    return hresult.s_Ok;
        //}

        public override hresult OnEdit(Point3d pnt, EditFlags lInsertType)
        {            
            //string _text="TEXT";
            //McInputValueDialog.GetStringValue("Edit text:",out _text);
            //Text = _text;
            
            return hresult.s_Ok;
        }

        //[CommandMethod("gt_BaseGraphEntity", CommandFlags.NoCheck | CommandFlags.NoPrefix)]
        static public void CreateBaseGraphEntity()
        {
            BaseGraphEntity obj = new BaseGraphEntity();
            obj.DbEntity.Color = Multicad.Constants.Colors.ByLayer;
            obj.PlaceObject();
        }
        public override bool SupportMcStreamSerialization()
        {
            return true;
        }
        public override hresult write(McStream S)
        {
            S.PutVersion(1, 0);

            S.PutPoint(_pnt);
            //S.PutVector(_vec);
            //S.PutString(_Text);
            //S.PutBool(_bShowLine);

            S.WriteVersionBlockEnd();
                        
           
            return hresult.s_Ok;
        }
        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 _pnt))
                    return hresult.e_Fail;
                //if (!S.GetVector(out _vec))
                //    return hresult.e_Fail;
                //if (!S.GetString(out _Text))
                //    return hresult.e_Fail;
                //if (!S.GetBool(out _bShowLine))
                //    return hresult.e_Fail;
            }

            if (!S.ReadVersionBlockEnd())
                return hresult.e_Fail;

            return hresult.s_Ok;
        }

        public Guid Guid
        {
            get
            {
                return ID.ToGuid();
            }
            
        }

        public Guid GetGuid() => ID.ToGuid();

        #region IMcDynamicProperties



        //[Browsable(false)]
        //public string DynamicLineTypeName
        //{
        //    get
        //    {
        //        return _DynamicLineTypeName;
        //    }
        //    set
        //    {
        //        if (!TryModify()) return;//без этого не будет сохранятся Undo и перерисовыватся объект
        //        _DynamicLineTypeName = value;
        //    }
        //}
        //protected string _DynamicLineTypeName;

        //[Browsable(false)]
        //public int DynamicLineWeight
        //{
        //    get
        //    {
        //        return _DynamicLineWeight;
        //    }
        //    set
        //    {
        //        if (!TryModify()) return;//без этого не будет сохранятся Undo и перерисовыватся объект
        //        _DynamicLineWeight = value;
        //    }
        //}
        //protected int _DynamicLineWeight;

        //[Browsable(false)]
        //public Multicad.Geometry.HorizTextAlign HTextAlign
        //{
        //    get
        //    {
        //        return _HTextAlign;
        //    }
        //    set
        //    {
        //        if (!TryModify()) return;//без этого не будет сохранятся Undo и перерисовыватся объект
        //        _HTextAlign = value;
        //    }
        //}
        //protected Multicad.Geometry.HorizTextAlign _HTextAlign;

        public ICollection<McDynamicProperty> GetProperties(out bool exclusive)
        {
            exclusive = false;

            List<McDynamicProperty> listProps = new List<McDynamicProperty>();
            //listProps.Add(GetProperty("GuidStr"));
            //listProps.Add(GetProperty("Vertex1"));
            //listProps.Add(GetProperty("Vertex2"));

            //listProps.Add(GetProperty("dynLinetype"));
            //listProps.Add(GetProperty("dynLineweight"));
            //listProps.Add(GetProperty("dynHorizTextAlign"));
            return listProps;
        }

        public McDynamicProperty GetProperty(string name)
        {
            //string Category = "Расширенные параметры отображения";
            //switch (name)
            //{
            //    case "GuidStr":
            //        return new McDynamicPropertyImpl(this, Category, name, "Guid", GuidStr);
            //    case "Vertex1":
            //        return new McDynamicPropertyImpl(this, "Вершины ребра", name, "Vertex1", _vertex1);
            //    case "Vertex2":
            //        return new McDynamicPropertyImpl(this, "Вершины ребра", name, "Vertex2", _vertex2);
            //        //case "dynColor":
            //        //    return new McDynamicPropertyImpl(this, Category, name, "Цвет текста", _DynamicColor);
            //        //case "dynLinetype":
            //        //    return new McDynamicPropertyImpl(this, Category, name, "Тип линии", _DynamicLineTypeName);
            //        //case "dynLineweight":
            //        //    return new McDynamicPropertyImpl(this, Category, name, "Вес линии", _DynamicLineWeight);
            //}
            return null;
        }
        #endregion IMcDynamicProperties
    }

    /// <summary>
	/// Класс "Динамическое свойство"
	/// </summary>
	public class McDynamicPropertyImpl : McDynamicProperty
    {
        protected String _SystemName;
        protected String _DisplayName;
        protected String _CategoryName;
        protected Object _Value;
        ///[NonSerialized]
        protected McCustomBase _Owner;

        public McDynamicPropertyImpl(McCustomBase owner, String CategoryName, String SystemName, String DisplayName, object Value)
        {
            _SystemName = SystemName;
            _DisplayName = DisplayName;
            _Value = Value;
            _CategoryName = CategoryName;
            _Owner = owner;
        }

        #region McDynamicProperty
        //-----------------------------------------------
        override public Object GetValue()
        {
            return _Value;
        }

        //-----------------------------------------------
        override public bool SetValue(Object value)
        {
            if (_Owner == null || value == null)
                return false;
            _Owner.TryModify(0);

            //switch (_SystemName)
            //{
            //    //case "dynColor":
            //    //    (_Owner as BaseGraphEntity).DynamicColor = (Color)value;
            //    //    break;
            //    //case "dynLinetype":
            //    //    (_Owner as BaseGraphEntity).DynamicLineTypeName = (string)value;
            //    //    break;
            //    //case "dynLineweight":
            //    //    (_Owner as BaseGraphEntity).DynamicLineWeight = (int)value;
            //    //    break;
            //}

            _Value = value;
            return true;
        }

        override public String Name
        {
            get { return _SystemName; }
        }

        override public bool IsBrowsable
        {
            get { return true; }
        }
        
        override public bool IsReadOnly
        {
            get { return false; }
        }

        override public ExAttributesProperties ExtendedAtributes
        {
            get { return ExAttributesProperties.None; }
        }

        override public Multicad.Units.MeasureCategory UnitCategory
        {
            get { return Multicad.Units.MeasureCategory.Undefined; }
        }

        override public Multicad.Units.Name UnitName
        {
            get { return Multicad.Units.Name.Undefined; }
        }

        override public String Description
        {
            get { return String.Empty; }
        }

        override public String DisplayName
        {
            get { return _DisplayName; }
        }

        override public String Category
        {
            get { return _CategoryName; }
        }

        override public TypeConverter Converter
        {
            get
            {
                //switch (_SystemName)
                //{
                //    case "dynColor":
                //        return new Multicad.ComponentModel.ColorConverter();
                //    case "dynLinetype":
                //        return new Multicad.ComponentModel.LineTypeConverter();
                //    case "dynLineweight":
                //        return new Multicad.ComponentModel.LineWeightConverter();
                //}
                return null;
            }
        }

        override public IMcDynamicPropertyEditor GetEditor()
        {
            return null;
        }

        //override public System.Collections.ICollection GetStandardValues()
        //{
        //    if (_SystemName == "dynHorizTextAlign")
        //    {
        //        System.Collections.ObjectModel.Collection<string> items = new System.Collections.ObjectModel.Collection<string>();
        //        items.Add(McHorzTextAlignTypeConverter.stLeft);
        //        items.Add(McHorzTextAlignTypeConverter.stCenter);
        //        items.Add(McHorzTextAlignTypeConverter.stRight);
        //        return new System.ComponentModel.TypeConverter.StandardValuesCollection(items);
        //    }

        //    return null;
        //}

        //override public StandardValueTypeEnum GetStandardValueType()
        //{
        //    if (_SystemName == "dynHorizTextAlign")
        //        return StandardValueTypeEnum.Exclusive;
        //    return StandardValueTypeEnum.None;
        //}

        override public System.Type PropertyType
        {
            get { return _Value.GetType(); }
        }
        #endregion McDynamicProperty
    }
      
    
}