WindowsStatusBar.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / wpf / src / UIAutomation / Win32Providers / MS / Internal / AutomationProxies / WindowsStatusBar.cs / 1305600 / WindowsStatusBar.cs

                            //---------------------------------------------------------------------------- 
//
// 
//    Copyright (C) Microsoft Corporation.  All rights reserved.
//  
//
// 
// Description: Windows Status Proxy 
//
// History: 
//  07/01/2003 : a-jeanp Created for WCP
//---------------------------------------------------------------------------

using System; 
using System.Collections;
using System.Text; 
using System.Windows.Automation; 
using System.Windows.Automation.Provider;
using System.ComponentModel; 
using System.Windows;
using System.Globalization;
using MS.Win32;
 
namespace MS.Internal.AutomationProxies
{ 
    class WindowsStatusBar : ProxyHwnd, IGridProvider, IRawElementProviderHwndOverride 
    {
        // ----------------------------------------------------- 
        //
        // Constructors
        //
        // ----------------------------------------------------- 

        #region Constructors 
 
        internal WindowsStatusBar(IntPtr hwnd, ProxyFragment parent, int item, Accessible acc)
            : base(hwnd, parent, item) 
        {
            _acc = acc;

            _cControlType = ControlType.StatusBar; 

            _fHasGrip = StatusBarGrip.HasGrip(hwnd); 
 
            _sAutomationId = "StatusBar"; // This string is a non-localizable string
 
            // 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 WindowsStatusBar(hwnd, null, idChild, null); 
        }
 
        // Static Create method called by the event tracker system
        internal static void RaiseEvents (IntPtr hwnd, int eventId, object idProp, int idObject, int idChild)
        {
            if (idObject != NativeMethods.OBJID_VSCROLL && idObject != NativeMethods.OBJID_HSCROLL) 
            {
                bool isWinforms = WindowsFormsHelper.IsWindowsFormsControl(hwnd); 
                ProxySimple el = isWinforms ? (ProxySimple)WindowsFormsHelper.Create(hwnd, 0, idObject) : (ProxySimple)Create(hwnd, 0); 
                if (el == null)
                { 
                    // WindowsFormsHelper may return null if the MSAA Role for this hwnd isn't handled
                    return;
                }
 
                if (idChild > 0)
                { 
                    if (eventId == NativeMethods.EventObjectNameChange && idChild == 1) 
                    {
                        // Need to let the overall control process this event also. 
                        el.DispatchEvents(eventId, idProp, idObject, idChild);
                    }

                    el = ((WindowsStatusBar)el).CreateStatusBarPane(idChild - 1); 
                }
 
                el.DispatchEvents(eventId, idProp, idObject, idChild); 
            }
        } 

        internal ProxySimple CreateStatusBarPane (int index)
        {
            // Use the Accessible object if this is a [....] control.  Only [....] StatusBars 
            // can have children.
            Accessible accChild = null; 
            if (_acc != null) 
            {
                // OLEACC's Win32 proxy does use a 1, 2, 3... scheme, but the [....] 
                // controls in some cases supply their own children, using a different scheme.
                // Using the "ByIndex" approach avoids having to know what the underlying
                // object's idChild scheme is.
                accChild = Accessible.GetFullAccessibleChildByIndex(_acc, index); 
                if (accChild != null && accChild.Role != AccessibleRole.PushButton)
                { 
                    // [....] toolbars have full IAccessibles for their children, but 
                    // return the overall hwnd; treat those same as regular items.
                    // We only want to special-case actual child hwnds for overriding. 
                    IntPtr hwndChild = accChild.Window;
                    if (hwndChild == IntPtr.Zero || hwndChild == _hwnd)
                    {
                        hwndChild = GetChildHwnd(_hwnd, accChild.Location); 
                    }
 
                    if(hwndChild != IntPtr.Zero && hwndChild != _hwnd) 
                    {
                        // We have an actual child hwnd. 
                        return new WindowsStatusBarPaneChildOverrideProxy(hwndChild, this, index);
                    }
                }
            } 
            return new WindowsStatusBarPane(_hwnd, this, index, accChild);
        } 
 
        #endregion Proxy Create
 
        // ------------------------------------------------------
        //
        // Patterns Implementation
        // 
        // -----------------------------------------------------
 
        #region ProxySimple Interface 

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

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

        #endregion ElementProvider 
 
        #region ProxyFragment Interface
 
        // Returns the next sibling element in the raw hierarchy.
        // Peripheral controls have always negative values.
        // Returns null if no next child
        internal override ProxySimple GetNextSibling (ProxySimple child) 
        {
            int item = child._item; 
            int count = Count; 

            // Next for an item that does not exist in the list 
            if (item >= count)
            {
                throw new ElementNotAvailableException ();
            } 

            // The grip is the last item. Exit when we see it. 
            if (item == GripItemID) 
            {
                return null; 
            }

            // Eventually add the Grip as the last element in the list
            return item + 1 < count ? CreateStatusBarPane(item + 1) : (_fHasGrip ? StatusBarGrip.Create(_hwnd, this, -1) : null); 
        }
 
        // Returns the previous sibling element in the raw hierarchy. 
        // Peripheral controls have always negative values.
        // Returns null is no previous 
        internal override ProxySimple GetPreviousSibling (ProxySimple child)
        {
            int item = child._item;
            int count = Count; 

            // Next for an item that does not exist in the list 
            if (item >= count) 
            {
                throw new ElementNotAvailableException (); 
            }

            // Grip is the last in the list but has a negative number
            // Fake a new item number that is last in the list 
            if (item == GripItemID)
            { 
                item = count; 
            }
 
            return item > 0 && (item - 1) < Count ? CreateStatusBarPane (item - 1) : null;
        }

        // Returns the first child element in the raw hierarchy. 
        internal override ProxySimple GetFirstChild ()
        { 
            // Grip is the last Element 
            return Count > 0 ? CreateStatusBarPane(0) : (_fHasGrip ? StatusBarGrip.Create(_hwnd, this, GripItemID) : null);
        } 

        // Returns the last child element in the raw hierarchy.
        internal override ProxySimple GetLastChild ()
        { 
            // Grip is the last Element
            if (_fHasGrip) 
            { 
                return StatusBarGrip.Create(_hwnd, this, GripItemID);
            } 

            int count = Count;
            return count > 0 ? CreateStatusBarPane (count - 1): null;
        } 

        // Returns a Proxy element corresponding to the specified screen coordinates. 
        internal override ProxySimple ElementProviderFromPoint (int x, int y) 
        {
            // Loop through all the panes 
            for (int item = 0, count = Count; item < count; item++)
            {
                NativeMethods.Win32Rect rc = new NativeMethods.Win32Rect (WindowsStatusBarPane.GetBoundingRectangle (_hwnd, item));
 
                if (Misc.PtInRect(ref rc, x, y))
                { 
                    return CreateStatusBarPane(item); 
                }
            } 

            // Try the Grip
            if (_fHasGrip)
            { 
                NativeMethods.Win32Rect rc = StatusBarGrip.GetBoundingRectangle (_hwnd);
                if (Misc.PtInRect(ref rc, x, y)) 
                { 
                    ProxySimple grip = StatusBarGrip.Create(_hwnd, this, -1);
                    return (ProxySimple)(grip != null ? grip : this); 
                }
            }
            return this;
        } 

        #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: Status bar has only 1 row
            if (row != 0) 
            { 
                throw new ArgumentOutOfRangeException("row", row, SR.Get(SRID.GridRowOutOfRange));
            } 

            if (column < 0 || column >= Count)
            {
                throw new ArgumentOutOfRangeException("column", column, SR.Get(SRID.GridColumnOutOfRange)); 
            }
 
            return CreateStatusBarPane(column); 
        }
 
        int IGridProvider.RowCount
        {
            get
            { 
                return 1;
            } 
        } 

        int IGridProvider.ColumnCount 
        {
            get
            {
                return Count; 
            }
        } 
 
        #endregion Grid Pattern
 
        #region IRawElementProviderHwndOverride Interface

        //------------------------------------------------------
        // 
        //  Interface IRawElementProviderHwndOverride
        // 
        //------------------------------------------------------ 
        IRawElementProviderSimple IRawElementProviderHwndOverride.GetOverrideProviderForHwnd(IntPtr hwnd)
        { 
            // return the appropriate placeholder for the given hwnd...
            // loop over all the band to find it.

            // Only [....] StatusBars can have children. 
            if (_acc != null)
            { 
                Accessible accChild = _acc.FirstChild; 
                IntPtr hwndChild = IntPtr.Zero;
 
                for (int i = 0; accChild != null; i++, accChild = accChild.NextSibling(_acc))
                {
                    hwndChild = accChild.Window;
                    if (hwndChild == IntPtr.Zero) 
                    {
                        hwndChild = GetChildHwnd(_hwnd, accChild.Location); 
                    } 
                    if (hwndChild == hwnd)
                    { 
                        return new WindowsStatusBarPaneChildOverrideProxy(hwnd, this, i);
                    }
                }
            } 

            return null; 
        } 

        #endregion IRawElementProviderHwndOverride Interface 

        // -----------------------------------------------------
        //
        // Private Methods 
        //
        // ------------------------------------------------------ 
 
        #region Private Methods
 
        // Returns the number of Status Bar Panes
        private int Count
        {
            get 
            {
                if (_acc == null) 
                { 
                    return Misc.ProxySendMessageInt(_hwnd, NativeMethods.SB_GETPARTS, IntPtr.Zero, IntPtr.Zero);
                } 
                else
                {
                    return _acc.ChildCount;
                } 
            }
        } 
 
        unsafe static private IntPtr GetChildHwnd(IntPtr hwnd, Rect rc)
        { 
            UnsafeNativeMethods.ENUMCHILDWINDOWFROMRECT info = new UnsafeNativeMethods.ENUMCHILDWINDOWFROMRECT();

            info.hwnd = IntPtr.Zero;
            info.rc.left = (int)rc.Left; 
            info.rc.top = (int)rc.Top;
            info.rc.right = (int)rc.Right; 
            info.rc.bottom = (int)rc.Bottom; 

            Misc.EnumChildWindows(hwnd, new NativeMethods.EnumChildrenCallbackVoid(FindChildFromRect), (void*)&info); 

            return info.hwnd;
        }
 
        unsafe static private bool FindChildFromRect(IntPtr hwnd, void* lParam)
        { 
            NativeMethods.Win32Rect rc = NativeMethods.Win32Rect.Empty; 
            if (!Misc.GetClientRectInScreenCoordinates(hwnd, ref rc))
            { 
                return true;
            }

            UnsafeNativeMethods.ENUMCHILDWINDOWFROMRECT * info = (UnsafeNativeMethods.ENUMCHILDWINDOWFROMRECT *)lParam; 

            if (rc.left == info->rc.left && rc.top == info->rc.top && rc.right == info->rc.right && rc.bottom == info->rc.bottom) 
            { 
                info->hwnd = hwnd;
                return false; 
            }

            return true;
        } 

        #endregion 
 
        // -----------------------------------------------------
        // 
        // Private Fields
        //
        // -----------------------------------------------------
 
        #region Private Fields
 
        // Status bar with a Grip Style 
        private bool _fHasGrip;
        private Accessible _acc;   // Accessible is used for [....] controls. 

        // Item ID for the grip. Must be negative as it is a peripheral element
        private const int GripItemID = -1;
 
        private const int SBARS_SIZEGRIP = 0x0100;
 
        #endregion 

        // ----------------------------------------------------- 
        //
        // WindowsStatusBarPane Private Class
        //
        // ------------------------------------------------------ 

        #region WindowsStatusBarPane 
 
        class WindowsStatusBarPane : ProxySimple, IGridItemProvider, IValueProvider
        { 

            // -----------------------------------------------------
            //
            //  Constructors 
            //
            //------------------------------------------------------ 
 
            #region Constructors
 
            internal WindowsStatusBarPane (IntPtr hwnd, ProxyFragment parent, int item, Accessible acc)
            : base (hwnd, parent, item)
            {
                _acc = acc; 

                _cControlType = ControlType.Edit; 
                _sAutomationId = "StatusBar.Pane" + item.ToString(CultureInfo.CurrentCulture); // This string is a non-localizable string 
            }
 
            #endregion

            //------------------------------------------------------
            // 
            //  Patterns Implementation
            // 
            //----------------------------------------------------- 

            #region ProxySimple Interface 

            // Returns a pattern interface if supported.
            internal override object GetPatternProvider (AutomationPattern iid)
            { 
                if (iid == GridItemPattern.Pattern)
                { 
                    return this; 
                }
                else if (iid == ValuePattern.Pattern) 
                {
                    return this;
                }
 
                return null;
            } 
 
            // Gets the bounding rectangle for this element
            internal override Rect BoundingRectangle 
            {
                get
                {
                    return GetBoundingRectangle (_hwnd, _item); 
                }
            } 
 
            // Gets the localized name
            internal override string LocalizedName 
            {
                get
                {
                    return Text; 
                }
            } 
 
            #endregion ProxySimple Interface
 
            #region Grid Pattern

            int IGridItemProvider.Row
            { 
                get
                { 
                    return 0; 
                }
            } 

            int IGridItemProvider.Column
            {
                get 
                {
                    return _item; 
                } 
            }
 
            int IGridItemProvider.RowSpan
            {
                get
                { 
                    return 1;
                } 
            } 

            int IGridItemProvider.ColumnSpan 
            {
                get
                {
                    return 1; 
                }
            } 
 
            IRawElementProviderSimple IGridItemProvider.ContainingGrid
            { 
                get
                {
                    return _parent;
                } 
            }
 
            #endregion Grid Pattern 

            #region Value Pattern 

            // Sets the text of the edit.
            void IValueProvider.SetValue(string str)
            { 
                // This is a read only element.
                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 Text;
                } 
            } 

            // Read only status 
            bool IValueProvider.IsReadOnly
            {
                get
                { 
                    return true;
                } 
            } 

            #endregion 

            //------------------------------------------------------
            //
            //  Internal Methods 
            //
            //----------------------------------------------------- 
 
            #region Internal Methods
 
            // Retrieves the bounding rectangle of the Status Bar Pane.
            static internal Rect GetBoundingRectangle (IntPtr hwnd, int item)
            {
                if( !WindowsFormsHelper.IsWindowsFormsControl(hwnd)) 
                {
                    return XSendMessage.GetItemRect(hwnd, NativeMethods.SB_GETRECT, item); 
                } 
                else
                { 
                    Accessible acc = null;
                    if (Accessible.AccessibleObjectFromWindow(hwnd, NativeMethods.OBJID_CLIENT, ref acc) != NativeMethods.S_OK || acc == null)
                    {
                        return Rect.Empty; 
                    }
                    else 
                    { 
                        // OLEACC's Win32 proxy does use a 1, 2, 3... scheme, but the [....]
                        // controls in some cases supply their own children, using a different scheme. 
                        // Using the "ByIndex" approach avoids having to know what the underlying
                        // object's idChild scheme is.
                        acc = Accessible.GetFullAccessibleChildByIndex(acc, item);
                        if (acc == null) 
                        {
                            return Rect.Empty; 
                        } 
                        else
                        { 
                            return acc.Location;
                        }
                    }
                } 
            }
 
            //Gets the localized name 
            internal string Text
            { 
                get
                {
                    if (_acc == null)
                    { 
                        // Get the length of the string
                        int retValue = Misc.ProxySendMessageInt(_hwnd, NativeMethods.SB_GETTEXTLENGTHW, new IntPtr(_item), IntPtr.Zero); 
 
                        // The low word specifies the length, in characters, of the text.
                        // The high word specifies the type of operation used to draw the text. 
                        int len = NativeMethods.Util.LOWORD(retValue);
                        return XSendMessage.GetItemText(_hwnd, NativeMethods.SB_GETTEXTW, _item, len);
                    }
                    else 
                    {
                        return _acc.Name; 
                    } 
                }
            } 

            #endregion

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

            private Accessible _acc; // Accessible is used for [....] controls.
 
            #endregion
 
        } 
        #endregion
 
        // ------------------------------------------------------
        //
        //  WindowsStatusBarPaneChildOverrideProxy Private Class
        // 
        //-----------------------------------------------------
 
        #region WindowsStatusBarPaneChildOverrideProxy 

        class WindowsStatusBarPaneChildOverrideProxy : ProxyHwnd, IGridItemProvider 
        {
            // ------------------------------------------------------
            //
            // Constructors 
            //
            // ------------------------------------------------------ 
 
            #region Constructors
 
            internal WindowsStatusBarPaneChildOverrideProxy(IntPtr hwnd, ProxyFragment parent, int item)
                : base(hwnd, parent, item)
            {
            } 

            #endregion 
 
            //-----------------------------------------------------
            // 
            //  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 (iid == GridItemPattern.Pattern) 
                {
                    return this;
                }
                return null; 
            }
 
            internal override object GetElementProperty(AutomationProperty idProp) 
            {
                // No property should be handled by the override proxy 
                // Overrides the ProxySimple implementation.
                return null;
            }
 
            #endregion
 
            #region Grid Pattern 

            int IGridItemProvider.Row 
            {
                get
                {
                    return 0; 
                }
            } 
 
            int IGridItemProvider.Column
            { 
                get
                {
                    return _item;
                } 
            }
 
            int IGridItemProvider.RowSpan 
            {
                get 
                {
                    return 1;
                }
            } 

            int IGridItemProvider.ColumnSpan 
            { 
                get
                { 
                    return 1;
                }
            }
 
            IRawElementProviderSimple IGridItemProvider.ContainingGrid
            { 
                get 
                {
                    return _parent; 
                }
            }

            #endregion Grid Pattern 
        }
 
        #endregion 
        // -----------------------------------------------------
        // 
        // StatusBarGrip Private Class
        //
        // -----------------------------------------------------
 
        #region StatusBarGrip
 
        class StatusBarGrip: ProxyFragment 
        {
            // ----------------------------------------------------- 
            //
            //  Constructors
            //
            //------------------------------------------------------ 

            #region Constructors 
 
            public StatusBarGrip (IntPtr hwnd, ProxyHwnd parent, int item)
                : base( hwnd, parent, item) 
            {
                _sType = ST.Get(STID.LocalizedControlTypeGrip);
                _sAutomationId = "StatusBar.Grip"; // This string is a non-localizable string
            } 

            #endregion 
 
            //-----------------------------------------------------
            // 
            //  Patterns Implementation
            //
            //------------------------------------------------------
 
            #region ProxySimple Interface
 
            // Gets the bounding rectangle for this element 
            internal override Rect BoundingRectangle
            { 
                get
                {
                    return GetBoundingRectangle(_hwnd).ToRect(Misc.IsControlRTL(_hwnd));
                } 
            }
 
            #endregion 

            //------------------------------------------------------ 
            //
            //  Internal Methods
            //
            //----------------------------------------------------- 

            #region Internal Methods 
 
            // Gets the bounding rectangle for this element
            internal static NativeMethods.Win32Rect GetBoundingRectangle (IntPtr hwnd) 
            {
                if (!HasGrip(hwnd))
                {
                    return NativeMethods.Win32Rect.Empty; 
                }
 
                NativeMethods.Win32Rect client = new NativeMethods.Win32Rect(); 
                if (!Misc.GetClientRectInScreenCoordinates(hwnd, ref client))
                { 
                    return NativeMethods.Win32Rect.Empty;
                }

                // Get the Size for the Gripper 
                // The size can change at any time so the value cannot be cached
                NativeMethods.SIZE sizeGrip = WindowsGrip.GetGripSize(hwnd, true); 
 
                if (Misc.IsLayoutRTL(hwnd))
                { 
                    // Right to left mirroring style
                    return new NativeMethods.Win32Rect(client.left, client.bottom - sizeGrip.cy, sizeGrip.cx, client.bottom);
                }
                else 
                {
                    return new NativeMethods.Win32Rect(client.right - sizeGrip.cx, client.bottom - sizeGrip.cy, client.right, client.bottom); 
                } 
            }
 
            internal static StatusBarGrip Create(IntPtr hwnd, ProxyHwnd parent, int item)
            {
                if(HasGrip(hwnd))
                { 
                    return new StatusBarGrip(hwnd, parent, item);
                } 
 
                return null;
            } 

            #endregion

            #region Private Methods 
            internal static bool HasGrip(IntPtr hwnd)
            { 
                int style = Misc.GetWindowStyle(hwnd); 
                return Misc.IsBitSet(style, SBARS_SIZEGRIP) || WindowsGrip.IsGripPresent(hwnd, true);
            } 
            #endregion
        }

        #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