I was goofing around tonight and decided to write a little IP address
control. I had written a simple one a long time ago, but I decided I
should try to write one that was half way correct :) Anyway, here is the
result of about an hour and half of work...
// IPControl.cs
using System;
using System.Collecti ons;
using System.Componen tModel;
using System.Drawing;
using System.Data;
using System.Windows. Forms;
using System.Net;
using System.Runtime. InteropServices ;
namespace FireAnt.Control s
{
/// <summary>
/// Simple API Based IP Control
/// </summary>
public class IPControl : System.Windows. Forms.UserContr ol
{
/// <summary>
/// Required designer variable.
/// </summary>
private System.Componen tModel.Containe r components = null;
private NativeIPControl ipControl;
public event FieldChangedDel egate FieldChanged;
public IPControl()
{
// This call is required by the Windows.Forms Form Designer.
InitializeCompo nent();
// create the native ip control
this.ipControl =
new NativeIPControl (this.Handle, this.Height, this.Width);
}
/// <summary>
/// Clean up any resources being used.
/// </summary>
protected override void Dispose( bool disposing )
{
if( disposing )
{
if(components != null)
{
components.Disp ose();
}
}
base.Dispose( disposing );
}
/// <summary>
/// Overridden window procedure
/// </summary>
/// <param name="m">Window message to process</param>
protected override void WndProc(ref Message m)
{
// we need to over ride this so that we
// can receive notification messages from the
// native ip control window...
switch (m.Msg)
{
case Win32Interop.WM _NOTIFY:
unsafe
{
Win32Interop.NM HDR* nmhdr = (Win32Interop.N MHDR*) m.LParam;
if (nmhdr->code == Win32Interop.IP N_FIELDCHANGED)
{
Win32Interop.NM IPADDRESS* nmaddr
= (Win32Interop.N MIPADDRESS*) m.LParam;
// fire a field changed event...
FieldChangedEve ntArgs e
= new FieldChangedEve ntArgs(nmaddr->iField, nmaddr->iValue);
if (this.FieldChan ged != null)
{
this.FieldChang ed (this, e);
}
// change the feild value...
nmaddr->iValue = e.Value;
}
else
{
base.WndProc(re f m);
}
}
break;
default:
base.WndProc (ref m);
break;
}
}
#region Component Designer generated code
/// <summary>
/// Required method for Designer support - do not modify
/// the contents of this method with the code editor.
/// </summary>
private void InitializeCompo nent()
{
//
// FAIPControl
//
this.Name = "IPControl" ;
this.Size = new System.Drawing. Size(132, 20);
this.Enter += new System.EventHan dler(this.IPCon trol_Enter);
}
#endregion
/// <summary>
/// Get/Set the IP address for the control
/// </summary>
[Browsable(false ),
ReadOnly(true)]
public IPAddress Address
{
get
{
uint address = 0;
if (Win32Interop.S endMessage (
this.ipControl. Handle,
Win32Interop.IP M_ISBLANK,
0,
0) == 0)
{
// get the address
Win32Interop.Se ndMessage (
this.ipControl. Handle,
Win32Interop.IP M_GETADDRESS,
0,
out address
);
// we need to reverse the order...
byte[] buffer = BitConverter.Ge tBytes(address) ;
System.Array.Re verse(buffer, 0, buffer.Length);
address = BitConverter.To UInt32(buffer, 0);
}
return new IPAddress(addre ss);
}
set
{
// we need to get the bytes, and reverse the order
byte[] buffer = value.GetAddres sBytes();
System.Array.Re verse(buffer, 0, buffer.Length);
uint address = BitConverter.To UInt32(buffer, 0);
// now set the value
Win32Interop.Se ndMessage (
this.ipControl. Handle,
Win32Interop.IP M_SETADDRESS,
0,
address
);
}
}
/// <summary>
/// Clear the control
/// </summary>
public void Clear()
{
// clear the ip values...
Win32Interop.Se ndMessage (
this.ipControl. Handle,
Win32Interop.IP M_CLEARADDRESS,
0,
0
);
}
/// <summary>
/// Set focus to a particular field in the control
/// </summary>
/// <param name="field">Th e zero based field index to set focus
to</param>
public void Focus(int field)
{
if (field < 0 || field > 3)
{
throw new ArgumentOutOfRa ngeException (
"field",
field,
"Field must be between 0 and 3");
}
Win32Interop.Se ndMessage (
this.ipControl. Handle,
Win32Interop.IP M_SETFOCUS,
(uint) field, 0
);
}
private void IPControl_Enter (object sender, System.EventArg s e)
{
// set the focus to our ip control...
Win32Interop.Se ndMessage (
this.ipControl. Handle,
Win32Interop.IP M_SETFOCUS,
0,
0
);
}
/// <summary>
/// Native Windows IP Control Class
/// </summary>
private class NativeIPControl : System.Windows. Forms.NativeWin dow
{
public NativeIPControl (IntPtr parent, int height, int width)
{
// create the create params structure
CreateParams cp = new CreateParams();
// fill it in...
cp.ClassName = Win32Interop.WC _IPADDRESS;
cp.Style = Win32Interop.WS _CHILD | Win32Interop.WS _VISIBLE;
cp.X = 0;
cp.Y = 0;
cp.Height = height;
cp.Width = width;
cp.Parent = parent;
// create the window
this.CreateHand le(cp);
}
// we'll probably need this latter...
protected override void WndProc(ref Message m)
{
// for now just call the default procedure
base.DefWndProc (ref m);
}
}
}
public class FieldChangedEve ntArgs : System.EventArg s
{
private int field;
private int newValue;
internal FieldChangedEve ntArgs(int field, int newValue)
{
this.field = field;
this.newValue = newValue;
}
public int Field
{
get
{
return this.field;
}
}
public int Value
{
get
{
return this.newValue;
}
set
{
if (value >= 0 && value <= 255)
{
this.newValue = value;
}
}
}
}
public delegate void FieldChangedDel egate (
object sender, FieldChangedEve ntArgs e);
}
// Win32Interop.cs
using System;
using System.Runtime. InteropServices ;
namespace FireAnt.Control s
{
/// <summary>
/// Win32 Interop Definitions
/// </summary>
internal sealed class Win32Interop
{
// Window Style Constants
public const int WS_CHILD = 0x40000000;
public const int WS_VISIBLE = 0x10000000;
// Window Class Names
public const string WC_IPADDRESS = "SysIPAddress32 ";
// IP Control Window Messages
public const uint IPM_CLEARADDRES S = (WM_USER+100); // no parameters
public const uint IPM_SETADDRESS = (WM_USER+101); // lparam = TCP/IP
address
public const uint IPM_GETADDRESS = (WM_USER+102); // lresult = # of non
black fields. lparam = LPDWORD for TCP/IP address
public const uint IPM_SETRANGE = (WM_USER+103); // wparam = field,
lparam = range
public const uint IPM_SETFOCUS = (WM_USER+104); // wparam = field
public const uint IPM_ISBLANK = (WM_USER+105); // no parameters
// IP Control Notification Messages
public const int WM_NOTIFY = 0x004E;
public const uint IPN_FIELDCHANGE D = (IPN_FIRST - 0);
// IP Control Structures
[StructLayout(La youtKind.Sequen tial)]
public struct NMHDR
{
public IntPtr hwndFrom;
public uint idFrom;
public uint code;
}
[StructLayout(La youtKind.Sequen tial)]
public struct NMIPADDRESS
{
public NMHDR hdr;
public int iField;
public int iValue;
}
#region API Function Calls
[DllImport("user 32", CharSet=CharSet .Auto, SetLastError=tr ue)]
public static extern uint SendMessage (
IntPtr hWnd,
uint Msg,
uint wParam,
uint lParam
);
[DllImport("user 32", CharSet=CharSet .Auto, SetLastError=tr ue)]
public static extern uint SendMessage (
IntPtr hWnd,
uint Msg,
uint wParam,
out uint lParam
);
#endregion
#region Private Data
// private window message constants
private const uint WM_USER = 0x0400;
private const uint IPN_FIRST = unchecked(0U-860U); // internet address
private const uint IPN_LAST = unchecked(0U-879U); // internet address
private Win32Interop() {}
#endregion
}
}
Sorry, the code is in C# - but I thought I'd share it with you guys anyway.
HTH
--
Tom Shelton [MVP]
