ipaddresscontrol.cs

ipaddresscontrollib.rar

// Copyright (c) 2007 Michael Chapman

// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:

// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


using System;
using System.Collections;
using System.ComponentModel;
using System.Diagnostics;
using System.Drawing;
using System.Data;
using System.Globalization;
using System.Runtime.InteropServices;
using System.Security.Permissions;
using System.Text;
using System.Windows.Forms;


namespace IPAddressControlLib
{
   public class FieldChangedEventArgs : EventArgs
   {
      private int _fieldId;
      private String _text;

      public int FieldId
      {
         get 
         {
            return _fieldId;
         }
         set
         {
            _fieldId = value;
         }
      }

      public String Text
      {
         get
         {
            return _text;
         }
         set
         {
            _text = value;
         }
      }
   }

   public delegate void FieldChangedEventHandler( object sender, FieldChangedEventArgs e );

	[DesignerAttribute( typeof(IPAddressControlDesigner) )]
	public class IPAddressControl : System.Windows.Forms.UserControl
	{
      public const int NumberOfFields = 4;

      #region Private Data

      private FieldControl[] _fieldControls = new FieldControl[NumberOfFields];
      private DotControl[] _dotControls     = new DotControl[NumberOfFields-1];

      private bool _autoSize;
      private BorderStyle _borderStyle = BorderStyle.Fixed3D;
      private bool _readOnly;

		/// <summary>
		/// Required designer variable.
		/// </summary>
		private System.ComponentModel.Container components = null;

      #endregion

      #region Public Events

      public event FieldChangedEventHandler FieldChangedEvent;

      #endregion

      #region Public Properies

      [Browsable(true)]
      public bool AutoSize
      {
         get 
         {
            return _autoSize;
         }
         set
         {
            _autoSize = value;
            if ( _autoSize )
            {
               AdjustSize();
            }
         }
      }

      public bool Blank
      {
         get
         {
            foreach ( FieldControl fc in _fieldControls )
            {
               if ( fc.Blank == false )
               {
                  return false;
               }
            }

            return true;
         }
      }

      [Browsable(true)]
      public BorderStyle BorderStyle
      {
         get 
         {
            return _borderStyle;
         }
         set
         {
            _borderStyle = value;
            foreach ( DotControl dc in _dotControls )
            {
               dc.IgnoreTheme = ( value != BorderStyle.Fixed3D );
            }
            LayoutControls();
            Invalidate();
         }
      }

      public override bool Focused
      {
         get
         {
            foreach ( FieldControl fc in _fieldControls )
            {
               if ( fc.Focused )
               {
                  return true;
               }
            }
            
            return false;
         }
      }

      [Browsable(true)]
      public bool ReadOnly
      {
         get
         {
            return _readOnly;
         }
         set
         {
            _readOnly = value;

            foreach ( FieldControl fc in _fieldControls )
            {
               fc.ReadOnly = _readOnly;
            }

            foreach ( DotControl dc in _dotControls )
            {
               dc.ReadOnly = _readOnly;
            }

            Invalidate();
         }
      }

      [Bindable(true),Browsable(true)]
      [DefaultValue("0.0.0.0")]
      public override string Text
      {
         get
         {
            StringBuilder sb = new StringBuilder();;

            try
            {
               for ( int index = 0; index < _fieldControls.Length; ++index )
               {
                  sb.Append( _fieldControls[index].Text );
                  
                  if ( index < _dotControls.Length )
                  {
                     sb.Append( _dotControls[index].Text );
                  }
               }
            }
            catch ( ArgumentOutOfRangeException )
            {
            }

            return sb.ToString();
         }
         set
         {
            Parse( value );
         }
      }

      #endregion

      #region Public Functions

      public void Clear()
      {
         foreach( FieldControl fc in _fieldControls )
         {
            fc.Clear();
         }
      }

      public byte[] GetAddressBytes()
      {
         Byte[] bytes = new Byte[_fieldControls.Length];

         for ( int index = 0; index < bytes.Length; ++index )
         {
            if ( _fieldControls[index].TextLength > 0 )
            {
               bytes[index] = Convert.ToByte( _fieldControls[index].Text, CultureInfo.InvariantCulture );
            }
            else
            {
               bytes[index] = (byte)(_fieldControls[index].RangeLower);
            }
         }

         return bytes;
      }

      public void SetAddressBytes( Byte[] bytes )
      {
         Clear();

         int length = Math.Min( _fieldControls.Length, bytes.Length );

         for ( int i = 0; i < length; ++i )
         {
            _fieldControls[i].Text = bytes[i].ToString( CultureInfo.InvariantCulture );
         }
      }

      public void SetFieldFocus( int field )
      {
         if ( ( field >= 0 ) && ( field < _fieldControls.Length ) )
         {
            _fieldControls[field].TakeFocus( Direction.Forward, Selection.All );
         }
      }

      public void SetFieldRange( int field, int rangeLower, int rangeUpper )
      {
         if ( ( field >= 0 ) && ( field < _fieldControls.Length ) )
         {
            _fieldControls[field].RangeLower = rangeLower;
            _fieldControls[field].RangeUpper = rangeUpper;
         }
      }

      public override string ToString()
      {
         StringBuilder sb = new StringBuilder();

         try
         {
            for ( int index = 0; index < _fieldControls.Length; ++index )
            {
               sb.Append( _fieldControls[index].ToString() );
                  
               if ( index < _dotControls.Length )
               {
                  sb.Append( _dotControls[index].ToString() );
               }
            }
         }
         catch ( ArgumentOutOfRangeException )
         {
         }

         return sb.ToString();
      }

      #endregion

      #region Constructors

		public IPAddressControl()
		{
         InitializeComponent();

			for ( int index = 0; index < _fieldControls.Length; ++index )
         {
            _fieldControls[index] = new FieldControl();
            _fieldControls[index].Name = "fieldControl" + index.ToString( CultureInfo.InvariantCulture );
            _fieldControls[index].CreateControl();
            _fieldControls[index].Parent = this;
            _fieldControls[index].FieldId = index;
            _fieldControls[index].CedeFocusEvent += new CedeFocusHandler( this.OnCedeFocus );
            _fieldControls[index].SpecialKeyEvent += new SpecialKeyHandler( this.OnSpecialKey );
            _fieldControls[index].TextChangedEvent += new TextChangedHandler( this.OnFieldTextChanged );
            this.Controls.Add( _fieldControls[index] );
         }
         
         for ( int index = 0; index < _dotControls.Length; ++index )
         {
            _dotControls[index] = new DotControl();
            _dotControls[index].Name = "dotControl" + index.ToString( CultureInfo.InvariantCulture );
            _dotControls[index].CreateControl();
            _dotControls[index].Parent = this;
            _dotControls[index].IgnoreTheme = ( this.BorderStyle != BorderStyle.Fixed3D );
            this.Controls.Add( _dotControls[index] );
         }

         Size = MinimumSize;

         SetStyle( ControlStyles.ResizeRedraw, true );
         SetStyle( ControlStyles.UserPaint, true );
         SetStyle( ControlStyles.ContainerControl, true );

         LayoutControls();
		}

      #endregion

      #region Private Properties

      private Size MinimumSize
      {
         get
         {
            Size retVal = new Size( 0, 0 );

            foreach ( FieldControl fc in _fieldControls )
            {
               retVal.Width += fc.Size.Width;
               retVal.Height = Math.Max( retVal.Height, fc.Size.Height );
            }

            foreach ( DotControl dc in _dotControls )
            {
               retVal.Width += dc.Size.Width;
               retVal.Height = Math.Max( retVal.Height, dc.Size.Height );
            }

            switch ( BorderStyle )
            {
               case BorderStyle.Fixed3D:
                  retVal.Width  += 6;
                  retVal.Height += 7;
                  break;
               case BorderStyle.FixedSingle:
                  retVal.Width  += 4;
                  retVal.Height += 7;
                  break;
            }

            return retVal;
         }
      }

      #endregion

      #region Private Functions

      private void AdjustSize()
      {
         Size newSize = MinimumSize;

         if ( this.Size.Width > newSize.Width )
         {
            newSize = new Size( this.Size.Width, newSize.Height );
         }

         if ( this.Size.Height > newSize.Height )
         {
            newSize = new Size( newSize.Width, this.Size.Height );
         }

         if ( _autoSize )
         {
            this.Size = new Size( newSize.Width, MinimumSize.Height );
         }
         else
         {
            this.Size = newSize;
         }
      }

      private void IPAddressControl_DragDrop( object sender, System.Windows.Forms.DragEventArgs e )
      {
         Text = e.Data.GetData( DataFormats.Text ).ToString();
      }

      private void IPAddressControl_DragEnter( object sender, System.Windows.Forms.DragEventArgs e )
      {
         if ( e.Data.GetDataPresent( DataFormats.Text ) )
         {
            e.Effect = DragDropEffects.Copy;
         }
         else
         {
            e.Effect = DragDropEffects.None;
         }
      }

      private void LayoutControls()
      {
         SuspendLayout();

         int difference = this.Size.Width - MinimumSize.Width;

         Debug.Assert( difference >= 0 );

         int numOffsets = _fieldControls.Length + _dotControls.Length + 1;

         int div = difference / ( numOffsets );
         int mod = difference % ( numOffsets );

         int[] offsets = new int[numOffsets];

         for ( int index = 0; index < numOffsets; ++index )
         {
            offsets[index] = div;