Win32/UI/MaskedHexBox.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Text;
using System.Windows.Forms;
using System.Runtime.InteropServices;

namespace System.Windows.Forms
{
    public partial class MaskedHexBox : UserControl
    {
        public MaskedHexBox()
        {
            InitializeComponent();
            SetStyle(
                 ControlStyles.AllPaintingInWmPaint |
                 ControlStyles.OptimizedDoubleBuffer |
                 ControlStyles.UserPaint |
                 ControlStyles.ContainerControl,
                 true);
            this.isAddressMask = true;
            txtMaskedHexBox.KeyDown += new KeyEventHandler(txtMaskedHexBox_KeyDown);
            txtMaskedHexBox.TextAlign = HorizontalAlignment.Right;

        }

        private void MaskedHexBox_KeyDown(object sender, KeyEventArgs e)
        {
        }

        private void MaskedHexBox_KeyPress(object sender, KeyPressEventArgs e)
        {
        }

        void txtMaskedHexBox_KeyDown(object sender, KeyEventArgs e)
        {

            if (e.KeyCode > Keys.F && e.KeyCode <= Keys.Z && !e.Control && !e.Alt)
            {
                e.SuppressKeyPress = true;
            }
        }


        new public Font Font
        {
            get { return base.Font; }
            set
            {
                base.Font = value;
                txtMaskedHexBox.Font = value;
                btnCopy.Font = value;
                btnPaste.Font = value;
            }
        }

        private string Mask
        {
            get { return txtMaskedHexBox.Mask; }
            set { txtMaskedHexBox.Mask = value; }
        }

        private bool _ReadOnly;
        public virtual bool ReadOnly
        {
            get { return _ReadOnly; }
            set { _ReadOnly = value; if (_ReadOnly) { txtMaskedHexBox.Enabled = false; } else { txtMaskedHexBox.Enabled = true; } }
        }
        public override string Text
        {
            get { return txtMaskedHexBox.Text.PadRight(this.TextLength + 2, '0'); }
            set { txtMaskedHexBox.Text = value; }
        }
        public ulong Value
        {
            get { return this.ToUInt64(); }
            set
            {
                switch (this.TextLength)
                {
                    case 0:
                    case 1:
                    case 2: this.Text = string.Format("0x{0:x2}", value); break;
                    case 3:
                    case 4: this.Text = string.Format("0x{0:x4}", value); break;
                    case 5:
                    case 6:
                    case 7:
                    case 8: this.Text = string.Format("0x{0:x8}", value); break;
                    default: this.Text = string.Format("0x{0:x" + this.TextLength + "}", value); break;
                }
            }
        }
        private bool _isAddressMask;
        public bool isAddressMask
        {
            get { return _isAddressMask; }
            set
            {
                _isAddressMask = value;
                if (value)
                {
                    this.CreateTypeSize<uint>();
                }
            }
        }

        public void CreateTypeSize<T>() where T : IConvertible
        {
            Type type = typeof(T);
            this.TextLength = Marshal.SizeOf(type) * 2;
            this.MaxLength = this.TextLength;
        }

        private int _MaxLength;
        public int MaxLength
        {
            get { return _MaxLength; }
            set { _MaxLength = value; }
        }
        private int _TextLength;
        public int TextLength
        {
            get { return _TextLength; }
            set
            {
                StringBuilder mask = new StringBuilder();

                mask.Append("\\0x");

                if (this.MaxLength <= sizeof(uint) * 2)
                {

                    switch (value)
                    {
                        case 0:
                        case 1:
                        case 2: _TextLength = 2; mask.Append(this.CreateMask(_TextLength)); break;
                        case 3:
                        case 4: _TextLength = 4; mask.Append(this.CreateMask(_TextLength)); break;
                        case 5:
                        case 6:
                        case 7:
                        case 8:
                        default: _TextLength = 8; mask.Append(this.CreateMask(_TextLength)); break;
                    }
                }
                else
                {
                    switch (value)
                    {
                        case 0:
                        case 1:
                        case 2: _TextLength = 2; mask.Append(this.CreateMask(_TextLength)); break;
                        case 3:
                        case 4: _TextLength = 4; mask.Append(this.CreateMask(_TextLength)); break;
                        case 5:
                        case 6:
                        case 7:
                        case 8: _TextLength = 8; mask.Append(this.CreateMask(_TextLength)); break;
                        default: _TextLength = value; mask.Append(this.CreateMask(_TextLength)); break;
                    }
                }
                this.Mask = mask.ToString();
            }
        }
        private string CreateMask(int length)
        {
            StringBuilder mask = new StringBuilder();
            for (int i = 0; i < length; i++)
            {
                mask.Append("C");
            }
            return mask.ToString();
        }

        private void btnCopy_Click(object sender, EventArgs e) { Clipboard.SetData(DataFormats.Text, this.Text); }
        private void btnPaste_Click(object sender, EventArgs e) { if (this.ReadOnly) return; this.Text = (string)Clipboard.GetData(DataFormats.Text); }

        private void txtMaskedHexBox_MaskInputRejected(object sender, MaskInputRejectedEventArgs e)
        {

        }


    }

    #region MaskedHexBox Extensions
    public static class MaskedHexBoxExtensions
    {
        private static string GetSafeConversionString(this MaskedHexBox val)
        {
            StringBuilder builder = new StringBuilder();

            if (val.Text == "0x")
            {
                builder.Append("0x");
                for (int i = 0; i < val.TextLength; i++)
                {
                    builder.Append("0");
                }
            }
            else
                builder.Append(val.Text.Replace(" ", ""));
            return builder.ToString();
        }
        public static byte ToByte(this MaskedHexBox val)
        {
            try { return Convert.ToByte(val.GetSafeConversionString(), 16); }
            catch { return 0; }
        }
        public static sbyte ToSByte(this MaskedHexBox val)
        {
            try
            {
                return Convert.ToSByte(val.GetSafeConversionString(), 16);
            }
            catch { return 0; }
        }
        public static Int16 ToInt16(this MaskedHexBox val)
        {
            try
            {
                return Convert.ToInt16(val.GetSafeConversionString(), 16);
            }
            catch { return 0; }
        }
        public static Int32 ToInt32(this MaskedHexBox val)
        {
            try
            {
                return Convert.ToInt32(val.GetSafeConversionString(), 16);
            }
            catch { return 0; }
        }
        public static Int64 ToInt64(this MaskedHexBox val)
        {
            try
            {
                return Convert.ToInt64(val.GetSafeConversionString(), 16);
            }
            catch { return 0; }
        }
        public static UInt16 ToUInt16(this MaskedHexBox val)
        {
            try
            {
                return Convert.ToUInt16(val.GetSafeConversionString(), 16);
            }
            catch { return 0; }
        }
        public static UInt32 ToUInt32(this MaskedHexBox val)
        {
            try
            {
                return Convert.ToUInt32(val.GetSafeConversionString(), 16);
            }
            catch { return 0; }
        }
        public static UInt64 ToUInt64(this MaskedHexBox val)
        {
            try
            {
                return Convert.ToUInt64(val.GetSafeConversionString(), 16);
            }
            catch { return 0; }
        }
        public static Single ToSingle(this MaskedHexBox val)
        {
            try
            {
                return Convert.ToSingle(val.ToUInt32());
            }
            catch { return 0; }
        }
        public static double ToDouble(this MaskedHexBox val)
        {
            try
            {
                return Convert.ToDouble(val.ToUInt32());
            }
            catch { return 0; }
        }
        public static decimal ToDecimal(this MaskedHexBox val)
        {
            try
            {
                return Convert.ToDecimal(val.ToUInt32());
            }
            catch { return 0; }
        }
        //public static string ToString(this MaskedHexBox val)
        //{
        //    return Convert.ToString(val.ToUInt32(), 16);
        //}
    }
    #endregion
}
Revision:	88
Committed:	Wed May 9 20:52:20 2012 UTC (11 years, 1 month ago) by william
File size:	9495 byte(s)
Log Message:
#	User	Rev	Content
1	william	88	using System;
2			using System.Collections.Generic;
3			using System.ComponentModel;
4			using System.Drawing;
5			using System.Data;
6			using System.Text;
7			using System.Windows.Forms;
8			using System.Runtime.InteropServices;
9
10			namespace System.Windows.Forms
11			{
12			public partial class MaskedHexBox : UserControl
13			{
14			public MaskedHexBox()
15			{
16			InitializeComponent();
17			SetStyle(
18			ControlStyles.AllPaintingInWmPaint \|
19			ControlStyles.OptimizedDoubleBuffer \|
20			ControlStyles.UserPaint \|
21			ControlStyles.ContainerControl,
22			true);
23			this.isAddressMask = true;
24			txtMaskedHexBox.KeyDown += new KeyEventHandler(txtMaskedHexBox_KeyDown);
25			txtMaskedHexBox.TextAlign = HorizontalAlignment.Right;
26
27			}
28
29			private void MaskedHexBox_KeyDown(object sender, KeyEventArgs e)
30			{
31			}
32
33			private void MaskedHexBox_KeyPress(object sender, KeyPressEventArgs e)
34			{
35			}
36
37			void txtMaskedHexBox_KeyDown(object sender, KeyEventArgs e)
38			{
39
40			if (e.KeyCode > Keys.F && e.KeyCode <= Keys.Z && !e.Control && !e.Alt)
41			{
42			e.SuppressKeyPress = true;
43			}
44			}
45
46
47			new public Font Font
48			{
49			get { return base.Font; }
50			set
51			{
52			base.Font = value;
53			txtMaskedHexBox.Font = value;
54			btnCopy.Font = value;
55			btnPaste.Font = value;
56			}
57			}
58
59			private string Mask
60			{
61			get { return txtMaskedHexBox.Mask; }
62			set { txtMaskedHexBox.Mask = value; }
63			}
64
65			private bool _ReadOnly;
66			public virtual bool ReadOnly
67			{
68			get { return _ReadOnly; }
69			set { _ReadOnly = value; if (_ReadOnly) { txtMaskedHexBox.Enabled = false; } else { txtMaskedHexBox.Enabled = true; } }
70			}
71			public override string Text
72			{
73			get { return txtMaskedHexBox.Text.PadRight(this.TextLength + 2, '0'); }
74			set { txtMaskedHexBox.Text = value; }
75			}
76			public ulong Value
77			{
78			get { return this.ToUInt64(); }
79			set
80			{
81			switch (this.TextLength)
82			{
83			case 0:
84			case 1:
85			case 2: this.Text = string.Format("0x{0:x2}", value); break;
86			case 3:
87			case 4: this.Text = string.Format("0x{0:x4}", value); break;
88			case 5:
89			case 6:
90			case 7:
91			case 8: this.Text = string.Format("0x{0:x8}", value); break;
92			default: this.Text = string.Format("0x{0:x" + this.TextLength + "}", value); break;
93			}
94			}
95			}
96			private bool _isAddressMask;
97			public bool isAddressMask
98			{
99			get { return _isAddressMask; }
100			set
101			{
102			_isAddressMask = value;
103			if (value)
104			{
105			this.CreateTypeSize<uint>();
106			}
107			}
108			}
109
110			public void CreateTypeSize<T>() where T : IConvertible
111			{
112			Type type = typeof(T);
113			this.TextLength = Marshal.SizeOf(type) * 2;
114			this.MaxLength = this.TextLength;
115			}
116
117			private int _MaxLength;
118			public int MaxLength
119			{
120			get { return _MaxLength; }
121			set { _MaxLength = value; }
122			}
123			private int _TextLength;
124			public int TextLength
125			{
126			get { return _TextLength; }
127			set
128			{
129			StringBuilder mask = new StringBuilder();
130
131			mask.Append("\\0x");
132
133			if (this.MaxLength <= sizeof(uint) * 2)
134			{
135
136			switch (value)
137			{
138			case 0:
139			case 1:
140			case 2: _TextLength = 2; mask.Append(this.CreateMask(_TextLength)); break;
141			case 3:
142			case 4: _TextLength = 4; mask.Append(this.CreateMask(_TextLength)); break;
143			case 5:
144			case 6:
145			case 7:
146			case 8:
147			default: _TextLength = 8; mask.Append(this.CreateMask(_TextLength)); break;
148			}
149			}
150			else
151			{
152			switch (value)
153			{
154			case 0:
155			case 1:
156			case 2: _TextLength = 2; mask.Append(this.CreateMask(_TextLength)); break;
157			case 3:
158			case 4: _TextLength = 4; mask.Append(this.CreateMask(_TextLength)); break;
159			case 5:
160			case 6:
161			case 7:
162			case 8: _TextLength = 8; mask.Append(this.CreateMask(_TextLength)); break;
163			default: _TextLength = value; mask.Append(this.CreateMask(_TextLength)); break;
164			}
165			}
166			this.Mask = mask.ToString();
167			}
168			}
169			private string CreateMask(int length)
170			{
171			StringBuilder mask = new StringBuilder();
172			for (int i = 0; i < length; i++)
173			{
174			mask.Append("C");
175			}
176			return mask.ToString();
177			}
178
179			private void btnCopy_Click(object sender, EventArgs e) { Clipboard.SetData(DataFormats.Text, this.Text); }
180			private void btnPaste_Click(object sender, EventArgs e) { if (this.ReadOnly) return; this.Text = (string)Clipboard.GetData(DataFormats.Text); }
181
182			private void txtMaskedHexBox_MaskInputRejected(object sender, MaskInputRejectedEventArgs e)
183			{
184
185			}
186
187
188			}
189
190			#region MaskedHexBox Extensions
191			public static class MaskedHexBoxExtensions
192			{
193			private static string GetSafeConversionString(this MaskedHexBox val)
194			{
195			StringBuilder builder = new StringBuilder();
196
197			if (val.Text == "0x")
198			{
199			builder.Append("0x");
200			for (int i = 0; i < val.TextLength; i++)
201			{
202			builder.Append("0");
203			}
204			}
205			else
206			builder.Append(val.Text.Replace(" ", ""));
207			return builder.ToString();
208			}
209			public static byte ToByte(this MaskedHexBox val)
210			{
211			try { return Convert.ToByte(val.GetSafeConversionString(), 16); }
212			catch { return 0; }
213			}
214			public static sbyte ToSByte(this MaskedHexBox val)
215			{
216			try
217			{
218			return Convert.ToSByte(val.GetSafeConversionString(), 16);
219			}
220			catch { return 0; }
221			}
222			public static Int16 ToInt16(this MaskedHexBox val)
223			{
224			try
225			{
226			return Convert.ToInt16(val.GetSafeConversionString(), 16);
227			}
228			catch { return 0; }
229			}
230			public static Int32 ToInt32(this MaskedHexBox val)
231			{
232			try
233			{
234			return Convert.ToInt32(val.GetSafeConversionString(), 16);
235			}
236			catch { return 0; }
237			}
238			public static Int64 ToInt64(this MaskedHexBox val)
239			{
240			try
241			{
242			return Convert.ToInt64(val.GetSafeConversionString(), 16);
243			}
244			catch { return 0; }
245			}
246			public static UInt16 ToUInt16(this MaskedHexBox val)
247			{
248			try
249			{
250			return Convert.ToUInt16(val.GetSafeConversionString(), 16);
251			}
252			catch { return 0; }
253			}
254			public static UInt32 ToUInt32(this MaskedHexBox val)
255			{
256			try
257			{
258			return Convert.ToUInt32(val.GetSafeConversionString(), 16);
259			}
260			catch { return 0; }
261			}
262			public static UInt64 ToUInt64(this MaskedHexBox val)
263			{
264			try
265			{
266			return Convert.ToUInt64(val.GetSafeConversionString(), 16);
267			}
268			catch { return 0; }
269			}
270			public static Single ToSingle(this MaskedHexBox val)
271			{
272			try
273			{
274			return Convert.ToSingle(val.ToUInt32());
275			}
276			catch { return 0; }
277			}
278			public static double ToDouble(this MaskedHexBox val)
279			{
280			try
281			{
282			return Convert.ToDouble(val.ToUInt32());
283			}
284			catch { return 0; }
285			}
286			public static decimal ToDecimal(this MaskedHexBox val)
287			{
288			try
289			{
290			return Convert.ToDecimal(val.ToUInt32());
291			}
292			catch { return 0; }
293			}
294			//public static string ToString(this MaskedHexBox val)
295			//{
296			// return Convert.ToString(val.ToUInt32(), 16);
297			//}
298			}
299			#endregion
300			}