HEGII.ss.mes.wcf/DK.Basics/BaseControls/ExportExcel/UPOI/U_HLine.cs

using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Drawing;
using System.Reflection;
using System.Windows.Forms;
using Microsoft.VisualBasic;
using Microsoft.VisualBasic.CompilerServices;

namespace Dongke.IBOSS.PRD.Framework.Controls
{

	[ToolboxItem(false)]
	[Browsable(false)]
	[EditorBrowsable(EditorBrowsableState.Never)]
	[DesignerGenerated]
	public class U_HLine : UserControl, ICustomTypeDescriptor, IControl
	{
		private class XpropDescriptor : PropertyDescriptor
		{
			private string theProp;

			private U_HLine mycc;

			public override Type ComponentType => GetType();

			public override bool IsReadOnly => false;

			public override Type PropertyType
			{
				get
				{
					switch (theProp.ToLower())
					{
						case "isprint":
							return mycc.IsPrint.GetType();
						case "x":
							return mycc.X.GetType();
						case "y":
							return mycc.Y.GetType();
						case "ewidth":
							return mycc.EWidth.GetType();
						case "linewidth":
							return mycc.LineWidth.GetType();
						case "linecolor":
							return mycc.LineColor.GetType();
						default:
							Interaction.MsgBox("Property过程编程错误,属性名称[" + theProp + "]未找到");
							return null;
					}
				}
			}

			public XpropDescriptor(U_HLine cc, string prop, Attribute[] attrs)
				: base(prop, attrs)
			{
				theProp = cc.GetPropertyEnglishName(prop);
				mycc = cc;
			}

			public override bool CanResetValue(object component)
			{
				return false;
			}

			public override object GetValue(object component)
			{
				switch (theProp.ToLower())
				{
					case "isprint":
						return mycc.IsPrint;
					case "x":
						return mycc.X;
					case "y":
						return mycc.Y;
					case "ewidth":
						return mycc.EWidth;
					case "linewidth":
						return mycc.LineWidth;
					case "linecolor":
						return mycc.LineColor;
					default:
						Interaction.MsgBox("GetValue过程编程错误,属性名称[" + theProp + "]未找到");
						return null;
				}
			}

			public override void ResetValue(object component)
			{
			}

			public override void SetValue(object component, object value)
			{
				switch (theProp.ToLower())
				{
					case "isprint":
						mycc.IsPrint = Conversions.ToBoolean(value);
						break;
					case "x":
						mycc.X = Conversions.ToSingle(value);
						break;
					case "y":
						mycc.Y = Conversions.ToSingle(value);
						break;
					case "ewidth":
						mycc.EWidth = Conversions.ToSingle(value);
						break;
					case "linewidth":
						mycc.LineWidth = Conversions.ToSingle(value);
						break;
					case "linecolor":
						{
							Color black = Color.Black;
							mycc.LineColor = ((value != null) ? ((Color)value) : black);
							break;
						}
					default:
						Interaction.MsgBox("SetValue过程编程错误,属性名称[" + theProp + "]未找到");
						break;
				}
			}

			public override bool ShouldSerializeValue(object component)
			{
				return false;
			}
		}

		private IContainer components;

		private float MYX;

		private float MYY;

		private bool theisprint;

		private float thelinewidth;

		private Color thelinecolor;

		private string[,] DefineProperty;

		[Category("行为")]
		[Description("以套打模式打印或预览时，是否打印该控件的内容")]
		public bool IsPrint
		{
			get
			{
				return theisprint;
			}
			set
			{
				theisprint = value;
			}
		}

		[Category("布局")]
		[Description("控件所处的X位置,以毫米为计量单位")]
		public float X
		{
			get
			{
				return ConvertToMM(base.Left, isX: true);
			}
			set
			{
				base.Left = checked((int)Math.Round(ConvertFromMM(value, isx: true)));
			}
		}

		[Description("控件所处的Y位置,以毫米为计量单位")]
		[Category("布局")]
		public float Y
		{
			get
			{
				return ConvertToMM(base.Top, isX: false);
			}
			set
			{
				base.Top = checked((int)Math.Round(ConvertFromMM(value, isx: false)));
			}
		}

		[Category("布局")]
		[Description("控件的宽度,以毫米为计量单位")]
		public float EWidth
		{
			get
			{
				return ConvertToMM(base.Width, isX: true);
			}
			set
			{
				base.Width = checked((int)Math.Round(ConvertFromMM(value, isx: true)));
			}
		}

		[Category("外观")]
		[Description("直线的线宽,不是直线的长度,以毫米为计量单位,最小必须为0.15毫米")]
		public float LineWidth
		{
			get
			{
				return thelinewidth;
			}
			set
			{
				if ((double)value < 0.15)
				{
					value = 0.15f;
				}
				thelinewidth = value;
				base.Height = checked((int)Math.Round(ConvertFromMM(value, isx: true)));
				Invalidate();
			}
		}

		[Category("外观")]
		[Description("线条颜色")]
		public Color LineColor
		{
			get
			{
				return thelinecolor;
			}
			set
			{
				thelinecolor = value;
				Invalidate();
			}
		}

		[DebuggerNonUserCode]
		protected override void Dispose(bool disposing)
		{
			try
			{
				if (disposing && components != null)
				{
					components.Dispose();
				}
			}
			finally
			{
				base.Dispose(disposing);
			}
		}

		[System.Diagnostics.DebuggerStepThrough]
		private void InitializeComponent()
		{
			base.SuspendLayout();
			System.Drawing.SizeF sizeF = new System.Drawing.SizeF(6f, 12f);
			base.AutoScaleDimensions = sizeF;
			base.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
			this.BackColor = System.Drawing.Color.White;
			base.Name = "Hline";
			System.Drawing.Size size = new System.Drawing.Size(169, 37);
			base.Size = size;
			base.ResumeLayout(false);
		}

		public float ConvertToMM(float tt, bool isX)
		{
			if (isX)
			{
				return (float)Math.Round((double)(tt / MYX) * 2.54 * 10.0, 2);
			}
			return (float)Math.Round((double)(tt / MYY) * 2.54 * 10.0, 2);
		}

		public float ConvertFromMM(float tt, bool isx)
		{
			if (isx)
			{
				return (float)((double)(tt * MYX) / 2.54 / 10.0);
			}
			return (float)((double)(tt * MYY) / 2.54 / 10.0);
		}

		public string GetPropertyEnglishName(string cname)
		{
			bool flag = false;
			int num = 0;
			checked
			{
				int num2 = DefineProperty.GetLength(0) - 1;
				int i;
				for (i = num; i <= num2; i++)
				{
					if (Operators.CompareString(DefineProperty[i, 1].ToUpper(), cname.ToUpper(), TextCompare: false) == 0)
					{
						flag = true;
						break;
					}
				}
				if (flag)
				{
					return DefineProperty[i, 0];
				}
				return cname;
			}
		}

		public string GetPropertyChineseName(string ename)
		{
			bool flag = false;
			int num = 0;
			checked
			{
				int num2 = DefineProperty.GetLength(0) - 1;
				int i;
				for (i = num; i <= num2; i++)
				{
					if (Operators.CompareString(DefineProperty[i, 0].ToUpper(), ename.ToUpper(), TextCompare: false) == 0)
					{
						flag = true;
						break;
					}
				}
				if (flag)
				{
					return DefineProperty[i, 1];
				}
				return ename;
			}
		}

		protected override void OnPaint(PaintEventArgs e)
		{
			base.OnPaint(e);
			float num = ConvertFromMM(LineWidth, isx: true);
			Pen pen = new Pen(LineColor, num);
			e.Graphics.DrawLine(pen, 0f, num / 2f, base.Width, num / 2f);
		}

		protected override void OnResize(EventArgs e)
		{
			base.OnResize(e);
			Invalidate();
		}

		public U_HLine()
		{
			base.Disposed += Hline_Disposed;
			theisprint = true;
			thelinewidth = 0.26f;
			thelinecolor = Color.Black;
			DefineProperty = new string[3, 2];
			InitializeComponent();
			MYX = CreateGraphics().DpiX;
			MYY = CreateGraphics().DpiY;
			DefineProperty = new string[6, 2];
			DefineProperty[0, 0] = "IsPrint";
			DefineProperty[0, 1] = "是否套打";
			DefineProperty[1, 0] = "X";
			DefineProperty[1, 1] = "X位置";
			DefineProperty[2, 0] = "Y";
			DefineProperty[2, 1] = "Y位置";
			DefineProperty[3, 0] = "EWidth";
			DefineProperty[3, 1] = "宽度";
			DefineProperty[4, 0] = "LineWidth";
			DefineProperty[4, 1] = "线宽";
			DefineProperty[5, 0] = "LineColor";
			DefineProperty[5, 1] = "线条颜色";
		}

		public AttributeCollection GetAttributes()
		{
			return TypeDescriptor.GetAttributes(this, noCustomTypeDesc: true);
		}

		public string GetClassName()
		{
			return TypeDescriptor.GetClassName(this, noCustomTypeDesc: true);
		}

		public string GetComponentName()
		{
			return TypeDescriptor.GetClassName(this, noCustomTypeDesc: true);
		}

		public TypeConverter GetConverter()
		{
			return TypeDescriptor.GetConverter(this, noCustomTypeDesc: true);
		}

		public EventDescriptor GetDefaultEvent()
		{
			return TypeDescriptor.GetDefaultEvent(this, noCustomTypeDesc: true);
		}

		public PropertyDescriptor GetDefaultProperty()
		{
			return TypeDescriptor.GetDefaultProperty(this, noCustomTypeDesc: true);
		}

		public object GetEditor(Type editorBaseType)
		{
			return TypeDescriptor.GetEditor(this, editorBaseType, noCustomTypeDesc: true);
		}

		public EventDescriptorCollection GetEvents()
		{
			return TypeDescriptor.GetEvents(this, noCustomTypeDesc: true);
		}

		public EventDescriptorCollection GetEvents(Attribute[] attributes)
		{
			return TypeDescriptor.GetEvents(this, attributes, noCustomTypeDesc: true);
		}

		public PropertyDescriptorCollection GetProperties()
		{
			return TypeDescriptor.GetProperties(this, noCustomTypeDesc: true);
		}

		public PropertyDescriptorCollection GetProperties(Attribute[] attributes)
		{
			checked
			{
				PropertyDescriptor[] array = new PropertyDescriptor[DefineProperty.GetLength(0) - 1 + 1];
				int num = 0;
				int num2 = array.Length - 1;
				for (int i = num; i <= num2; i++)
				{
					Type type = GetType();
					PropertyInfo[] properties = type.GetProperties();
					PropertyInfo[] array2 = properties;
					foreach (PropertyInfo propertyInfo in array2)
					{
						if (Operators.CompareString(propertyInfo.Name.ToUpper(), DefineProperty[i, 0].ToUpper(), TextCompare: false) == 0)
						{
							attributes = Attribute.GetCustomAttributes(propertyInfo);
							break;
						}
					}
					array[i] = new XpropDescriptor(this, DefineProperty[i, 1], attributes);
				}
				return new PropertyDescriptorCollection(array);
			}
		}

		public object GetPropertyOwner(PropertyDescriptor pd)
		{
			return this;
		}

		private void Hline_Disposed(object sender, EventArgs e)
		{
			try
			{
				DefineProperty = null;
			}
			catch (Exception projectError)
			{
				ProjectData.SetProjectError(projectError);
				ProjectData.ClearProjectError();
			}
		}

		public void RestoreFromString(string ss)
		{
			string[] array = Strings.Split(ss, mbsjmodule.G_MB_Spetator_Proper);
			if (Operators.CompareString(array[0], "1", TextCompare: false) == 0)
			{
				IsPrint = true;
			}
			else
			{
				IsPrint = false;
			}
			X = Conversions.ToSingle(array[1]);
			Y = Conversions.ToSingle(array[2]);
			EWidth = Conversions.ToSingle(array[3]);
			LineWidth = Conversions.ToSingle(array[4]);
			LineColor = Module1.ConvertStringToColor(array[5]);
			base.Tag = "横线";
		}

		public string SaveAsString()
		{
			string text = ((!IsPrint) ? "0" : "1");
			text = text + mbsjmodule.G_MB_Spetator_Proper + Conversions.ToString(X);
			text = text + mbsjmodule.G_MB_Spetator_Proper + Conversions.ToString(Y);
			text = text + mbsjmodule.G_MB_Spetator_Proper + Conversions.ToString(EWidth);
			text = text + mbsjmodule.G_MB_Spetator_Proper + Conversions.ToString(LineWidth);
			return text + mbsjmodule.G_MB_Spetator_Proper + Module1.ConvertColorToString(LineColor);
		}
	}
}