WindowsIPAddress.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ DotNET / DotNET / 8.0 / untmp / WIN_WINDOWS / lh_tools_devdiv_wpf / Windows / AccessibleTech / longhorn / Automation / Win32Providers / MS / Internal / AutomationProxies / WindowsIPAddress.cs / 1 / WindowsIPAddress.cs

                            //---------------------------------------------------------------------------- 
//
// 
//    Copyright (C) Microsoft Corporation.  All rights reserved.
//  
//
// 
// Description: Win32 IP Common Control proxy 
//
// History: 
//          Kris Krueger            Created
//          [....]   Reimplemented
//          alexsn (2003/08/15)     Updated to use IRawElementProviderHwndOverride
// 
//---------------------------------------------------------------------------
 
using System; 
using System.Net;
using System.Text; 
using System.ComponentModel;
using System.Globalization;
using System.Windows.Automation;
using System.Windows.Automation.Provider; 
using System.Windows;
using MS.Win32; 
 
namespace MS.Internal.AutomationProxies
{ 
    class WindowsIPAddress: ProxyHwnd, IRawElementProviderHwndOverride, IValueProvider, IGridProvider
    {
        // -----------------------------------------------------
        // 
        //  Constructors
        // 
        //----------------------------------------------------- 

        #region Constructors 

        WindowsIPAddress (IntPtr hwnd, ProxyFragment parent, int item)
            : base( hwnd, parent, item )
        { 
            // IP Address control itself is custom so need to also return LocalizedControlType property
            _cControlType = ControlType.Custom; 
            _sType = ST.Get( STID.LocalizedControlTypeIPAddress ); ; 
            _fIsKeyboardFocusable = true;
 
            // support for events
            _createOnEvent = new WinEventTracker.ProxyRaiseEvents (RaiseEvents);
        }
 
        #endregion
 
        #region Proxy Create 

        // Static Create method called by UIAutomation to create this proxy. 
        // returns null if unsuccessful
        internal static IRawElementProviderSimple Create(IntPtr hwnd, int idChild, int idObject)
        {
            return Create(hwnd, idChild); 
        }
 
        private static IRawElementProviderSimple Create(IntPtr hwnd, int idChild) 
        {
            // Something is wrong if idChild is not zero 
            if (idChild != 0)
            {
                System.Diagnostics.Debug.Assert (idChild == 0, "Invalid Child Id, idChild != 0");
                throw new ArgumentOutOfRangeException("idChild", idChild, SR.Get(SRID.ShouldBeZero)); 
            }
 
            return new WindowsIPAddress(hwnd, null, 0); 
        }
 
        internal static void RaiseEvents (IntPtr hwnd, int eventId, object idProp, int idObject, int idChild)
        {
            if (idObject != NativeMethods.OBJID_VSCROLL && idObject != NativeMethods.OBJID_HSCROLL)
            { 
                ProxySimple el = new WindowsIPAddress (hwnd, null, 0);
 
                el.DispatchEvents (eventId, idProp, idObject, idChild); 
            }
        } 

        #endregion Proxy Create

        //------------------------------------------------------ 
        //
        //  Patterns Implementation 
        // 
        //-----------------------------------------------------
 
        #region ProxySimple Interface

        // Returns a pattern interface if supported.
        internal override object GetPatternProvider (AutomationPattern iid) 
        {
            return iid == ValuePattern.Pattern || iid == GridPattern.Pattern ? this : null; 
        } 

        #endregion 

        #region ProxyFragment Interface

        // Returns a Proxy element corresponding to the specified screen coordinates. 
        internal override ProxySimple ElementProviderFromPoint (int x, int y)
        { 
            // let UIAutomation do the drilling 
            return null;
        } 

        #endregion ProxyFragment Interface

        #region IRawElementProviderHwndOverride 

        IRawElementProviderSimple IRawElementProviderHwndOverride.GetOverrideProviderForHwnd (IntPtr hwnd) 
        { 
            // Find location of passed in hwnd under the parent
            int index = GetIndexOfChildWindow (hwnd); 
            System.Diagnostics.Debug.Assert (index != -1, "GetOverrideProviderForHwnd: cannot find child hwnd index");
            return new ByteEditBoxOverride (hwnd, index);
        }
 
        #endregion IRawElementProviderHwndOverride
 
        #region Value Pattern 

        // Sets the IP Address. 
        void IValueProvider.SetValue (string val)
        {
            // Make sure that the control is enabled
            if (!SafeNativeMethods.IsWindowEnabled(_hwnd)) 
            {
                throw new ElementNotEnabledException(); 
            } 

            IPAddress ipAddress = GetIPAddressFromString (val); 

            if (ipAddress != null)
            {
                byte[] abOctet = ipAddress.GetAddressBytes(); 

                if (abOctet.Length == 4) 
                { 
                    uint ipV4 = 0;
 
                    for (int iPos = 0; iPos < 4; iPos++)
                    {
                        ipV4 = (ipV4 << 8) + abOctet[iPos];
                    } 

                    // no return result for this message, so if it get sent it must have succeeded 
                    Misc.ProxySendMessage(_hwnd, NativeMethods.IPM_SETADDRESS, IntPtr.Zero, (IntPtr)unchecked((int)ipV4)); 
                    return;
                } 
            }

            // this was no a valid IP address
            throw new InvalidOperationException (SR.Get(SRID.OperationCannotBePerformed)); 
        }
 
 
        // Request to get the value that this UI element is representing as a string
        string IValueProvider.Value 
        {
            get
            {
                return Misc.ProxyGetText(_hwnd, IP_ADDRESS_STRING_LENGTH); 
            }
        } 
 
        bool IValueProvider.IsReadOnly
        { 
            get
            {
                return !Misc.IsEnabled(_hwnd);
            } 
        }
 
        #endregion 

        #region Grid Pattern 

        // Obtain the AutomationElement at an zero based absolute position in the grid.
        // Where 0,0 is top left
        IRawElementProviderSimple IGridProvider.GetItem(int row, int column) 
        {
            // NOTE: IPAddress has only 1 row 
            if (row != 0) 
            {
                throw new ArgumentOutOfRangeException("row", row, SR.Get(SRID.GridRowOutOfRange)); 
            }

            if (column < 0 || column >= OCTETCOUNT)
            { 
                throw new ArgumentOutOfRangeException("column", column, SR.Get(SRID.GridColumnOutOfRange));
            } 
 
            // Note: GridItem position is in reverse from the hwnd position
            // take this into account 
            column = OCTETCOUNT - (column + 1);
            IntPtr hwndChild = GetChildWindowFromIndex(column);
            if (hwndChild != IntPtr.Zero)
            { 
                return new ByteEditBoxOverride(hwndChild, column);
            } 
            return null; 
        }
 
        int IGridProvider.RowCount
        {
            get
            { 
                return 1;
            } 
        } 

        int IGridProvider.ColumnCount 
        {
            get
            {
                return OCTETCOUNT; 
            }
        } 
 
        #endregion Grid Pattern
 
        //------------------------------------------------------
        //
        //  Private Methods
        // 
        //------------------------------------------------------
 
        #region Private Method 

        private IPAddress GetIPAddressFromString (String strIPAddress) 
        {
            String [] strIPAddresses = strIPAddress.Split (IP_ADDRESS_SEPERATOR);

            if (strIPAddresses.Length != 4) 
            {
                return null; 
            } 

            uint ipV4 = 0; 
            for (int iPos = 3; iPos >= 0; iPos--)
            {
                ipV4 = (ipV4 << 8) + byte.Parse(strIPAddresses[iPos], CultureInfo.InvariantCulture);
            } 

            return new IPAddress ((long) ipV4); 
        } 

        // Index or -1 (if not found) 
        private int GetIndexOfChildWindow (IntPtr target)
        {
            int index = 0;
            IntPtr hwndChild = Misc.GetWindow(_hwnd, NativeMethods.GW_CHILD); 
            while (hwndChild != IntPtr.Zero)
            { 
                if (hwndChild == target) 
                {
                    return index; 
                }

                index++;
                hwndChild = Misc.GetWindow(hwndChild, NativeMethods.GW_HWNDNEXT); 
            }
            return -1; 
        } 

        // get child window at index (0-based). IntPtr.Zero if not found 
        private IntPtr GetChildWindowFromIndex (int index)
        {
            IntPtr hwndChild = Misc.GetWindow(_hwnd, NativeMethods.GW_CHILD);
            for (int i = 0; ((i < index) && (hwndChild != IntPtr.Zero)); i++) 
            {
                hwndChild = Misc.GetWindow(hwndChild, NativeMethods.GW_HWNDNEXT); 
            } 
            return hwndChild;
        } 

        #endregion Private Method

        //----------------------------------------------------- 
        //
        //  Private Fields 
        // 
        //------------------------------------------------------
 
        #region Private Fields

        private const int IP_ADDRESS_STRING_LENGTH = 16;
        private const char IP_ADDRESS_SEPERATOR = '.'; 
        internal const int OCTETCOUNT = 4;
 
        #endregion Private Fields 

    } 

    // -----------------------------------------------------
    //
    //  ByteEditBoxOverride Private Class 
    //
    //----------------------------------------------------- 
 
    #region ByteEditBoxOverride
 
    // Placeholder/Extra Pattern provider for OctetEditBox
    // @review: 2003/08/15 - alexsn: Deriving from ProxyHwnd
    class ByteEditBoxOverride : ProxyHwnd, IGridItemProvider, IRangeValueProvider
    { 

        // ----------------------------------------------------- 
        // 
        //  Constructors
        // 
        //------------------------------------------------------

        #region Constructors
 
        internal ByteEditBoxOverride(IntPtr hwnd, int position) :
                base(hwnd, null, 0) 
        { 
            _sType = ST.Get(STID.LocalizedControlTypeOctet);
            _position = position; 
            _sAutomationId = "Octet " + position.ToString(CultureInfo.CurrentCulture); // This string is a non-localizable string
            _fIsKeyboardFocusable = true;
        }
 
        #endregion Constructors
 
        //----------------------------------------------------- 
        //
        //  Patterns Implementation 
        //
        //------------------------------------------------------

        #region ProxySimple Interface 

        internal override ProviderOptions ProviderOptions 
        { 
            get
            { 
                return base.ProviderOptions | ProviderOptions.OverrideProvider;
            }
        }
 
        // Returns a pattern interface if supported.
        internal override object GetPatternProvider(AutomationPattern iid) 
        { 
            if (GridItemPattern.Pattern == iid)
            { 
                return this;
            }

            if (RangeValuePattern.Pattern == iid) 
            {
                return this; 
            } 
            return null;
        } 

        // Gets the localized name
        internal override string LocalizedName
        { 
            get
            { 
                return Misc.ProxyGetText(_hwnd); 
            }
        } 

        #endregion

        #region  RangeValue Pattern 

        // Sets the one of the field of the IP Address. 
        void IRangeValueProvider.SetValue(double val) 
        {
            // Make sure that the control is enabled 
            if (!SafeNativeMethods.IsWindowEnabled(_hwnd))
            {
                throw new ElementNotEnabledException();
            } 

            int i = (int)val; 
 
            // Check range
            if (i > 255) 
            {
                throw new ArgumentOutOfRangeException("value", val, SR.Get(SRID.RangeValueMax));
            }
            if (i < 0) 
            {
                throw new ArgumentOutOfRangeException("value", val, SR.Get(SRID.RangeValueMin)); 
            } 

            // Set text 
            Misc.ProxySendMessage(_hwnd, NativeMethods.WM_SETTEXT, IntPtr.Zero, new StringBuilder(i.ToString(CultureInfo.CurrentCulture)));
        }

        // Request to get the value that this UI element is representing in a native format 
        double IRangeValueProvider.Value
        { 
            get 
            {
                string s = WindowsEditBox.Text(_hwnd); 
                if (string.IsNullOrEmpty(s))
                {
                    return double.NaN;
                } 
                return double.Parse(s, CultureInfo.CurrentCulture);
            } 
        } 

        bool IRangeValueProvider.IsReadOnly 
        {
            get
            {
                return !SafeNativeMethods.IsWindowEnabled(_hwnd); 
            }
        } 
 
        double IRangeValueProvider.Maximum
        { 
            get
            {
                return 255.0;
            } 
        }
 
        double IRangeValueProvider.Minimum 
        {
            get 
            {
                return 0.0;
            }
        } 

        double IRangeValueProvider.SmallChange 
        { 
            get
            { 
                return Double.NaN;
            }
        }
 
        double IRangeValueProvider.LargeChange
        { 
            get 
            {
                return Double.NaN; 
            }
        }

        #endregion 

        #region GridItem Pattern 
 
        int IGridItemProvider.Row
        { 
            get
            {
                return 0;
            } 
        }
        int IGridItemProvider.Column 
        { 
            get
            { 
                // Note hwnd locations are in reverse
                // we need to ajust columns accordnigly
                return WindowsIPAddress.OCTETCOUNT - 1 - _position;
            } 
        }
        int IGridItemProvider.RowSpan 
        { 
            get
            { 
                return 1;
            }
        }
        int IGridItemProvider.ColumnSpan 
        {
            get 
            { 
                return 1;
            } 
        }
        IRawElementProviderSimple IGridItemProvider.ContainingGrid
        {
            get 
            {
                return WindowsIPAddress.Create(Misc.GetParent(_hwnd), 0, 0); 
            } 
        }
 

        #endregion GridItem Pattern

        //------------------------------------------------------ 
        //
        //  Private Fields 
        // 
        //-----------------------------------------------------
 
        #region Private Fields

        // location in the IP
        private int _position; 

        #endregion Private Fields 
    } 

    #endregion 
}


// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK