kev/Drawer/UCDraw/SigmaDrawerWellElement/WellCurveTrack.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Design;
using System.Xml.Serialization;
using GeoSigma;
using GeoSigma.SigmaDrawerElement;
using GeoSigma.SigmaDrawerStyle;
using GeoSigma.SigmaDrawerStyle.Converter;
using SigmaDrawerStyle;
using GeoSigmaDrawLib;
using System.Data;
//using PropertyEditorColor = GeoSigma.SigmaDrawerStyle.PropertyEditorColor;

namespace SigmaDrawerElement
{
#pragma warning disable SA1402 // File may only contain a single type
#pragma warning disable SA1600 // Elements should be documented
#pragma warning disable SA1649 // File name should match first type name

    /// <summary>
    /// 充填
    /// </summary>
    public enum WellCurveTrackFillType
    {
        LeftBorder,
        RightBorder,
        LeftThreshold,
        RightThreshold,
    }

    public class WellCurveTrackFillTypeConverter : EnumConverter<WellCurveTrackFillType>
    {
        public static readonly Dictionary<WellCurveTrackFillType, string> Maps = new Dictionary<WellCurveTrackFillType, string>()
        {
            { WellCurveTrackFillType.LeftBorder, "左边界" },
            { WellCurveTrackFillType.RightBorder, "右边界" },
          //  { WellCurveTrackFillType.LeftThreshold, "左阈值" },
         //   { WellCurveTrackFillType.RightThreshold, "右阈值" },
        };

        public static readonly Dictionary<WellCurveTrackFillType, string> XmlMaps = new Dictionary<WellCurveTrackFillType, string>()
        {
            { WellCurveTrackFillType.LeftBorder, "Left" },
            { WellCurveTrackFillType.RightBorder, "Right" },
            { WellCurveTrackFillType.LeftThreshold, "LeftValue" },
            { WellCurveTrackFillType.RightThreshold, "RightValue" },
        };

        protected override Dictionary<WellCurveTrackFillType, string> CreateMaps()
        {
            return Maps;
        }
    }

    /// <summary>
    /// 画刷类型
    /// </summary>
    public enum WellCurveTrackBrushType
    {
        None,
        SingleColor,
        Picture,
        GradientColor,
    }

    public class WellCurveTrackBrushTypeConverter : EnumConverter<WellCurveTrackBrushType>
    {
        public static readonly Dictionary<WellCurveTrackBrushType, string> Maps = new Dictionary<WellCurveTrackBrushType, string>
        {
            { WellCurveTrackBrushType.None, string.Empty },
            { WellCurveTrackBrushType.SingleColor, "单色" },
            { WellCurveTrackBrushType.Picture, "图案" },
           // { WellCurveTrackBrushType.GradientColor, "渐变色" },
        };

        protected override Dictionary<WellCurveTrackBrushType, string> CreateMaps()
        {
            return Maps;
        }
    }

    /// <summary>
    /// 标注格式
    /// 0.# 到 0.##### 表示 可选小数位数，例如：0.## 格式可以显示 1、1.1、1.12，但不强制补零
    /// 0.0 到 0.00000 表示 固定小数位数，例如：0.00 会将 1 显示为 1.00
    /// </summary>
    public enum WellCurveTrackLabelFormat
    {
        Optional1 = 1,   // 对应 0.#
        Optional2 = 2,   // 对应 0.##
        Optional3 = 3,   // 对应 0.###
        Optional4 = 4,   // 对应 0.####
        Fixed1 = 101,    // 对应 0.0
        Fixed2 = 102,    // 对应 0.00
        Fixed3 = 103,    // 对应 0.000
        Fixed4 = 104,    // 对应 0.0000
    }

    public class WellCurveTrackLabelFormatConverter : EnumConverter<WellCurveTrackLabelFormat>
    {
        public static readonly Dictionary<WellCurveTrackLabelFormat, string> Maps = new Dictionary<WellCurveTrackLabelFormat, string>
        {
            { WellCurveTrackLabelFormat.Optional1, "0.#" },
            { WellCurveTrackLabelFormat.Optional2, "0.##" },
            { WellCurveTrackLabelFormat.Optional3, "0.###" },
            { WellCurveTrackLabelFormat.Optional4, "0.####" },
            { WellCurveTrackLabelFormat.Fixed1,  "0.0" },
            { WellCurveTrackLabelFormat.Fixed2,  "0.00" },
            { WellCurveTrackLabelFormat.Fixed3,  "0.000" },
            { WellCurveTrackLabelFormat.Fixed4,  "0.0000" },
        };

        protected override Dictionary<WellCurveTrackLabelFormat, string> CreateMaps()
        {
            return Maps;
        }
    }

    /// <summary>
    /// 充填曲线
    /// </summary>
    public enum WellCurveTrackFillCurve
    {
        None,
        SP,
        LLD,
        LLS,
        AC,
    }

    public class WellCurveTrackFillCurveConverter : EnumConverter<WellCurveTrackFillCurve>
    {
        public static readonly Dictionary<WellCurveTrackFillCurve, string> Maps = new Dictionary<WellCurveTrackFillCurve, string>
        {
            { WellCurveTrackFillCurve.None, "" },
            { WellCurveTrackFillCurve.SP, "SP" },
            { WellCurveTrackFillCurve.LLD, "LLD" },
            { WellCurveTrackFillCurve.LLS, "LLS" },
            { WellCurveTrackFillCurve.AC, "AC" },
        };

        protected override Dictionary<WellCurveTrackFillCurve, string> CreateMaps()
        {
            return Maps;
        }
    }

    public enum WellCurveTrackStyle
    {
        Curve,
        Step,
    }

    public class WellCurveTrackStyleConverter : EnumConverter<WellCurveTrackStyle>
    {
        public static readonly Dictionary<WellCurveTrackStyle, string> Maps = new Dictionary<WellCurveTrackStyle, string>
        {
            { WellCurveTrackStyle.Curve, "曲线" },
            { WellCurveTrackStyle.Step, "阶梯" },
        };

        protected override Dictionary<WellCurveTrackStyle, string> CreateMaps()
        {
            return Maps;
        }
    }

    public enum WellCurveScatter
    {
        None,
        Scatter,
    }

    public class WellCurveTrackCurveScatterConverter : EnumConverter<WellCurveScatter>
    {
        public static readonly Dictionary<WellCurveScatter, string> Maps = new Dictionary<WellCurveScatter, string>
        {
            { WellCurveScatter.None, "" },
            { WellCurveScatter.Scatter, "散点" },
        };

        protected override Dictionary<WellCurveScatter, string> CreateMaps()
        {
            return Maps;
        }
    }

    /// <summary>
    /// 曲线道
    /// </summary>
    [XmlRoot("Pcg")]
    [TypeConverter(typeof(PropertySorter))]
    public class WellCurveTrack : WellObjectXmlBase
    {
        //public WellCurveTrack()
        //{
        //    wellPoleContext = new WellPoleContext();
        //}
        private const string CurveTrackCategory = "\t\t\t\t\t曲线道";
        private const string GridCategory = "\t\t\t\t网格";
        private const string FillCategory = "\t\t\t充填";
        private const string CurveStyleCategory = "\t\t曲线风格";
        private const string PointSymbolCategory = "\t点符号";

        // 曲线道
        [XmlIgnore]
        [Category(CurveTrackCategory)]
        [DisplayName("标题"), PropertyOrder(0)]
        public string Title
        {
            get => CurveTrack.Title.Font.Text;
            set => CurveTrack.Title.Font.Text = value;
        }

        [XmlIgnore]
        [Category(CurveTrackCategory)]
        [DisplayName("曲线名称"), PropertyOrder(1)]
        [TypeConverter(typeof(curveNamesConverter))]
        public string CurveName
        {
            get => CurveTrack.Name;
            set
            {
                if(CurveTrack.Name != value)
                {
                    CurveTrack.bRefreshWorkAreaData = true;
                }
                CurveTrack.Name = value;
            }
        }

        [XmlIgnore]
        [Category(CurveTrackCategory)]
        [DisplayName("左值"), PropertyOrder(2)]
        public double LeftValue
        {
            get => CurveTrack.Left;
            set => CurveTrack.Left = value;
        }

        [XmlIgnore]
        [Category(CurveTrackCategory)]
        [DisplayName("右值"), PropertyOrder(3)]
        public double RightValue
        {
            get => CurveTrack.Right;
            set => CurveTrack.Right = value;
        }

        [XmlIgnore]
        [Category(CurveTrackCategory)]
        [DisplayName("标注格式"), PropertyOrder(4)]
        [TypeConverter(typeof(WellCurveTrackLabelFormatConverter))]
        public WellCurveTrackLabelFormat LabelFormat
        {
            get => DictionaryHelper.Reverse(WellCurveTrackLabelFormatConverter.Maps)[CurveTrack.GridStyle.Format];
            set => CurveTrack.GridStyle.Format = WellCurveTrackLabelFormatConverter.Maps[value];
        }

        [XmlIgnore]
        [Category(CurveTrackCategory)]
        [DisplayName("对数"), PropertyOrder(5)]
        [TypeConverter(typeof(YesNoConverter))]
        public bool IsLogarithmic
        {
            get => CurveTrack.Mode == "Log";
            set
            {
                // 这两个必须一定，不然显示会有问题
                CurveTrack.Mode = value ? "Log" : "Default";
                CurveTrack.CurveStyle.ShowStyle = CurveTrack.Mode;
            }
        }

        [XmlIgnore]
        [Category(CurveTrackCategory)]
        [DisplayName("宽度"), PropertyOrder(6)]
        public double Width
        {
            get => CurveTrack.Width;
            set => CurveTrack.Width = value;
        }

        [XmlIgnore]
        [Category(CurveTrackCategory)]
        [DisplayName("道头字体"), PropertyOrder(7)]
        [Editor(typeof(PropertyEditorWellFontEx), typeof(UITypeEditor))]
        public WellFontEx HeaderFont
        {
            get => CurveTrack.Title.Font;
            set => CurveTrack.Title.Font = value;
        }

        [XmlIgnore]
        [Category(CurveTrackCategory)]
        [DisplayName("显示曲线横线"), PropertyOrder(9)]
        [TypeConverter(typeof(YesNoConverter))]
        public bool ShowCurveLinear
        {
            get => CurveTrack.ShowLine;
            set => CurveTrack.ShowLine = value;
        }

        [XmlIgnore]
        [Category(CurveTrackCategory)]
        [DisplayName("曲线显示样式"), PropertyOrder(10)]
        [TypeConverter(typeof(YesNoConverter))]
        public bool CurveDisplayStyle
        {
            get => CurveTrack.CurveStyle.Visiable;
            set => CurveTrack.CurveStyle.Visiable = value;
        }

        // 网格
        [XmlIgnore]
        [Category(GridCategory)]
        [DisplayName("显示网格"), PropertyOrder(11)]
        [TypeConverter(typeof(YesNoConverter))]
        public bool ShowGrid
        {
            get => CurveTrack.GridStyle.Visiable;
            set
            {
                // 在 pcg 中定义中，这两个是不同含义，
                // 但是在咱们的系统中它们表示含义相同，同步设置
                CurveTrack.GridStyle.Visiable = value;
                CurveTrack.GridStyle.IsDrawScale = value;
            }
        }

        [XmlIgnore]
        [Category(GridCategory)]
        [DisplayName("主刻度个数"), PropertyOrder(13)]
        public double MajorTicks
        {
            get => CurveTrack.GridStyle.MajorSpace;
            set => CurveTrack.GridStyle.MajorSpace = value;
        }

        [XmlIgnore]
        [Category(GridCategory)]
        [DisplayName("次刻度个数"), PropertyOrder(14)]
        public double MinorTicks
        {
            get => CurveTrack.GridStyle.MinorSpace;
            set => CurveTrack.GridStyle.MinorSpace = value;
        }

        [XmlIgnore]
        [Category(FillCategory)]
        [DisplayName("充填方式"), PropertyOrder(15)]
        [TypeConverter(typeof(WellCurveTrackFillTypeConverter))]
        public WellCurveTrackFillType FillMode
        {
            get => DictionaryHelper.Reverse(WellCurveTrackFillTypeConverter.XmlMaps)[CurveTrack.FillStyle.Mode];
            set => CurveTrack.FillStyle.Mode = WellCurveTrackFillTypeConverter.XmlMaps[value];
        }

        private static Dictionary<WellCurveTrackBrushType, string> fillModeMap = new Dictionary<WellCurveTrackBrushType, string>()
        {
            { WellCurveTrackBrushType.None, string.Empty },
            { WellCurveTrackBrushType.SingleColor, "Solid" },
            { WellCurveTrackBrushType.Picture, "Hatch" },  //目前没有渐变色对话框，就先省略
        };

        [XmlIgnore]
        [Category(FillCategory)]
        [DisplayName("画刷类型"), PropertyOrder(16)]
        [TypeConverter(typeof(WellCurveTrackBrushTypeConverter))]
        public WellCurveTrackBrushType BrushType
        {
            get => DictionaryHelper.Reverse(fillModeMap)[CurveTrack.FillMode];
            set => CurveTrack.FillMode = fillModeMap[value];
        }

        [XmlIgnore]
        [Category(FillCategory)]
        [DisplayName("充填颜色"), PropertyOrder(17)]
        [Editor(typeof(PropertyEditorColor), typeof(UITypeEditor))]
        public Color FillColor
        {
            get => CurveTrack.FillStyle.BackColor;
            set => CurveTrack.FillStyle.BackColor = value;
        }

        [XmlIgnore]
        [Category(FillCategory)]
        [DisplayName("充填符号"), PropertyOrder(18)]
        [Editor(typeof(PropertyEditorFillSymbol), typeof(UITypeEditor))]
        public string FillSymbol
        {
            get => CurveTrack.FillStyle.Pattern;
            set => CurveTrack.FillStyle.Pattern = value;
        }

        //[XmlIgnore]
        //[Category(FillCategory)]
        //[DisplayName("充填曲线"), PropertyOrder(19)]
        //[TypeConverter(typeof(WellCurveTrackFillCurveConverter))]
        //public WellCurveTrackFillCurve FillCurve
        //{
        //    get => DictionaryHelper.Reverse(WellCurveTrackFillCurveConverter.Maps)[CurveTrack.FillStyle.SideTrack];
        //    set => CurveTrack.FillStyle.SideTrack = WellCurveTrackFillCurveConverter.Maps[value];
        //}
        [XmlIgnore]
        [Category(FillCategory)]
        [DisplayName("充填曲线"), PropertyOrder(19)]
        [TypeConverter(typeof(fillCurveNamesConverter))]
        public string FillCurve
        {
            get=> CurveTrack.FillStyle.SideTrack;
            set=> CurveTrack.FillStyle.SideTrack = value;
        }

        [XmlIgnore]
        [Category(FillCategory)]
        [DisplayName("显示充填曲线"), PropertyOrder(20)]
        [TypeConverter(typeof(YesNoConverter))]
        public bool ShowFillCurve
        {
            get => CurveTrack.FillStyle.CurveVisiable;
            set => CurveTrack.FillStyle.CurveVisiable = value;
        }

        [XmlIgnore]
        [Category(FillCategory)]
        [DisplayName("渐进色填充设置"), PropertyOrder(20)]
        [Editor(typeof(PropertyEditorFillCurveGradient), typeof(UITypeEditor))]
        public WellTrackGradientStyle GradientStyle
        {
            get => CurveTrack.FillStyle.GradientStyle;
            set => CurveTrack.FillStyle.GradientStyle = value;
        }


        // 曲线风格
        [XmlIgnore]
        [Category(CurveStyleCategory)]
        [DisplayName("样式"), PropertyOrder(21)]
        [TypeConverter(typeof(WellCurveTrackStyleConverter))]
        public WellCurveTrackStyle Style
        {
            get => CurveTrack.CurveStyle.IsStep ? WellCurveTrackStyle.Step : WellCurveTrackStyle.Curve;
            set => CurveTrack.CurveStyle.IsStep = value == WellCurveTrackStyle.Step;
        }

        [XmlIgnore]
        [Category(CurveStyleCategory)]
        [DisplayName("曲线类型"), PropertyOrder(22)]
        [Editor(typeof(PropertyEditorWellCurveStyle), typeof(UITypeEditor))]
        public WellLineStyle CurveType
        {
            get => new WellLineStyle()
            {
                Color = CurveTrack.CurveStyle.Color,
                Width = CurveTrack.CurveStyle.Width,
                Style = CurveTrack.CurveStyle.Dash,
            };

            set
            {
                CurveTrack.CurveStyle.Color = value.Color;
                CurveTrack.CurveStyle.Width = value.Width;
                CurveTrack.CurveStyle.Dash = value.Style;
            }
        }

        // 点符号
        [XmlIgnore]
        [Category(PointSymbolCategory)]
        [DisplayName("散点"), PropertyOrder(23)]
        [TypeConverter(typeof(WellCurveTrackCurveScatterConverter))]
        public WellCurveScatter Scatter
        {
            get => string.IsNullOrWhiteSpace(CurveTrack.SymbolStyle.Name) ? WellCurveScatter.None : WellCurveScatter.Scatter;
            set => CurveTrack.SymbolStyle.Name = WellCurveTrackCurveScatterConverter.Maps[value];
        }

        [XmlIgnore]
        [Category(PointSymbolCategory)]
        [DisplayName("符号"), PropertyOrder(24)]
        [ListBoxEditor("PointType")]
        [Editor(typeof(PropertyEditorListBox), typeof(UITypeEditor))]
        public string Symbol
        {
            get => CurveTrack.SymbolStyle.Name;
            set => CurveTrack.SymbolStyle.Name = value;
        }

        [XmlIgnore]
        [Category(PointSymbolCategory)]
        [DisplayName("符号边框颜色"), PropertyOrder(25)]
        [Editor(typeof(PropertyEditorColor), typeof(UITypeEditor))]
        public Color SymbolBorderColor
        {
            get => CurveTrack.SymbolStyle.ForeColor;
            set => CurveTrack.SymbolStyle.ForeColor = value;
        }

        [XmlIgnore]
        [Category(PointSymbolCategory)]
        [DisplayName("符号填充颜色"), PropertyOrder(26)]
        [Editor(typeof(PropertyEditorColor), typeof(UITypeEditor))]
        public Color SymbolFillColor
        {
            get => CurveTrack.SymbolStyle.BackColor;
            set => CurveTrack.SymbolStyle.BackColor = value;
        }

        [XmlIgnore]
        [Category(PointSymbolCategory)]
        [DisplayName("符号大小"), PropertyOrder(27)]
        public double SymbolSize
        {
            get => CurveTrack.SymbolStyle.SizeWidth;
            set => CurveTrack.SymbolStyle.SizeWidth = value;
        }

        [Browsable(false)]
        [XmlAttribute("Version")]
        public string Version { get; set; }

        [Browsable(false)]
        [XmlElement("WellTrack")]
        public WellTrackWellTrack CurveTrack { get; set; }

        //[Browsable(false)]
        //[XmlIgnore]
        //public WellPoleContext wellPoleContext { get; set; }
    }

    public static class DataServiceFillCurveNames
    {
        public static string[] GetAvailableOptions(Object param1)
        {
            string[] names = new string[0];
            if (param1 is WellCurveTrack settings)
            { 
                if(settings.wellPoleContext.geoWellPole.GetWellAllCurveNames(settings.wellPoleContext.wellObjHandle,out string[] NamesArr) == true)
                {
                    List<string> slist = new List<string>(NamesArr);
                    slist.Insert(0, "");
                   // slist.Remove(settings.CurveName);

                    return slist.ToArray();
                }
            }

            return names;
        }
    }

    public class fillCurveNamesConverter : GenericWellOptionsConverter<WellCurveTrack>
    {
        public fillCurveNamesConverter() : base(settings => DataServiceFillCurveNames.GetAvailableOptions(settings))
        { }
    }

    public static class DataServiceDbCurveNames
    {
        public static string[] GetAvailableOptions(Object param1)
        {
            string[] names = new string[0];
            if (param1 is WellCurveTrack settings)
            {
               // if (settings.wellPoleContext.geoWellPole.GetWellBaseInfo(settings.wellPoleContext.wellObjHandle, out GeoSigmaWellPoleXY.WellBaseInfo wellinfo) == true)
               // {
                    if (settings.wellPoleContext.wellName != "" && settings.wellPoleContext.workArea != null)
                    {
                        if (settings.wellPoleContext.bReadCurveTable == false)
                        {
                            settings.wellPoleContext.bReadCurveTable = true;
                            settings.wellPoleContext.curveTable = new DataTable();
                            DataTable curvesTable = settings.wellPoleContext.curveTable;
                            settings.wellPoleContext.workArea.getCurvesData(settings.wellPoleContext.wellName, ref curvesTable);
                        }

                        names = new string[settings.wellPoleContext.curveTable.Columns.Count+1];
                        names[0] = "";
                        for (int i = 0; i < settings.wellPoleContext.curveTable.Columns.Count; i++)
                        {
                            names[i+1] = settings.wellPoleContext.curveTable.Columns[i].ColumnName;
                        }
                    }
                //}
            }

            return names;
        }
    }

    public class curveNamesConverter : GenericWellOptionsConverter<WellCurveTrack>
    {
        public curveNamesConverter() : base(settings => DataServiceDbCurveNames.GetAvailableOptions(settings))
        { }
    }

    //public static class DataServiceDbCurveNames
    //{
    //    public static string[] GetCurveNames(WellPoleContext wContext)
    //    {
    //        string[] names = new string[0];

    //        if(wContext.geoWellPole.GetWellBaseInfo(wContext.wellObjHandle,out GeoSigmaWellPoleXY.WellBaseInfo wellinfo) == true)
    //        {
    //            if(wellinfo.wellName != "" && wContext.workArea != null)
    //            {
    //                DataTable curvesTable = new DataTable();
    //               // ResultDataInfo qCurveResult = new ResultDataInfo();
    //                wContext.workArea.getCurvesData(wellinfo.wellName, ref curvesTable);
    //                // curvesTable.Columns
    //                names = new string[curvesTable.Columns.Count];
    //                for(int i = 0; i < curvesTable.Columns.Count; i++ )
    //                {
    //                    names[i] = curvesTable.Columns[i].ColumnName;
    //                }
    //            }
    //        }

    //        return names;
    //    }
    //}


    //public class curveNamesConverter : TypeConverter
    //{
    //    public override bool GetStandardValuesSupported(ITypeDescriptorContext context) => true;
    //    public override bool GetStandardValuesExclusive(ITypeDescriptorContext context) => true;

    //    public override StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
    //    {
    //        if (context?.Instance is WellCurveTrack settings)
    //        {
    //            var options = DataServiceDbCurveNames.GetCurveNames(settings.wellPoleContext);
    //            //var options = GetUserSpecificOptions(settings.UserId);
    //            return new StandardValuesCollection(options);
    //        }
    //        return new StandardValuesCollection(new string[0]);

    //    }
    //}


#pragma warning restore SA1649 // File name should match first type name
#pragma warning restore SA1600 // Elements should be documented
#pragma warning restore SA1402 // File may only contain a single type
}