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
{
    
    [DefaultEvent("ValueChanged")]
    public partial class MaskedHexBox : UserControl
    {
        ulong old_value = 0;
        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;
            ValueChanged = null;
            txtMaskedHexBox.InsertKeyMode = InsertKeyMode.Overwrite;
        }
        [Browsable(true)]
        [Category("Property Changed")]
        [Description("Raised when the Value displayed changes.")]
        public event EventHandler<ValueChangedEventArgs> ValueChanged;

        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;
            }
            if (!e.SuppressKeyPress)
            {
                old_value = this.Value;
            }
        }

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

                Font t = value;

                txtMaskedHexBox.Font = new Font(t.FontFamily, t.SizeInPoints + 4, t.Style);
                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
            {
                old_value = this.Value;
                txtMaskedHexBox.Text = value;
                DoResize();
                ulong new_value = this.Value;
                if ((new_value != old_value) && ValueChanged != null)
                    ValueChanged(this, new ValueChangedEventArgs(old_value, new_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);
            int size = Marshal.SizeOf(type) * 2;
            this.MaxLength = size;
            this.TextLength = this.MaxLength;
        }

        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 2: _TextLength = 2; mask.Append(this.CreateMask(_TextLength)); break;
                        case 4: _TextLength = 4; mask.Append(this.CreateMask(_TextLength)); break;
                        case 8: goto default;
                        case 16: _TextLength = 16; mask.Append(this.CreateMask(_TextLength)); break;
                        default: _TextLength = 8; mask.Append(this.CreateMask(_TextLength)); break;
                    }
                }
                else
                {
                    switch (value)
                    {
                        case 2: _TextLength = 2; mask.Append(this.CreateMask(_TextLength)); break;
                        case 4: _TextLength = 4; mask.Append(this.CreateMask(_TextLength)); break;
                        case 8: _TextLength = 8; mask.Append(this.CreateMask(_TextLength)); break;
                        case 16: _TextLength = 16; mask.Append(this.CreateMask(_TextLength)); break;
                        default: _TextLength = value; mask.Append(this.CreateMask(_TextLength)); break;
                    }
                }
                this.Mask = mask.ToString();
                DoResize();
            }
        }
        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;
            var rawText = (string)Clipboard.GetData(DataFormats.Text);
            if (rawText.StartsWith("0x")) { rawText = rawText.Remove(0,2); }
            if (rawText.StartsWith("x")) { rawText = rawText.Remove(0, 1); }

            rawText = rawText.PadLeft(this.TextLength, '0');
            rawText = string.Format("0x{0}", rawText);
            this.Text = rawText;
        }

        private void txtMaskedHexBox_MaskInputRejected(object sender, MaskInputRejectedEventArgs e)
        {

        }

        private void MaskedHexBox_Load(object sender, EventArgs e)
        {
            DoResize();
        }

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

        private void DoResize()
        {
            string t = string.Empty;
            switch (this.TextLength)
            {
                case 2:
                    t = string.Format("0x{0:x2}", this.Value);
                    break;
                case 4:
                    t = string.Format("0x{0:x4}", this.Value);
                    break;
                case 8: goto default;
                case 16:
                    t = string.Format("0x{0:x16}", this.Value);
                    break;
                default: 
                     t = string.Format("0x{0:x8}", this.Value);
                     break;
            }


            using (Graphics g = this.CreateGraphics())
            {
                var size = g.MeasureString(t, this.Font).ToSize();
                int width = size.Width; // the minimum size of the textbox
                double growth = (double)size.Width / 0.5;

                switch (this.TextLength)
                {
                    case 2: this.Width = (int)growth + 25; break;
                    case 4: this.Width = (int)growth + 15; break;
                    case 8: goto default;
                    case 16: this.Width = (int)growth - 70; break;
                    default:
                        this.Width = (int)growth - 15; break;
                }

                
            }
        }

        private void txtMaskedHexBox_TextChanged(object sender, EventArgs e)
        {           
            ulong new_value = this.Value;
            if ((new_value != old_value) && ValueChanged != null)
                ValueChanged(this, new ValueChangedEventArgs(old_value, new_value));
        }
    }

    #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:	673
Committed:	Mon Jun 17 05:32:10 2013 UTC (9 years, 7 months ago) by william
File size:	12665 byte(s)
Log Message:	MaskedHexBox: set: txtMaskedHexBox.InsertKeyMode = InsertKeyMode.Overwrite; ** this allows us to directly overwrite text in control
#	Content
1	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
13	[DefaultEvent("ValueChanged")]
14	public partial class MaskedHexBox : UserControl
15	{
16	ulong old_value = 0;
17	public MaskedHexBox()
18	{
19	InitializeComponent();
20	SetStyle(
21	ControlStyles.AllPaintingInWmPaint \|
22	ControlStyles.OptimizedDoubleBuffer \|
23	ControlStyles.UserPaint \|
24	ControlStyles.ContainerControl,
25	true);
26	this.isAddressMask = true;
27	txtMaskedHexBox.KeyDown += new KeyEventHandler(txtMaskedHexBox_KeyDown);
28	txtMaskedHexBox.TextAlign = HorizontalAlignment.Right;
29	ValueChanged = null;
30	txtMaskedHexBox.InsertKeyMode = InsertKeyMode.Overwrite;
31	}
32	[Browsable(true)]
33	[Category("Property Changed")]
34	[Description("Raised when the Value displayed changes.")]
35	public event EventHandler<ValueChangedEventArgs> ValueChanged;
36
37	private void MaskedHexBox_KeyDown(object sender, KeyEventArgs e)
38	{
39	}
40
41	private void MaskedHexBox_KeyPress(object sender, KeyPressEventArgs e)
42	{
43	}
44
45	void txtMaskedHexBox_KeyDown(object sender, KeyEventArgs e)
46	{
47
48	if (e.KeyCode > Keys.F && e.KeyCode <= Keys.Z && !e.Control && !e.Alt)
49	{
50	e.SuppressKeyPress = true;
51	}
52	if (!e.SuppressKeyPress)
53	{
54	old_value = this.Value;
55	}
56	}
57
58	new public Font Font
59	{
60	get { return base.Font; }
61	set
62	{
63	base.Font = value;
64
65	Font t = value;
66
67	txtMaskedHexBox.Font = new Font(t.FontFamily, t.SizeInPoints + 4, t.Style);
68	btnCopy.Font = value;
69	btnPaste.Font = value;
70	}
71	}
72
73	private string Mask
74	{
75	get { return txtMaskedHexBox.Mask; }
76	set { txtMaskedHexBox.Mask = value; }
77	}
78
79	private bool _ReadOnly;
80	public virtual bool ReadOnly
81	{
82	get { return _ReadOnly; }
83	set { _ReadOnly = value; if (_ReadOnly) { txtMaskedHexBox.Enabled = false; } else { txtMaskedHexBox.Enabled = true; } }
84	}
85	public override string Text
86	{
87	get
88	{
89	return txtMaskedHexBox.Text.PadRight(this.TextLength + 2, '0');
90	}
91	set
92	{
93	old_value = this.Value;
94	txtMaskedHexBox.Text = value;
95	DoResize();
96	ulong new_value = this.Value;
97	if ((new_value != old_value) && ValueChanged != null)
98	ValueChanged(this, new ValueChangedEventArgs(old_value, new_value));
99	}
100	}
101	public ulong Value
102	{
103	get { return this.ToUInt64(); }
104	set
105	{
106
107	switch (this.TextLength)
108	{
109	case 0:
110	case 1:
111	case 2: this.Text = string.Format("0x{0:x2}", value); break;
112	case 3:
113	case 4: this.Text = string.Format("0x{0:x4}", value); break;
114	case 5:
115	case 6:
116	case 7:
117	case 8: this.Text = string.Format("0x{0:x8}", value); break;
118	default: this.Text = string.Format("0x{0:x" + this.TextLength + "}", value); break;
119	}
120	}
121	}
122	private bool _isAddressMask;
123	public bool isAddressMask
124	{
125	get { return _isAddressMask; }
126	set
127	{
128	_isAddressMask = value;
129	if (value)
130	{
131	this.CreateTypeSize<uint>();
132	}
133	}
134	}
135
136	public void CreateTypeSize<T>() where T : IConvertible
137	{
138	Type type = typeof(T);
139	int size = Marshal.SizeOf(type) * 2;
140	this.MaxLength = size;
141	this.TextLength = this.MaxLength;
142	}
143
144	private int _MaxLength;
145	public int MaxLength
146	{
147	get { return _MaxLength; }
148	set { _MaxLength = value; }
149	}
150	private int _TextLength;
151	public int TextLength
152	{
153	get { return _TextLength; }
154	set
155	{
156	StringBuilder mask = new StringBuilder();
157
158	mask.Append("\\0x");
159
160	if (this.MaxLength <= sizeof(uint) * 2)
161	{
162
163	switch (value)
164	{
165	case 2: _TextLength = 2; mask.Append(this.CreateMask(_TextLength)); break;
166	case 4: _TextLength = 4; mask.Append(this.CreateMask(_TextLength)); break;
167	case 8: goto default;
168	case 16: _TextLength = 16; mask.Append(this.CreateMask(_TextLength)); break;
169	default: _TextLength = 8; mask.Append(this.CreateMask(_TextLength)); break;
170	}
171	}
172	else
173	{
174	switch (value)
175	{
176	case 2: _TextLength = 2; mask.Append(this.CreateMask(_TextLength)); break;
177	case 4: _TextLength = 4; mask.Append(this.CreateMask(_TextLength)); break;
178	case 8: _TextLength = 8; mask.Append(this.CreateMask(_TextLength)); break;
179	case 16: _TextLength = 16; mask.Append(this.CreateMask(_TextLength)); break;
180	default: _TextLength = value; mask.Append(this.CreateMask(_TextLength)); break;
181	}
182	}
183	this.Mask = mask.ToString();
184	DoResize();
185	}
186	}
187	private string CreateMask(int length)
188	{
189	StringBuilder mask = new StringBuilder();
190	for (int i = 0; i < length; i++)
191	{
192	mask.Append("C");
193	}
194	return mask.ToString();
195	}
196
197	private void btnCopy_Click(object sender, EventArgs e) { Clipboard.SetData(DataFormats.Text, this.Text); }
198	private void btnPaste_Click(object sender, EventArgs e)
199	{
200	if (this.ReadOnly) return;
201	var rawText = (string)Clipboard.GetData(DataFormats.Text);
202	if (rawText.StartsWith("0x")) { rawText = rawText.Remove(0,2); }
203	if (rawText.StartsWith("x")) { rawText = rawText.Remove(0, 1); }
204
205	rawText = rawText.PadLeft(this.TextLength, '0');
206	rawText = string.Format("0x{0}", rawText);
207	this.Text = rawText;
208	}
209
210	private void txtMaskedHexBox_MaskInputRejected(object sender, MaskInputRejectedEventArgs e)
211	{
212
213	}
214
215	private void MaskedHexBox_Load(object sender, EventArgs e)
216	{
217	DoResize();
218	}
219
220	protected override void OnResize(EventArgs e)
221	{
222	base.OnResize(e);
223	DoResize();
224	}
225
226	private void DoResize()
227	{
228	string t = string.Empty;
229	switch (this.TextLength)
230	{
231	case 2:
232	t = string.Format("0x{0:x2}", this.Value);
233	break;
234	case 4:
235	t = string.Format("0x{0:x4}", this.Value);
236	break;
237	case 8: goto default;
238	case 16:
239	t = string.Format("0x{0:x16}", this.Value);
240	break;
241	default:
242	t = string.Format("0x{0:x8}", this.Value);
243	break;
244	}
245
246
247
248	using (Graphics g = this.CreateGraphics())
249	{
250	var size = g.MeasureString(t, this.Font).ToSize();
251	int width = size.Width; // the minimum size of the textbox
252	double growth = (double)size.Width / 0.5;
253
254	switch (this.TextLength)
255	{
256	case 2: this.Width = (int)growth + 25; break;
257	case 4: this.Width = (int)growth + 15; break;
258	case 8: goto default;
259	case 16: this.Width = (int)growth - 70; break;
260	default:
261	this.Width = (int)growth - 15; break;
262	}
263
264
265	}
266	}
267
268	private void txtMaskedHexBox_TextChanged(object sender, EventArgs e)
269	{
270	ulong new_value = this.Value;
271	if ((new_value != old_value) && ValueChanged != null)
272	ValueChanged(this, new ValueChangedEventArgs(old_value, new_value));
273	}
274	}
275
276	#region MaskedHexBox Extensions
277	public static class MaskedHexBoxExtensions
278	{
279	private static string GetSafeConversionString(this MaskedHexBox val)
280	{
281	StringBuilder builder = new StringBuilder();
282
283	if (val.Text == "0x")
284	{
285	builder.Append("0x");
286	for (int i = 0; i < val.TextLength; i++)
287	{
288	builder.Append("0");
289	}
290	}
291	else
292	builder.Append(val.Text.Replace(" ", ""));
293	return builder.ToString();
294	}
295	public static byte ToByte(this MaskedHexBox val)
296	{
297	try { return Convert.ToByte(val.GetSafeConversionString(), 16); }
298	catch { return 0; }
299	}
300	public static sbyte ToSByte(this MaskedHexBox val)
301	{
302	try
303	{
304	return Convert.ToSByte(val.GetSafeConversionString(), 16);
305	}
306	catch { return 0; }
307	}
308	public static Int16 ToInt16(this MaskedHexBox val)
309	{
310	try
311	{
312	return Convert.ToInt16(val.GetSafeConversionString(), 16);
313	}
314	catch { return 0; }
315	}
316	public static Int32 ToInt32(this MaskedHexBox val)
317	{
318	try
319	{
320	return Convert.ToInt32(val.GetSafeConversionString(), 16);
321	}
322	catch { return 0; }
323	}
324	public static Int64 ToInt64(this MaskedHexBox val)
325	{
326	try
327	{
328	return Convert.ToInt64(val.GetSafeConversionString(), 16);
329	}
330	catch { return 0; }
331	}
332	public static UInt16 ToUInt16(this MaskedHexBox val)
333	{
334	try
335	{
336	return Convert.ToUInt16(val.GetSafeConversionString(), 16);
337	}
338	catch { return 0; }
339	}
340	public static UInt32 ToUInt32(this MaskedHexBox val)
341	{
342	try
343	{
344	return Convert.ToUInt32(val.GetSafeConversionString(), 16);
345	}
346	catch { return 0; }
347	}
348	public static UInt64 ToUInt64(this MaskedHexBox val)
349	{
350	try
351	{
352	return Convert.ToUInt64(val.GetSafeConversionString(), 16);
353	}
354	catch { return 0; }
355	}
356	public static Single ToSingle(this MaskedHexBox val)
357	{
358	try
359	{
360	return Convert.ToSingle(val.ToUInt32());
361	}
362	catch { return 0; }
363	}
364	public static double ToDouble(this MaskedHexBox val)
365	{
366	try
367	{
368	return Convert.ToDouble(val.ToUInt32());
369	}
370	catch { return 0; }
371	}
372	public static decimal ToDecimal(this MaskedHexBox val)
373	{
374	try
375	{
376	return Convert.ToDecimal(val.ToUInt32());
377	}
378	catch { return 0; }
379	}
380	//public static string ToString(this MaskedHexBox val)
381	//{
382	// return Convert.ToString(val.ToUInt32(), 16);
383	//}
384	}
385	#endregion
386	}