RoutedEventArgs.cs source code in C# .NET

                        
Code:
                         / 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / wpf / src / Core / CSharp / System / Windows / RoutedEventArgs.cs / 1305600 / RoutedEventArgs.cs
                        

                        
                            using System; 
using System.Security;

using SR=MS.Internal.PresentationCore.SR;
using SRID=MS.Internal.PresentationCore.SRID; 
using MS.Internal.PresentationCore;
using System.Collections.Specialized ; 
using System.Windows.Input; 
using System.Diagnostics;
using MS.Internal; 

namespace System.Windows
{
    /// 
 
    ///     The container for all state associated
    ///     with a RoutedEvent 
    /// 
 
    /// 
    ///      
    ///     constitutes the 
    ///     , 
    ///     , 
    ///      and  
    ///      
    ///      
    /// 
    ///     Different 
    ///     can be used with a single   
    ///     
    ///
    ///     The  is responsible
    ///     for packaging the , 
    ///     providing extra event state info, and invoking the
    ///     handler associated with the RoutedEvent 
    ///  
    public class RoutedEventArgs : EventArgs
    { 
        #region Construction

        /// 

        ///     Constructor for  
        /// 
        ///  
        ///     All members take default values  
        ///     
        /// 
        ///     
        ///     defaults to null 
        ///      defaults to
        ///     false  
        ///      defaults to null 
        ///      also defaults to null 
        ///      
        /// 
        public RoutedEventArgs() 
        {
        }

        /// 
 
        ///     Constructor for 
        /// 
 
        /// The new value that the RoutedEvent Property is being set to  
        public RoutedEventArgs(RoutedEvent routedEvent) : this( routedEvent, null)
        { 
        }

        /// 

        ///     Constructor for  
        /// 
        /// The new value that the SourceProperty is being set to  
        /// The new value that the RoutedEvent Property is being set to  
        public RoutedEventArgs(RoutedEvent routedEvent, object source)
        { 
            _routedEvent = routedEvent;
            _source = _originalSource = source;
        }
 
        #endregion Construction
 
        #region External API 
        /// 

        ///     Returns the  associated 
        ///     with this 
        /// 
        /// 
        ///     The  cannot be null 
        ///     at any time
        ///  
        public RoutedEvent RoutedEvent 
        {
            get {return _routedEvent;} 
            set
            {
                if (UserInitiated && InvokingHandler)
                    throw new InvalidOperationException(SR.Get(SRID.RoutedEventCannotChangeWhileRouting)); 

                _routedEvent = value; 
            } 
        }
 
        /// 

        ///     Changes the RoutedEvent assocatied with these RoutedEventArgs
        /// 
        ///  
        ///     Only used internally.  Added to support cracking generic MouseButtonDown/Up events
        ///     into MouseLeft/RightButtonDown/Up events. 
        ///  
        /// 
        ///     The new RoutedEvent to associate with these RoutedEventArgs 
        /// 
        internal void OverrideRoutedEvent( RoutedEvent newRoutedEvent )
        {
            _routedEvent = newRoutedEvent; 
        }
 
        /// 
 
        ///     Returns a boolean flag indicating if or not this
        ///     RoutedEvent has been handled this far in the route 
        /// 
        /// 
        ///     Initially starts with a false value before routing
        ///     has begun 
        /// 
        /// 
        /// Critical - _flags is critical due to UserInitiated value. 
        /// PublicOK - in this function we're not setting UserInitiated - we're setting Handled.
        /// 
        public bool Handled
        {
            [SecurityCritical ]
            get 
            {
                return _flags[ HandledIndex ] ; 
            } 

            [SecurityCritical ] 
            set
            {
                if (_routedEvent == null)
                { 
                    throw new InvalidOperationException(SR.Get(SRID.RoutedEventArgsMustHaveRoutedEvent));
                } 
 

                if( TraceRoutedEvent.IsEnabled ) 
                {
                    TraceRoutedEvent.TraceActivityItem(
                                            TraceRoutedEvent.HandleEvent,
                                            value, 
                                            RoutedEvent.OwnerType.Name,
                                            RoutedEvent.Name, 
                                            this ); 
                }
 

                // Note: We need to allow the caller to change the handled value
                // from true to false.
                // 
                // We are concerned about scenarios where a child element
                // listens to a high-level event (such as TextInput) while a 
                // parent element listens tp a low-level event such as KeyDown. 
                // In these scenarios, we want the parent to not respond to the
                // KeyDown event, in deference to the child. 
                //
                // Internally we implement this by asking the parent to only
                // respond to KeyDown events if they have focus.  This works
                // around the problem and is an example of an unofficial 
                // protocol coordinating the two elements.
                // 
                // But we imagine that there will be some cases we miss or 
                // that third parties introduce.  For these cases, we expect
                // that the application author may need to mark the KeyDown 
                // as handled in the child, and then reset the event to
                // being unhandled after the parent, so that default processing
                // and promotion still occur.
                // 
                // For more information see the following task:
                // 20284: Input promotion breaks down when lower level input is intercepted 
 
                _flags[ HandledIndex ] = value;
 
            }
        }

        /// 
 
        ///     Returns Source object that raised the RoutedEvent
        /// 
 
        public object Source 
        {
            get {return _source;} 
            set
            {

                if (InvokingHandler && UserInitiated) 
                    throw new InvalidOperationException(SR.Get(SRID.RoutedEventCannotChangeWhileRouting));
 
                if (_routedEvent == null) 
                {
                    throw new InvalidOperationException(SR.Get(SRID.RoutedEventArgsMustHaveRoutedEvent)); 
                }


                object source = value ; 
                if (_source == null && _originalSource == null)
                { 
                    // Gets here when it is the first time that the source is set. 
                    // This implies that this is also the original source of the event
                    _source = _originalSource = source; 
                    OnSetSource(source);
                }
                else if (_source != source)
                { 
                    // This is the actiaon taken at all other times when the
                    // source is being set to a different value from what it was 
                    _source = source; 
                    OnSetSource(source);
                } 
            }
        }

        /// 
 
        ///     Changes the Source assocatied with these RoutedEventArgs
        /// 
 
        ///  
        ///     Only used internally.  Added to support cracking generic MouseButtonDown/Up events
        ///     into MouseLeft/RightButtonDown/Up events. 
        /// 
        /// 
        ///     The new object to associate as the source of these RoutedEventArgs
        ///  
        internal void OverrideSource( object source )
        { 
            _source = source; 
        }
 
        /// 

        ///     Returns OriginalSource object that raised the RoutedEvent
        /// 
        ///  
        ///     Always returns the OriginalSource object that raised the
        ///     RoutedEvent unlike  
        ///     that may vary under specific scenarios  
        ///     This property acquires its value once before the event
        ///     handlers are invoked and never changes then on 
        /// 
        public object OriginalSource
        {
            get {return _originalSource;} 
        }
 
        /// 
 
        ///     Invoked when the source of the event is set
        /// 
 
        /// 
        ///     Changing the source of an event can often
        ///     require updating the data within the event.
        ///     For this reason, the OnSource=  method is 
        ///     protected virtual and is meant to be
        ///     overridden by sub-classes of 
        ///       
        ///     Also see 
        ///  
        /// 
        ///     The new value that the SourceProperty is being set to
        /// 
        protected virtual void OnSetSource(object source) 
        {
        } 
 
        /// 

        ///     Invokes the generic handler with the 
        ///     appropriate arguments
        /// 
        /// 
        ///     Is meant to be overridden by sub-classes of 
        ///      to provide
        ///     more efficient invocation of their delegate 
        ///  
        /// 
        ///     Generic Handler to be invoked 
        /// 
        /// 
        ///     Target on whom the Handler will be invoked
        ///  
        protected virtual void InvokeEventHandler(Delegate genericHandler, object genericTarget)
        { 
            if (genericHandler == null) 
            {
                throw new ArgumentNullException("genericHandler"); 
            }

            if (genericTarget == null)
            { 
                throw new ArgumentNullException("genericTarget");
            } 
 
            if (_routedEvent == null)
            { 
                throw new InvalidOperationException(SR.Get(SRID.RoutedEventArgsMustHaveRoutedEvent));
            }

            InvokingHandler = true; 
            try
            { 
                if (genericHandler is RoutedEventHandler) 
                {
                    ((RoutedEventHandler)genericHandler)(genericTarget, this); 
                }
                else
                {
                    // Restricted Action - reflection permission required 
                    genericHandler.DynamicInvoke(new object[] {genericTarget, this});
                } 
            } 
            finally
            { 
                InvokingHandler = false;
            }

        } 

        #endregion External API 
 
        #region Operations
 
        // Calls the InvokeEventHandler protected
        // virtual method
        //
        // This method is needed because 
        // delegates are invoked from
        // RoutedEventHandler which is not a 
        // sub-class of RoutedEventArgs 
        // and hence cannot invoke protected
        // method RoutedEventArgs.FireEventHandler 
        internal void InvokeHandler(Delegate handler, object target)
        {
            InvokingHandler = true;
 
            try
            { 
                InvokeEventHandler(handler, target); 
            }
            finally 
            {
                InvokingHandler = false;
            }
        } 

        /// 
        ///     Critical - access critical information, if this is a user initiated command 
        ///     TreatAsSafe - checking user initiated bit considered safe.
        /// 
        internal bool UserInitiated
        {
            [SecurityCritical, SecurityTreatAsSafe ]
            [FriendAccessAllowed] // Also used by Framework. 
            get
            { 
                if (_flags [UserInitiatedIndex]) 
                {
                    return SecurityHelper.CallerHasUserInitiatedRoutedEventPermission(); 
                }
                return false;
            }
        } 

        ///  
        ///     Critical - access critical information, if this is a user initiated command 
        /// 
        [SecurityCritical] 
        internal void MarkAsUserInitiated()
        {
            _flags [ UserInitiatedIndex ] = true;
        } 

        ///  
        ///     Critical - access critical information, if this is a user initiated command 
        ///     TreatAsSafe - clearing user initiated bit considered safe.
        ///  
        [SecurityCritical, SecurityTreatAsSafe ]
        internal void ClearUserInitiated()
        {
            _flags [ UserInitiatedIndex ] = false ; 
        }
 
        /// 
        /// Critical - _flags is critical due to UserInitiated value.
        /// TreatAsSafe - in this function we're not setting UserInitiated - we're setting InvokingHandler. 
        ///
        private bool InvokingHandler
        {
            [SecurityCritical, SecurityTreatAsSafe ] 
            get
            { 
                return _flags[InvokingHandlerIndex]; 
            }
            [SecurityCritical, SecurityTreatAsSafe ] 
            set
            {
                _flags[InvokingHandlerIndex] = value;
            } 
        }
        #endregion Operations 
 

 
        #region Data

        private RoutedEvent _routedEvent;
        private object _source; 
        private object _originalSource;
 
        /// 
        /// Critical - the UserInitiated flag value is critical.
        /// 
        [SecurityCritical]
        private BitVector32          _flags;

        private const int HandledIndex                          = 1; 
        private const int UserInitiatedIndex                    = 2;
        private const int InvokingHandlerIndex                  = 4; 
 

        #endregion Data 
    }

    /// 

    ///     RoutedEventHandler Definition 
    /// 
    ///  
    public delegate void RoutedEventHandler(object sender, RoutedEventArgs e); 
}
 

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

using SR=MS.Internal.PresentationCore.SR;
using SRID=MS.Internal.PresentationCore.SRID; 
using MS.Internal.PresentationCore;
using System.Collections.Specialized ; 
using System.Windows.Input; 
using System.Diagnostics;
using MS.Internal; 

namespace System.Windows
{
    /// 
 
    ///     The container for all state associated
    ///     with a RoutedEvent 
    /// 
 
    /// 
    ///      
    ///     constitutes the 
    ///     , 
    ///     , 
    ///      and  
    ///      
    ///      
    /// 
    ///     Different 
    ///     can be used with a single   
    ///     
    ///
    ///     The  is responsible
    ///     for packaging the , 
    ///     providing extra event state info, and invoking the
    ///     handler associated with the RoutedEvent 
    ///  
    public class RoutedEventArgs : EventArgs
    { 
        #region Construction

        /// 

        ///     Constructor for  
        /// 
        ///  
        ///     All members take default values  
        ///     
        /// 
        ///     
        ///     defaults to null 
        ///      defaults to
        ///     false  
        ///      defaults to null 
        ///      also defaults to null 
        ///      
        /// 
        public RoutedEventArgs() 
        {
        }

        /// 
 
        ///     Constructor for 
        /// 
 
        /// The new value that the RoutedEvent Property is being set to  
        public RoutedEventArgs(RoutedEvent routedEvent) : this( routedEvent, null)
        { 
        }

        /// 

        ///     Constructor for  
        /// 
        /// The new value that the SourceProperty is being set to  
        /// The new value that the RoutedEvent Property is being set to  
        public RoutedEventArgs(RoutedEvent routedEvent, object source)
        { 
            _routedEvent = routedEvent;
            _source = _originalSource = source;
        }
 
        #endregion Construction
 
        #region External API 
        /// 

        ///     Returns the  associated 
        ///     with this 
        /// 
        /// 
        ///     The  cannot be null 
        ///     at any time
        ///  
        public RoutedEvent RoutedEvent 
        {
            get {return _routedEvent;} 
            set
            {
                if (UserInitiated && InvokingHandler)
                    throw new InvalidOperationException(SR.Get(SRID.RoutedEventCannotChangeWhileRouting)); 

                _routedEvent = value; 
            } 
        }
 
        /// 

        ///     Changes the RoutedEvent assocatied with these RoutedEventArgs
        /// 
        ///  
        ///     Only used internally.  Added to support cracking generic MouseButtonDown/Up events
        ///     into MouseLeft/RightButtonDown/Up events. 
        ///  
        /// 
        ///     The new RoutedEvent to associate with these RoutedEventArgs 
        /// 
        internal void OverrideRoutedEvent( RoutedEvent newRoutedEvent )
        {
            _routedEvent = newRoutedEvent; 
        }
 
        /// 
 
        ///     Returns a boolean flag indicating if or not this
        ///     RoutedEvent has been handled this far in the route 
        /// 
        /// 
        ///     Initially starts with a false value before routing
        ///     has begun 
        /// 
        /// 
        /// Critical - _flags is critical due to UserInitiated value. 
        /// PublicOK - in this function we're not setting UserInitiated - we're setting Handled.
        /// 
        public bool Handled
        {
            [SecurityCritical ]
            get 
            {
                return _flags[ HandledIndex ] ; 
            } 

            [SecurityCritical ] 
            set
            {
                if (_routedEvent == null)
                { 
                    throw new InvalidOperationException(SR.Get(SRID.RoutedEventArgsMustHaveRoutedEvent));
                } 
 

                if( TraceRoutedEvent.IsEnabled ) 
                {
                    TraceRoutedEvent.TraceActivityItem(
                                            TraceRoutedEvent.HandleEvent,
                                            value, 
                                            RoutedEvent.OwnerType.Name,
                                            RoutedEvent.Name, 
                                            this ); 
                }
 

                // Note: We need to allow the caller to change the handled value
                // from true to false.
                // 
                // We are concerned about scenarios where a child element
                // listens to a high-level event (such as TextInput) while a 
                // parent element listens tp a low-level event such as KeyDown. 
                // In these scenarios, we want the parent to not respond to the
                // KeyDown event, in deference to the child. 
                //
                // Internally we implement this by asking the parent to only
                // respond to KeyDown events if they have focus.  This works
                // around the problem and is an example of an unofficial 
                // protocol coordinating the two elements.
                // 
                // But we imagine that there will be some cases we miss or 
                // that third parties introduce.  For these cases, we expect
                // that the application author may need to mark the KeyDown 
                // as handled in the child, and then reset the event to
                // being unhandled after the parent, so that default processing
                // and promotion still occur.
                // 
                // For more information see the following task:
                // 20284: Input promotion breaks down when lower level input is intercepted 
 
                _flags[ HandledIndex ] = value;
 
            }
        }

        /// 
 
        ///     Returns Source object that raised the RoutedEvent
        /// 
 
        public object Source 
        {
            get {return _source;} 
            set
            {

                if (InvokingHandler && UserInitiated) 
                    throw new InvalidOperationException(SR.Get(SRID.RoutedEventCannotChangeWhileRouting));
 
                if (_routedEvent == null) 
                {
                    throw new InvalidOperationException(SR.Get(SRID.RoutedEventArgsMustHaveRoutedEvent)); 
                }


                object source = value ; 
                if (_source == null && _originalSource == null)
                { 
                    // Gets here when it is the first time that the source is set. 
                    // This implies that this is also the original source of the event
                    _source = _originalSource = source; 
                    OnSetSource(source);
                }
                else if (_source != source)
                { 
                    // This is the actiaon taken at all other times when the
                    // source is being set to a different value from what it was 
                    _source = source; 
                    OnSetSource(source);
                } 
            }
        }

        /// 
 
        ///     Changes the Source assocatied with these RoutedEventArgs
        /// 
 
        ///  
        ///     Only used internally.  Added to support cracking generic MouseButtonDown/Up events
        ///     into MouseLeft/RightButtonDown/Up events. 
        /// 
        /// 
        ///     The new object to associate as the source of these RoutedEventArgs
        ///  
        internal void OverrideSource( object source )
        { 
            _source = source; 
        }
 
        /// 

        ///     Returns OriginalSource object that raised the RoutedEvent
        /// 
        ///  
        ///     Always returns the OriginalSource object that raised the
        ///     RoutedEvent unlike  
        ///     that may vary under specific scenarios  
        ///     This property acquires its value once before the event
        ///     handlers are invoked and never changes then on 
        /// 
        public object OriginalSource
        {
            get {return _originalSource;} 
        }
 
        /// 
 
        ///     Invoked when the source of the event is set
        /// 
 
        /// 
        ///     Changing the source of an event can often
        ///     require updating the data within the event.
        ///     For this reason, the OnSource=  method is 
        ///     protected virtual and is meant to be
        ///     overridden by sub-classes of 
        ///       
        ///     Also see 
        ///  
        /// 
        ///     The new value that the SourceProperty is being set to
        /// 
        protected virtual void OnSetSource(object source) 
        {
        } 
 
        /// 

        ///     Invokes the generic handler with the 
        ///     appropriate arguments
        /// 
        /// 
        ///     Is meant to be overridden by sub-classes of 
        ///      to provide
        ///     more efficient invocation of their delegate 
        ///  
        /// 
        ///     Generic Handler to be invoked 
        /// 
        /// 
        ///     Target on whom the Handler will be invoked
        ///  
        protected virtual void InvokeEventHandler(Delegate genericHandler, object genericTarget)
        { 
            if (genericHandler == null) 
            {
                throw new ArgumentNullException("genericHandler"); 
            }

            if (genericTarget == null)
            { 
                throw new ArgumentNullException("genericTarget");
            } 
 
            if (_routedEvent == null)
            { 
                throw new InvalidOperationException(SR.Get(SRID.RoutedEventArgsMustHaveRoutedEvent));
            }

            InvokingHandler = true; 
            try
            { 
                if (genericHandler is RoutedEventHandler) 
                {
                    ((RoutedEventHandler)genericHandler)(genericTarget, this); 
                }
                else
                {
                    // Restricted Action - reflection permission required 
                    genericHandler.DynamicInvoke(new object[] {genericTarget, this});
                } 
            } 
            finally
            { 
                InvokingHandler = false;
            }

        } 

        #endregion External API 
 
        #region Operations
 
        // Calls the InvokeEventHandler protected
        // virtual method
        //
        // This method is needed because 
        // delegates are invoked from
        // RoutedEventHandler which is not a 
        // sub-class of RoutedEventArgs 
        // and hence cannot invoke protected
        // method RoutedEventArgs.FireEventHandler 
        internal void InvokeHandler(Delegate handler, object target)
        {
            InvokingHandler = true;
 
            try
            { 
                InvokeEventHandler(handler, target); 
            }
            finally 
            {
                InvokingHandler = false;
            }
        } 

        /// 
        ///     Critical - access critical information, if this is a user initiated command 
        ///     TreatAsSafe - checking user initiated bit considered safe.
        /// 
        internal bool UserInitiated
        {
            [SecurityCritical, SecurityTreatAsSafe ]
            [FriendAccessAllowed] // Also used by Framework. 
            get
            { 
                if (_flags [UserInitiatedIndex]) 
                {
                    return SecurityHelper.CallerHasUserInitiatedRoutedEventPermission(); 
                }
                return false;
            }
        } 

        ///  
        ///     Critical - access critical information, if this is a user initiated command 
        /// 
        [SecurityCritical] 
        internal void MarkAsUserInitiated()
        {
            _flags [ UserInitiatedIndex ] = true;
        } 

        ///  
        ///     Critical - access critical information, if this is a user initiated command 
        ///     TreatAsSafe - clearing user initiated bit considered safe.
        ///  
        [SecurityCritical, SecurityTreatAsSafe ]
        internal void ClearUserInitiated()
        {
            _flags [ UserInitiatedIndex ] = false ; 
        }
 
        /// 
        /// Critical - _flags is critical due to UserInitiated value.
        /// TreatAsSafe - in this function we're not setting UserInitiated - we're setting InvokingHandler. 
        ///
        private bool InvokingHandler
        {
            [SecurityCritical, SecurityTreatAsSafe ] 
            get
            { 
                return _flags[InvokingHandlerIndex]; 
            }
            [SecurityCritical, SecurityTreatAsSafe ] 
            set
            {
                _flags[InvokingHandlerIndex] = value;
            } 
        }
        #endregion Operations 
 

 
        #region Data

        private RoutedEvent _routedEvent;
        private object _source; 
        private object _originalSource;
 
        /// 
        /// Critical - the UserInitiated flag value is critical.
        /// 
        [SecurityCritical]
        private BitVector32          _flags;

        private const int HandledIndex                          = 1; 
        private const int UserInitiatedIndex                    = 2;
        private const int InvokingHandlerIndex                  = 4; 
 

        #endregion Data 
    }

    /// 

    ///     RoutedEventHandler Definition 
    /// 
    ///  
    public delegate void RoutedEventHandler(object sender, RoutedEventArgs e); 
}
 

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

                        

                        

                        
                        

Link Menu

This book is available now!
Buy at Amazon US or
Buy at Amazon UK

• ScrollItemProviderWrapper.cs
• Number.cs
• CookieHandler.cs
• ForeignKeyConstraint.cs
• DataSourceHelper.cs
• Icon.cs
• DataGridTablesFactory.cs
• WebPartCatalogAddVerb.cs
• ConcurrencyMode.cs
• WindowsToolbarItemAsMenuItem.cs
• StringConcat.cs
• DynamicEndpointElement.cs
• SizeAnimationBase.cs
• webeventbuffer.cs
• UnsafeNativeMethods.cs
• WsrmTraceRecord.cs
• WindowsGraphics2.cs
• RenderContext.cs
• SystemNetHelpers.cs
• TextSelectionHighlightLayer.cs
• controlskin.cs
• NetworkInterface.cs
• BitmapFrame.cs
• SiblingIterators.cs
• PinnedBufferMemoryStream.cs
• TextTreeUndo.cs
• DataGridViewLayoutData.cs
• DecoderReplacementFallback.cs
• VisualBrush.cs
• AbsoluteQuery.cs
• ResolvedKeyFrameEntry.cs
• PasswordRecovery.cs
• LateBoundBitmapDecoder.cs
• BinaryFormatterSinks.cs
• FrameworkElement.cs
• EarlyBoundInfo.cs
• dsa.cs
• InternalsVisibleToAttribute.cs
• LinqExpressionNormalizer.cs
• TouchDevice.cs
• SerializationException.cs
• DataErrorValidationRule.cs
• InvalidComObjectException.cs
• TreeNodeCollection.cs
• Span.cs
• HttpBrowserCapabilitiesWrapper.cs
• WebPartManager.cs
• UniqueConstraint.cs
• Graphics.cs
• MenuCommandService.cs
• StoryFragments.cs
• BaseTransportHeaders.cs
• InputLanguage.cs
• DescendantQuery.cs
• SByte.cs
• XmlSerializer.cs
• UntrustedRecipientException.cs
• ColumnResult.cs
• PathTooLongException.cs
• Misc.cs
• EntityContainerEmitter.cs
• MimeTextImporter.cs
• _DisconnectOverlappedAsyncResult.cs
• BookmarkScopeManager.cs
• SecurityContextTokenCache.cs
• DataGridViewRowCollection.cs
• TextParentUndoUnit.cs
• _AutoWebProxyScriptEngine.cs
• SqlCharStream.cs
• EditingMode.cs
• ParallelTimeline.cs
• KeyInterop.cs
• CheckBoxBaseAdapter.cs
• MobileUserControl.cs
• XsdBuilder.cs
• RenderData.cs
• StdRegProviderWrapper.cs
• Point3DConverter.cs
• BaseParser.cs
• IsolatedStorageSecurityState.cs
• TextContainerChangedEventArgs.cs
• SqlHelper.cs
• BoundColumn.cs
• SystemInformation.cs
• ChooseAction.cs
• Timeline.cs
• ErrorHandler.cs
• StretchValidation.cs
• PasswordBox.cs
• CookieParameter.cs
• NamespaceEmitter.cs
• ResourcePart.cs
• Label.cs
• InteropTrackingRecord.cs
• CodeDomConfigurationHandler.cs
• UnhandledExceptionEventArgs.cs
• SQLMoneyStorage.cs
• BamlRecords.cs
• DataGridViewCellContextMenuStripNeededEventArgs.cs
• RowVisual.cs