Expander.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 / wcp / Framework / System / Windows / Controls / Expander.cs / 1 / Expander.cs
                        

                        
                            //---------------------------------------------------------------------------- 
//
// Copyright (C) Microsoft Corporation.  All rights reserved.
//
//--------------------------------------------------------------------------- 

using System; 
using System.Windows; 
using System.Windows.Automation;
using System.Windows.Automation.Peers; 
using System.Windows.Controls;
using System.ComponentModel;
using MS.Internal.KnownBoxes;
 

namespace System.Windows.Controls 
{ 
    /// 
    /// Specifies the expanding direction of a expansion. 
    /// 
    public enum ExpandDirection
    {
        ///  
        /// Expander will expand to the down direction.
        ///  
        Down = 0, 
        /// 
        /// Expander will expand to the up direction. 
        /// 
        Up = 1,
        /// 
        /// Expander will expand to the left direction. 
        /// 
        Left = 2, 
        ///  
        /// Expander will expand to the right direction.
        ///  
        Right = 3,
    }

    ///  
    /// An Expander control allows a user to view a header and expand that
    /// header to see further details of the content, or to collapse the section 
    /// up to the header to save space. 
    /// 
    [Localizability(LocalizationCategory.None, Readability = Readability.Unreadable)] // cannot be read & localized as string 
    public class Expander : HeaderedContentControl
    {
        //-------------------------------------------------------------------
        // 
        //  Constructors
        // 
        //------------------------------------------------------------------- 

        #region Constructors 

        static Expander()
        {
            DefaultStyleKeyProperty.OverrideMetadata(typeof(Expander), new FrameworkPropertyMetadata(typeof(Expander))); 
            _dType = DependencyObjectType.FromSystemTypeInternal(typeof(Expander));
 
            IsTabStopProperty.OverrideMetadata(typeof(Expander), new FrameworkPropertyMetadata(BooleanBoxes.FalseBox)); 
        }
 
        #endregion

        //--------------------------------------------------------------------
        // 
        //  Public Properties
        // 
        //------------------------------------------------------------------- 

        #region Public Properties 

        /// 
        /// ExpandDirection specifies to which direction the content will expand
        ///  
        [Bindable(true), Category("Behavior")]
        public ExpandDirection ExpandDirection 
        { 
            get { return (ExpandDirection) GetValue(ExpandDirectionProperty); }
            set { SetValue(ExpandDirectionProperty, value); } 
        }

        /// 
        /// The DependencyProperty for the ExpandDirection property. 
        /// Default Value: ExpandDirection.Down
        ///  
        public static readonly DependencyProperty ExpandDirectionProperty = 
                DependencyProperty.Register(
                        "ExpandDirection", 
                        typeof(ExpandDirection),
                        typeof(Expander),
                        new FrameworkPropertyMetadata(
                                ExpandDirection.Down /* default value */, 
                                FrameworkPropertyMetadataOptions.BindsTwoWayByDefault),
                        new ValidateValueCallback(IsValidExpandDirection)); 
 
        private static bool IsValidExpandDirection(object o)
        { 
            ExpandDirection value = (ExpandDirection)o;

            return (value == ExpandDirection.Down ||
                    value == ExpandDirection.Left || 
                    value == ExpandDirection.Right ||
                    value == ExpandDirection.Up); 
        } 

        ///  
        ///     The DependencyProperty for the IsExpanded property.
        ///     Default Value: false
        /// 
        public static readonly DependencyProperty IsExpandedProperty = 
                DependencyProperty.Register(
                        "IsExpanded", 
                        typeof(bool), 
                        typeof(Expander),
                        new FrameworkPropertyMetadata( 
                                BooleanBoxes.FalseBox /* default value */,
                                FrameworkPropertyMetadataOptions.BindsTwoWayByDefault | FrameworkPropertyMetadataOptions.Journal,
                                new PropertyChangedCallback(OnIsExpandedChanged)));
 
        private static void OnIsExpandedChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        { 
            Expander ep = (Expander) d; 

            bool newValue = (bool) e.NewValue; 

            // Fire accessibility event
            ExpanderAutomationPeer peer = UIElementAutomationPeer.FromElement(ep) as ExpanderAutomationPeer;
            if(peer != null) 
            {
                peer.RaiseExpandCollapseAutomationEvent(!newValue, newValue); 
            } 

            if (newValue) 
            {
                ep.OnExpanded();
            }
            else 
            {
                ep.OnCollapsed(); 
            } 
        }
 
        /// 
        /// IsExpanded indicates whether the expander is currently expanded.
        /// 
        [Bindable(true), Category("Appearance")] 
        public bool IsExpanded
        { 
            get { return (bool) GetValue(IsExpandedProperty); } 
            set { SetValue(IsExpandedProperty, BooleanBoxes.Box(value)); }
        } 

        /// 
        /// Expanded event.
        ///  
        public static readonly RoutedEvent ExpandedEvent =
            EventManager.RegisterRoutedEvent("Expanded", 
                RoutingStrategy.Bubble, 
                typeof(RoutedEventHandler),
                typeof(Expander) 
            );

        /// 
        /// Expanded event. It is fired when IsExpanded changed from false to true. 
        /// 
        public event RoutedEventHandler Expanded 
        { 
            add { AddHandler(ExpandedEvent, value); }
            remove { RemoveHandler(ExpandedEvent, value); } 
        }

        /// 
        /// Collapsed event. 
        /// 
        public static readonly RoutedEvent CollapsedEvent = 
            EventManager.RegisterRoutedEvent("Collapsed", 
                RoutingStrategy.Bubble,
                typeof(RoutedEventHandler), 
                typeof(Expander)
            );

        ///  
        /// Collapsed event. It is fired when IsExpanded changed from true to false.
        ///  
        public event RoutedEventHandler Collapsed 
        {
            add { AddHandler(CollapsedEvent, value); } 
            remove { RemoveHandler(CollapsedEvent, value); }
        }

        #endregion 

        //-------------------------------------------------------------------- 
        // 
        //  Protected Methods
        // 
        //--------------------------------------------------------------------

        #region Protected Methods
 
        /// 
        /// A virtual function that is called when the IsExpanded property is changed to true. 
        /// Default behavior is to raise an ExpandedEvent. 
        /// 
        protected virtual void OnExpanded() 
        {
            RoutedEventArgs args = new RoutedEventArgs();
            args.RoutedEvent =(Expander.ExpandedEvent);
            args.Source=this; 
            RaiseEvent(args);
        } 
 
        /// 
        /// A virtual function that is called when the IsExpanded property is changed to false. 
        /// Default behavior is to raise a CollapsedEvent.
        /// 
        protected virtual void OnCollapsed()
        { 
            RaiseEvent(new RoutedEventArgs(Expander.CollapsedEvent, this));
        } 
 
        #endregion
 
        #region Accessibility

        /// 
        /// Creates AutomationPeer () 
        /// 
        protected override AutomationPeer OnCreateAutomationPeer() 
        { 
            return new ExpanderAutomationPeer(this);
        } 

        #endregion

 
        //-------------------------------------------------------------------
        // 
        //  Private Fields 
        //
        //-------------------------------------------------------------------- 

        #region Private Fields

        #endregion 

        #region DTypeThemeStyleKey 
 
        // Returns the DependencyObjectType for the registered ThemeStyleKey's default
        // value. Controls will override this method to return approriate types. 
        internal override DependencyObjectType DTypeThemeStyleKey
        {
            get { return _dType; }
        } 

        private static DependencyObjectType _dType; 
 
        #endregion DTypeThemeStyleKey
    } 
}

// 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