Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / wpf / src / Core / CSharp / System / Windows / ContentElement.cs / 1305600 / ContentElement.cs
using MS.Internal;
using MS.Internal.KnownBoxes;
using MS.Internal.PresentationCore;
using MS.Utility;
using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Security;
using System.Security.Permissions;
using System.Windows.Automation;
using System.Windows.Automation.Peers;
using System.Windows.Input;
using System.Windows.Markup;
using System.Windows.Media.Animation;
using System.Windows.Threading;
using SR=MS.Internal.PresentationCore.SR;
using SRID=MS.Internal.PresentationCore.SRID;
namespace System.Windows
{
///
/// ContentElement Class is a DependencyObject with IFE - input, focus, and events
///
///
/// Static Constructor for ContentElement
///
///
/// Critical: This hooks up a bunch of thunks which are all critical since they
/// can be used to spoof input
/// TreatAsSafe: Since it does not expose the thunks
///
[SecurityCritical,SecurityTreatAsSafe]
static ContentElement()
{
UIElement.RegisterEvents(typeof(ContentElement));
RegisterProperties();
UIElement.IsFocusedPropertyKey.OverrideMetadata(
typeof(ContentElement),
new PropertyMetadata(
BooleanBoxes.FalseBox, // default value
new PropertyChangedCallback(IsFocused_Changed)));
}
#endregion Construction
#region DependencyObject
#endregion
///
/// Helper, gives the UIParent under control of which
/// the OnMeasure or OnArrange are currently called.
/// This may be implemented as a tree walk up until
/// LayoutElement is found.
///
internal DependencyObject GetUIParent()
{
return GetUIParent(false);
}
internal DependencyObject GetUIParent(bool continuePastVisualTree)
{
DependencyObject e = null;
// Try to find a UIElement parent in the visual ancestry.
e = InputElement.GetContainingInputElement(_parent) as DependencyObject;
// If there was no InputElement parent in the visual ancestry,
// check along the logical branch.
if(e == null && continuePastVisualTree)
{
DependencyObject doParent = GetUIParentCore();
e = InputElement.GetContainingInputElement(doParent) as DependencyObject;
}
return e;
}
///
/// Called to get the UI parent of this element when there is
/// no visual parent.
///
///
/// Returns a non-null value when some framework implementation
/// of this method has a non-visual parent connection,
///
protected virtual internal DependencyObject GetUIParentCore()
{
return null;
}
internal DependencyObject Parent
{
get
{
return _parent;
}
}
///
/// OnContentParentChanged is called when the parent of the content element is changed.
///
/// Old parent or null if the content element did not have a parent before.
[FriendAccessAllowed] // Built into Core, also used by Framework.
internal virtual void OnContentParentChanged(DependencyObject oldParent)
{
SynchronizeReverseInheritPropertyFlags(oldParent, true);
}
#region Automation
///
/// Called by the Automation infrastructure when AutomationPeer
/// is requested for this element. The element can return null or
/// the instance of AutomationPeer-derived clas, if it supports UI Automation
///
protected virtual AutomationPeer OnCreateAutomationPeer() { return null; }
///
/// Called by the Automation infrastructure or Control author
/// to make sure the AutomationPeer is created. The element may
/// create AP or return null, depending on OnCreateAutomationPeer override.
///
internal AutomationPeer CreateAutomationPeer()
{
VerifyAccess(); //this will ensure the AP is created in the right context
AutomationPeer ap = null;
if (HasAutomationPeer)
{
ap = AutomationPeerField.GetValue(this);
}
else
{
ap = OnCreateAutomationPeer();
if (ap != null)
{
AutomationPeerField.SetValue(this, ap);
HasAutomationPeer = true;
}
}
return ap;
}
///
/// Returns AutomationPeer if one exists.
/// The AutomationPeer may not exist if not yet created by Automation infrastructure
/// or if this element is not supposed to have one.
///
internal AutomationPeer GetAutomationPeer()
{
VerifyAccess();
if (HasAutomationPeer)
return AutomationPeerField.GetValue(this);
return null;
}
// If this element is currently listening to synchronized input, add a pre-opportunity handler to keep track of event routed through this element.
internal void AddSynchronizedInputPreOpportunityHandler(EventRoute route, RoutedEventArgs args)
{
if (InputManager.IsSynchronizedInput)
{
if (SynchronizedInputHelper.IsListening(this, args))
{
RoutedEventHandler eventHandler = new RoutedEventHandler(this.SynchronizedInputPreOpportunityHandler);
SynchronizedInputHelper.AddHandlerToRoute(this, route, eventHandler, false);
}
}
}
// If this element is currently listening to synchronized input, add a handler to post process the synchronized input otherwise
// add a synchronized input pre-opportunity handler from parent if parent is listening.
internal void AddSynchronizedInputPostOpportunityHandler(EventRoute route, RoutedEventArgs args)
{
if (InputManager.IsSynchronizedInput)
{
if (SynchronizedInputHelper.IsListening(this, args))
{
RoutedEventHandler eventHandler = new RoutedEventHandler(this.SynchronizedInputPostOpportunityHandler);
SynchronizedInputHelper.AddHandlerToRoute(this, route, eventHandler, true);
}
else
{
// Add a preview handler from the parent.
SynchronizedInputHelper.AddParentPreOpportunityHandler(this, route, args);
}
}
}
// This event handler to be called before all the class & instance handlers for this element.
internal void SynchronizedInputPreOpportunityHandler(object sender, RoutedEventArgs args)
{
if (!args.Handled)
{
SynchronizedInputHelper.PreOpportunityHandler(sender, args);
}
}
// This event handler to be called after class & instance handlers for this element.
internal void SynchronizedInputPostOpportunityHandler(object sender, RoutedEventArgs args)
{
if (args.Handled && (InputManager.SynchronizedInputState == SynchronizedInputStates.HadOpportunity))
{
SynchronizedInputHelper.PostOpportunityHandler(sender, args);
}
}
// Called by automation peer, when called this element will be the listening element for synchronized input.
internal bool StartListeningSynchronizedInput(SynchronizedInputType inputType)
{
if (InputManager.IsSynchronizedInput)
{
return false;
}
else
{
InputManager.StartListeningSynchronizedInput(this, inputType);
return true;
}
}
// When called, input processing will return to normal mode.
internal void CancelSynchronizedInput()
{
InputManager.CancelSynchronizedInput();
}
#endregion Automation
#region Input
///
/// A property indicating if the mouse is over this element or not.
///
public bool IsMouseDirectlyOver
{
get
{
// We do not return the cached value of reverse-inherited seed properties.
//
// The cached value is only used internally to detect a "change".
//
// More Info:
// The act of invalidating the seed property of a reverse-inherited property
// on the first side of the path causes the invalidation of the
// reverse-inherited properties on both sides. The input system has not yet
// invalidated the seed property on the second side, so its cached value can
// be incorrect.
//
return IsMouseDirectlyOver_ComputeValue();
}
}
private bool IsMouseDirectlyOver_ComputeValue()
{
return (Mouse.DirectlyOver == this);
}
///
/// Asynchronously re-evaluate the reverse-inherited properties.
///
[FriendAccessAllowed]
internal void SynchronizeReverseInheritPropertyFlags(DependencyObject oldParent, bool isCoreParent)
{
if(IsKeyboardFocusWithin)
{
Keyboard.PrimaryDevice.ReevaluateFocusAsync(this, oldParent, isCoreParent);
}
// Reevelauate the stylus properties first to guarentee that our property change
// notifications fire before mouse properties.
if(IsStylusOver)
{
StylusLogic.CurrentStylusLogicReevaluateStylusOver(this, oldParent, isCoreParent);
}
if(IsStylusCaptureWithin)
{
StylusLogic.CurrentStylusLogicReevaluateCapture(this, oldParent, isCoreParent);
}
if(IsMouseOver)
{
Mouse.PrimaryDevice.ReevaluateMouseOver(this, oldParent, isCoreParent);
}
if(IsMouseCaptureWithin)
{
Mouse.PrimaryDevice.ReevaluateCapture(this, oldParent, isCoreParent);
}
if (AreAnyTouchesOver)
{
TouchDevice.ReevaluateDirectlyOver(this, oldParent, isCoreParent);
}
if (AreAnyTouchesCapturedWithin)
{
TouchDevice.ReevaluateCapturedWithin(this, oldParent, isCoreParent);
}
}
///
/// BlockReverseInheritance method when overriden stops reverseInheritProperties from updating their parent level properties.
///
internal virtual bool BlockReverseInheritance()
{
return false;
}
///
/// A property indicating if the mouse is over this element or not.
///
public bool IsMouseOver
{
get
{
return ReadFlag(CoreFlags.IsMouseOverCache);
}
}
///
/// A property indicating if the stylus is over this element or not.
///
public bool IsStylusOver
{
get
{
return ReadFlag(CoreFlags.IsStylusOverCache);
}
}
///
/// Indicates if Keyboard Focus is anywhere
/// within in the subtree starting at the
/// current instance
///
public bool IsKeyboardFocusWithin
{
get
{
return ReadFlag(CoreFlags.IsKeyboardFocusWithinCache);
}
}
///
/// A property indicating if the mouse is captured to this element or not.
///
public bool IsMouseCaptured
{
get { return (bool) GetValue(IsMouseCapturedProperty); }
}
///
/// Captures the mouse to this element.
///
public bool CaptureMouse()
{
return Mouse.Capture(this);
}
///
/// Releases the mouse capture.
///
public void ReleaseMouseCapture()
{
Mouse.Capture(null);
}
///
/// Indicates if mouse capture is anywhere within in the subtree
/// starting at the current instance
///
public bool IsMouseCaptureWithin
{
get
{
return ReadFlag(CoreFlags.IsMouseCaptureWithinCache);
}
}
///
/// A property indicating if the stylus is over this element or not.
///
public bool IsStylusDirectlyOver
{
get
{
// We do not return the cached value of reverse-inherited seed properties.
//
// The cached value is only used internally to detect a "change".
//
// More Info:
// The act of invalidating the seed property of a reverse-inherited property
// on the first side of the path causes the invalidation of the
// reverse-inherited properties on both sides. The input system has not yet
// invalidated the seed property on the second side, so its cached value can
// be incorrect.
//
return IsStylusDirectlyOver_ComputeValue();
}
}
private bool IsStylusDirectlyOver_ComputeValue()
{
return (Stylus.DirectlyOver == this);
}
///
/// A property indicating if the stylus is captured to this element or not.
///
public bool IsStylusCaptured
{
get { return (bool) GetValue(IsStylusCapturedProperty); }
}
///
/// Captures the stylus to this element.
///
public bool CaptureStylus()
{
return Stylus.Capture(this);
}
///
/// Releases the stylus capture.
///
public void ReleaseStylusCapture()
{
Stylus.Capture(null);
}
///
/// Indicates if stylus capture is anywhere within in the subtree
/// starting at the current instance
///
public bool IsStylusCaptureWithin
{
get
{
return ReadFlag(CoreFlags.IsStylusCaptureWithinCache);
}
}
///
/// A property indicating if the keyboard is focused on this
/// element or not.
///
public bool IsKeyboardFocused
{
get
{
// We do not return the cached value of reverse-inherited seed properties.
//
// The cached value is only used internally to detect a "change".
//
// More Info:
// The act of invalidating the seed property of a reverse-inherited property
// on the first side of the path causes the invalidation of the
// reverse-inherited properties on both sides. The input system has not yet
// invalidated the seed property on the second side, so its cached value can
// be incorrect.
//
return IsKeyboardFocused_ComputeValue();
}
}
private bool IsKeyboardFocused_ComputeValue()
{
return (Keyboard.FocusedElement == this);
}
///
/// Focuses the keyboard on this element.
///
public bool Focus()
{
return Keyboard.Focus(this) == this;
}
///
/// Request to move the focus from this element to another element
///
/// Determine how to move the focus
/// Returns true if focus is moved successfully. Returns false if there is no next element
public virtual bool MoveFocus(TraversalRequest request)
{
return false;
}
///
/// Request to predict the element that should receive focus relative to this element for a
/// given direction, without actually moving focus to it.
///
/// The direction for which focus should be predicted
///
/// Returns the next element that focus should move to for a given FocusNavigationDirection.
/// Returns null if focus cannot be moved relative to this element.
///
public virtual DependencyObject PredictFocus(FocusNavigationDirection direction)
{
return null;
}
///
/// GotFocus event
///
public static readonly RoutedEvent GotFocusEvent = FocusManager.GotFocusEvent.AddOwner(typeof(ContentElement));
///
/// An event announcing that IsFocused changed to true.
///
public event RoutedEventHandler GotFocus
{
add { AddHandler(GotFocusEvent, value); }
remove { RemoveHandler(GotFocusEvent, value); }
}
///
/// LostFocus event
///
public static readonly RoutedEvent LostFocusEvent = FocusManager.LostFocusEvent.AddOwner(typeof(ContentElement));
///
/// An event announcing that IsFocused changed to false.
///
public event RoutedEventHandler LostFocus
{
add { AddHandler(LostFocusEvent, value); }
remove { RemoveHandler(LostFocusEvent, value); }
}
///
/// The DependencyProperty for IsFocused.
/// Flags: None
/// Read-Only: true
///
public static readonly DependencyProperty IsFocusedProperty =
UIElement.IsFocusedProperty.AddOwner(
typeof(ContentElement));
private static void IsFocused_Changed(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
ContentElement ce = ((ContentElement) d);
if ((bool) e.NewValue)
{
ce.OnGotFocus(new RoutedEventArgs(GotFocusEvent, ce));
}
else
{
ce.OnLostFocus(new RoutedEventArgs(LostFocusEvent, ce));
}
}
///
/// This method is invoked when the IsFocused property changes to true
///
/// RoutedEventArgs
protected virtual void OnGotFocus(RoutedEventArgs e)
{
RaiseEvent(e);
}
///
/// This method is invoked when the IsFocused property changes to false
///
/// RoutedEventArgs
protected virtual void OnLostFocus(RoutedEventArgs e)
{
RaiseEvent(e);
}
///
/// Gettor for IsFocused Property
///
public bool IsFocused
{
get { return (bool) GetValue(IsFocusedProperty); }
}
///
/// The DependencyProperty for the IsEnabled property.
///
public static readonly DependencyProperty IsEnabledProperty =
UIElement.IsEnabledProperty.AddOwner(
typeof(ContentElement),
new UIPropertyMetadata(
BooleanBoxes.TrueBox, // default value
new PropertyChangedCallback(OnIsEnabledChanged),
new CoerceValueCallback(CoerceIsEnabled)));
///
/// A property indicating if this element is enabled or not.
///
public bool IsEnabled
{
get { return (bool) GetValue(IsEnabledProperty); }
set { SetValue(IsEnabledProperty, BooleanBoxes.Box(value)); }
}
///
/// IsEnabledChanged event
///
public event DependencyPropertyChangedEventHandler IsEnabledChanged
{
add { EventHandlersStoreAdd(UIElement.IsEnabledChangedKey, value); }
remove { EventHandlersStoreRemove(UIElement.IsEnabledChangedKey, value); }
}
///
/// Fetches the value that IsEnabled should be coerced to.
///
///
/// This method is virtual is so that controls derived from UIElement
/// can combine additional requirements into the coersion logic.
///
/// It is important for anyone overriding this property to also
/// call CoerceValue when any of their dependencies change.
///
protected virtual bool IsEnabledCore
{
get
{
// As of 1/25/2006, the following controls override this method:
// Hyperlink.IsEnabledCore: CanExecute
return true;
}
}
private static object CoerceIsEnabled(DependencyObject d, object value)
{
ContentElement ce = (ContentElement) d;
// We must be false if our parent is false, but we can be
// either true or false if our parent is true.
//
// Another way of saying this is that we can only be true
// if our parent is true, but we can always be false.
if((bool) value)
{
// Use the "logical" parent. This is different that UIElement, which
// uses the visual parent. But the "content parent" is not a complete
// tree description (for instance, we don't track "content children"),
// so the best we can do is use the logical tree for ContentElements.
//
// Note: we assume the "logical" parent of a ContentElement is either
// a UIElement or ContentElement. We explicitly assume that there
// is never a raw Visual as the parent.
DependencyObject parent = ce.GetUIParentCore();
if(parent == null || (bool)parent.GetValue(IsEnabledProperty))
{
return BooleanBoxes.Box(ce.IsEnabledCore);
}
else
{
return BooleanBoxes.FalseBox;
}
}
else
{
return BooleanBoxes.FalseBox;
}
}
private static void OnIsEnabledChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
ContentElement ce = (ContentElement)d;
// Raise the public changed event.
ce.RaiseDependencyPropertyChanged(UIElement.IsEnabledChangedKey, e);
// Invalidate the children so that they will inherit the new value.
ce.InvalidateForceInheritPropertyOnChildren(e.Property);
// The input manager needs to re-hittest because something changed
// that is involved in the hit-testing we do, so a different result
// could be returned.
InputManager.SafeCurrentNotifyHitTestInvalidated();
}
//**********************************************************************
#region Focusable Property
//*********************************************************************
///
/// The DependencyProperty for the Focusable property.
///
[CommonDependencyProperty]
public static readonly DependencyProperty FocusableProperty =
UIElement.FocusableProperty.AddOwner(
typeof(ContentElement),
new UIPropertyMetadata(
BooleanBoxes.FalseBox, // default value
new PropertyChangedCallback(OnFocusableChanged)));
///
/// Gettor and Settor for Focusable Property
///
public bool Focusable
{
get { return (bool) GetValue(FocusableProperty); }
set { SetValue(FocusableProperty, BooleanBoxes.Box(value)); }
}
///
/// FocusableChanged event
///
public event DependencyPropertyChangedEventHandler FocusableChanged
{
add {EventHandlersStoreAdd(UIElement.FocusableChangedKey, value);}
remove {EventHandlersStoreRemove(UIElement.FocusableChangedKey, value);}
}
private static void OnFocusableChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
ContentElement ce = (ContentElement) d;
// Raise the public changed event.
ce.RaiseDependencyPropertyChanged(UIElement.FocusableChangedKey, e);
}
//*********************************************************************
#endregion Focusable Property
//*********************************************************************
///
/// A property indicating if the inptu method is enabled.
///
public bool IsInputMethodEnabled
{
get { return (bool) GetValue(InputMethod.IsInputMethodEnabledProperty); }
}
#endregion Input
#region Operations
private void RaiseMouseButtonEvent(EventPrivateKey key, MouseButtonEventArgs e)
{
EventHandlersStore store = EventHandlersStore;
if (store != null)
{
Delegate handler = store.Get(key);
if (handler != null)
{
((MouseButtonEventHandler)handler)(this, e);
}
}
}
// Helper method to retrieve and fire Clr Event handlers for DependencyPropertyChanged event
private void RaiseDependencyPropertyChanged(EventPrivateKey key, DependencyPropertyChangedEventArgs args)
{
EventHandlersStore store = EventHandlersStore;
if (store != null)
{
Delegate handler = store.Get(key);
if (handler != null)
{
((DependencyPropertyChangedEventHandler)handler)(this, args);
}
}
}
#endregion Operations
#region AllowDrop
///
/// The DependencyProperty for the AllowDrop property.
///
public static readonly DependencyProperty AllowDropProperty =
UIElement.AllowDropProperty.AddOwner(
typeof(ContentElement),
new PropertyMetadata(BooleanBoxes.FalseBox));
///
/// A dependency property that allows the drop object as DragDrop target.
///
public bool AllowDrop
{
get { return (bool) GetValue(AllowDropProperty); }
set { SetValue(AllowDropProperty, BooleanBoxes.Box(value)); }
}
#endregion AllowDrop
#region ForceInherit property support
// This has to be virtual, since there is no concept of "core" content children,
// so we have no choice by to rely on FrameworkContentElement to use logical
// children instead.
internal virtual void InvalidateForceInheritPropertyOnChildren(DependencyProperty property)
{
}
#endregion
#region Touch
///
/// A property indicating if any touch devices are over this element or not.
///
public bool AreAnyTouchesOver
{
get { return ReadFlag(CoreFlags.TouchesOverCache); }
}
///
/// A property indicating if any touch devices are directly over this element or not.
///
public bool AreAnyTouchesDirectlyOver
{
get { return (bool)GetValue(AreAnyTouchesDirectlyOverProperty); }
}
///
/// A property indicating if any touch devices are captured to elements in this subtree.
///
public bool AreAnyTouchesCapturedWithin
{
get { return ReadFlag(CoreFlags.TouchesCapturedWithinCache); }
}
///
/// A property indicating if any touch devices are captured to this element.
///
public bool AreAnyTouchesCaptured
{
get { return (bool)GetValue(AreAnyTouchesCapturedProperty); }
}
///
/// Captures the specified device to this element.
///
/// The touch device to capture.
/// True if capture was taken.
public bool CaptureTouch(TouchDevice touchDevice)
{
if (touchDevice == null)
{
throw new ArgumentNullException("touchDevice");
}
return touchDevice.Capture(this);
}
///
/// Releases capture from the specified touch device.
///
/// The device that is captured to this element.
/// true if capture was released, false otherwise.
public bool ReleaseTouchCapture(TouchDevice touchDevice)
{
if (touchDevice == null)
{
throw new ArgumentNullException("touchDevice");
}
if (touchDevice.Captured == this)
{
touchDevice.Capture(null);
return true;
}
else
{
return false;
}
}
///
/// Releases capture on any touch devices captured to this element.
///
public void ReleaseAllTouchCaptures()
{
TouchDevice.ReleaseAllCaptures(this);
}
///
/// The touch devices captured to this element.
///
public IEnumerable TouchesCaptured
{
get
{
return TouchDevice.GetCapturedTouches(this, /* includeWithin = */ false);
}
}
///
/// The touch devices captured to this element and any elements in the subtree.
///
public IEnumerable TouchesCapturedWithin
{
get
{
return TouchDevice.GetCapturedTouches(this, /* includeWithin = */ true);
}
}
///
/// The touch devices which are over this element and any elements in the subtree.
/// This is particularly relevant to elements which dont take capture (like Label).
///
public IEnumerable TouchesOver
{
get
{
return TouchDevice.GetTouchesOver(this, /* includeWithin = */ true);
}
}
///
/// The touch devices which are directly over this element.
/// This is particularly relevant to elements which dont take capture (like Label).
///
public IEnumerable TouchesDirectlyOver
{
get
{
return TouchDevice.GetTouchesOver(this, /* includeWithin = */ false);
}
}
#endregion
internal bool HasAutomationPeer
{
get { return ReadFlag(CoreFlags.HasAutomationPeer); }
set { WriteFlag(CoreFlags.HasAutomationPeer, value); }
}
#region Data
internal DependencyObject _parent;
///// ATTACHED STORAGE /////
internal static readonly UncommonField EventHandlersStoreField = UIElement.EventHandlersStoreField;
internal static readonly UncommonField InputBindingCollectionField = UIElement.InputBindingCollectionField;
internal static readonly UncommonField CommandBindingCollectionField = UIElement.CommandBindingCollectionField;
private static readonly UncommonField AutomationPeerField = new UncommonField();
// Caches the ContentElement's DependencyObjectType
private static DependencyObjectType ContentElementType = DependencyObjectType.FromSystemTypeInternal(typeof(ContentElement));
#endregion Data
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
using MS.Internal;
using MS.Internal.KnownBoxes;
using MS.Internal.PresentationCore;
using MS.Utility;
using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Security;
using System.Security.Permissions;
using System.Windows.Automation;
using System.Windows.Automation.Peers;
using System.Windows.Input;
using System.Windows.Markup;
using System.Windows.Media.Animation;
using System.Windows.Threading;
using SR=MS.Internal.PresentationCore.SR;
using SRID=MS.Internal.PresentationCore.SRID;
namespace System.Windows
{
///
/// ContentElement Class is a DependencyObject with IFE - input, focus, and events
///
///
/// Static Constructor for ContentElement
///
///
/// Critical: This hooks up a bunch of thunks which are all critical since they
/// can be used to spoof input
/// TreatAsSafe: Since it does not expose the thunks
///
[SecurityCritical,SecurityTreatAsSafe]
static ContentElement()
{
UIElement.RegisterEvents(typeof(ContentElement));
RegisterProperties();
UIElement.IsFocusedPropertyKey.OverrideMetadata(
typeof(ContentElement),
new PropertyMetadata(
BooleanBoxes.FalseBox, // default value
new PropertyChangedCallback(IsFocused_Changed)));
}
#endregion Construction
#region DependencyObject
#endregion
///
/// Helper, gives the UIParent under control of which
/// the OnMeasure or OnArrange are currently called.
/// This may be implemented as a tree walk up until
/// LayoutElement is found.
///
internal DependencyObject GetUIParent()
{
return GetUIParent(false);
}
internal DependencyObject GetUIParent(bool continuePastVisualTree)
{
DependencyObject e = null;
// Try to find a UIElement parent in the visual ancestry.
e = InputElement.GetContainingInputElement(_parent) as DependencyObject;
// If there was no InputElement parent in the visual ancestry,
// check along the logical branch.
if(e == null && continuePastVisualTree)
{
DependencyObject doParent = GetUIParentCore();
e = InputElement.GetContainingInputElement(doParent) as DependencyObject;
}
return e;
}
///
/// Called to get the UI parent of this element when there is
/// no visual parent.
///
///
/// Returns a non-null value when some framework implementation
/// of this method has a non-visual parent connection,
///
protected virtual internal DependencyObject GetUIParentCore()
{
return null;
}
internal DependencyObject Parent
{
get
{
return _parent;
}
}
///
/// OnContentParentChanged is called when the parent of the content element is changed.
///
/// Old parent or null if the content element did not have a parent before.
[FriendAccessAllowed] // Built into Core, also used by Framework.
internal virtual void OnContentParentChanged(DependencyObject oldParent)
{
SynchronizeReverseInheritPropertyFlags(oldParent, true);
}
#region Automation
///
/// Called by the Automation infrastructure when AutomationPeer
/// is requested for this element. The element can return null or
/// the instance of AutomationPeer-derived clas, if it supports UI Automation
///
protected virtual AutomationPeer OnCreateAutomationPeer() { return null; }
///
/// Called by the Automation infrastructure or Control author
/// to make sure the AutomationPeer is created. The element may
/// create AP or return null, depending on OnCreateAutomationPeer override.
///
internal AutomationPeer CreateAutomationPeer()
{
VerifyAccess(); //this will ensure the AP is created in the right context
AutomationPeer ap = null;
if (HasAutomationPeer)
{
ap = AutomationPeerField.GetValue(this);
}
else
{
ap = OnCreateAutomationPeer();
if (ap != null)
{
AutomationPeerField.SetValue(this, ap);
HasAutomationPeer = true;
}
}
return ap;
}
///
/// Returns AutomationPeer if one exists.
/// The AutomationPeer may not exist if not yet created by Automation infrastructure
/// or if this element is not supposed to have one.
///
internal AutomationPeer GetAutomationPeer()
{
VerifyAccess();
if (HasAutomationPeer)
return AutomationPeerField.GetValue(this);
return null;
}
// If this element is currently listening to synchronized input, add a pre-opportunity handler to keep track of event routed through this element.
internal void AddSynchronizedInputPreOpportunityHandler(EventRoute route, RoutedEventArgs args)
{
if (InputManager.IsSynchronizedInput)
{
if (SynchronizedInputHelper.IsListening(this, args))
{
RoutedEventHandler eventHandler = new RoutedEventHandler(this.SynchronizedInputPreOpportunityHandler);
SynchronizedInputHelper.AddHandlerToRoute(this, route, eventHandler, false);
}
}
}
// If this element is currently listening to synchronized input, add a handler to post process the synchronized input otherwise
// add a synchronized input pre-opportunity handler from parent if parent is listening.
internal void AddSynchronizedInputPostOpportunityHandler(EventRoute route, RoutedEventArgs args)
{
if (InputManager.IsSynchronizedInput)
{
if (SynchronizedInputHelper.IsListening(this, args))
{
RoutedEventHandler eventHandler = new RoutedEventHandler(this.SynchronizedInputPostOpportunityHandler);
SynchronizedInputHelper.AddHandlerToRoute(this, route, eventHandler, true);
}
else
{
// Add a preview handler from the parent.
SynchronizedInputHelper.AddParentPreOpportunityHandler(this, route, args);
}
}
}
// This event handler to be called before all the class & instance handlers for this element.
internal void SynchronizedInputPreOpportunityHandler(object sender, RoutedEventArgs args)
{
if (!args.Handled)
{
SynchronizedInputHelper.PreOpportunityHandler(sender, args);
}
}
// This event handler to be called after class & instance handlers for this element.
internal void SynchronizedInputPostOpportunityHandler(object sender, RoutedEventArgs args)
{
if (args.Handled && (InputManager.SynchronizedInputState == SynchronizedInputStates.HadOpportunity))
{
SynchronizedInputHelper.PostOpportunityHandler(sender, args);
}
}
// Called by automation peer, when called this element will be the listening element for synchronized input.
internal bool StartListeningSynchronizedInput(SynchronizedInputType inputType)
{
if (InputManager.IsSynchronizedInput)
{
return false;
}
else
{
InputManager.StartListeningSynchronizedInput(this, inputType);
return true;
}
}
// When called, input processing will return to normal mode.
internal void CancelSynchronizedInput()
{
InputManager.CancelSynchronizedInput();
}
#endregion Automation
#region Input
///
/// A property indicating if the mouse is over this element or not.
///
public bool IsMouseDirectlyOver
{
get
{
// We do not return the cached value of reverse-inherited seed properties.
//
// The cached value is only used internally to detect a "change".
//
// More Info:
// The act of invalidating the seed property of a reverse-inherited property
// on the first side of the path causes the invalidation of the
// reverse-inherited properties on both sides. The input system has not yet
// invalidated the seed property on the second side, so its cached value can
// be incorrect.
//
return IsMouseDirectlyOver_ComputeValue();
}
}
private bool IsMouseDirectlyOver_ComputeValue()
{
return (Mouse.DirectlyOver == this);
}
///
/// Asynchronously re-evaluate the reverse-inherited properties.
///
[FriendAccessAllowed]
internal void SynchronizeReverseInheritPropertyFlags(DependencyObject oldParent, bool isCoreParent)
{
if(IsKeyboardFocusWithin)
{
Keyboard.PrimaryDevice.ReevaluateFocusAsync(this, oldParent, isCoreParent);
}
// Reevelauate the stylus properties first to guarentee that our property change
// notifications fire before mouse properties.
if(IsStylusOver)
{
StylusLogic.CurrentStylusLogicReevaluateStylusOver(this, oldParent, isCoreParent);
}
if(IsStylusCaptureWithin)
{
StylusLogic.CurrentStylusLogicReevaluateCapture(this, oldParent, isCoreParent);
}
if(IsMouseOver)
{
Mouse.PrimaryDevice.ReevaluateMouseOver(this, oldParent, isCoreParent);
}
if(IsMouseCaptureWithin)
{
Mouse.PrimaryDevice.ReevaluateCapture(this, oldParent, isCoreParent);
}
if (AreAnyTouchesOver)
{
TouchDevice.ReevaluateDirectlyOver(this, oldParent, isCoreParent);
}
if (AreAnyTouchesCapturedWithin)
{
TouchDevice.ReevaluateCapturedWithin(this, oldParent, isCoreParent);
}
}
///
/// BlockReverseInheritance method when overriden stops reverseInheritProperties from updating their parent level properties.
///
internal virtual bool BlockReverseInheritance()
{
return false;
}
///
/// A property indicating if the mouse is over this element or not.
///
public bool IsMouseOver
{
get
{
return ReadFlag(CoreFlags.IsMouseOverCache);
}
}
///
/// A property indicating if the stylus is over this element or not.
///
public bool IsStylusOver
{
get
{
return ReadFlag(CoreFlags.IsStylusOverCache);
}
}
///
/// Indicates if Keyboard Focus is anywhere
/// within in the subtree starting at the
/// current instance
///
public bool IsKeyboardFocusWithin
{
get
{
return ReadFlag(CoreFlags.IsKeyboardFocusWithinCache);
}
}
///
/// A property indicating if the mouse is captured to this element or not.
///
public bool IsMouseCaptured
{
get { return (bool) GetValue(IsMouseCapturedProperty); }
}
///
/// Captures the mouse to this element.
///
public bool CaptureMouse()
{
return Mouse.Capture(this);
}
///
/// Releases the mouse capture.
///
public void ReleaseMouseCapture()
{
Mouse.Capture(null);
}
///
/// Indicates if mouse capture is anywhere within in the subtree
/// starting at the current instance
///
public bool IsMouseCaptureWithin
{
get
{
return ReadFlag(CoreFlags.IsMouseCaptureWithinCache);
}
}
///
/// A property indicating if the stylus is over this element or not.
///
public bool IsStylusDirectlyOver
{
get
{
// We do not return the cached value of reverse-inherited seed properties.
//
// The cached value is only used internally to detect a "change".
//
// More Info:
// The act of invalidating the seed property of a reverse-inherited property
// on the first side of the path causes the invalidation of the
// reverse-inherited properties on both sides. The input system has not yet
// invalidated the seed property on the second side, so its cached value can
// be incorrect.
//
return IsStylusDirectlyOver_ComputeValue();
}
}
private bool IsStylusDirectlyOver_ComputeValue()
{
return (Stylus.DirectlyOver == this);
}
///
/// A property indicating if the stylus is captured to this element or not.
///
public bool IsStylusCaptured
{
get { return (bool) GetValue(IsStylusCapturedProperty); }
}
///
/// Captures the stylus to this element.
///
public bool CaptureStylus()
{
return Stylus.Capture(this);
}
///
/// Releases the stylus capture.
///
public void ReleaseStylusCapture()
{
Stylus.Capture(null);
}
///
/// Indicates if stylus capture is anywhere within in the subtree
/// starting at the current instance
///
public bool IsStylusCaptureWithin
{
get
{
return ReadFlag(CoreFlags.IsStylusCaptureWithinCache);
}
}
///
/// A property indicating if the keyboard is focused on this
/// element or not.
///
public bool IsKeyboardFocused
{
get
{
// We do not return the cached value of reverse-inherited seed properties.
//
// The cached value is only used internally to detect a "change".
//
// More Info:
// The act of invalidating the seed property of a reverse-inherited property
// on the first side of the path causes the invalidation of the
// reverse-inherited properties on both sides. The input system has not yet
// invalidated the seed property on the second side, so its cached value can
// be incorrect.
//
return IsKeyboardFocused_ComputeValue();
}
}
private bool IsKeyboardFocused_ComputeValue()
{
return (Keyboard.FocusedElement == this);
}
///
/// Focuses the keyboard on this element.
///
public bool Focus()
{
return Keyboard.Focus(this) == this;
}
///
/// Request to move the focus from this element to another element
///
/// Determine how to move the focus
/// Returns true if focus is moved successfully. Returns false if there is no next element
public virtual bool MoveFocus(TraversalRequest request)
{
return false;
}
///
/// Request to predict the element that should receive focus relative to this element for a
/// given direction, without actually moving focus to it.
///
/// The direction for which focus should be predicted
///
/// Returns the next element that focus should move to for a given FocusNavigationDirection.
/// Returns null if focus cannot be moved relative to this element.
///
public virtual DependencyObject PredictFocus(FocusNavigationDirection direction)
{
return null;
}
///
/// GotFocus event
///
public static readonly RoutedEvent GotFocusEvent = FocusManager.GotFocusEvent.AddOwner(typeof(ContentElement));
///
/// An event announcing that IsFocused changed to true.
///
public event RoutedEventHandler GotFocus
{
add { AddHandler(GotFocusEvent, value); }
remove { RemoveHandler(GotFocusEvent, value); }
}
///
/// LostFocus event
///
public static readonly RoutedEvent LostFocusEvent = FocusManager.LostFocusEvent.AddOwner(typeof(ContentElement));
///
/// An event announcing that IsFocused changed to false.
///
public event RoutedEventHandler LostFocus
{
add { AddHandler(LostFocusEvent, value); }
remove { RemoveHandler(LostFocusEvent, value); }
}
///
/// The DependencyProperty for IsFocused.
/// Flags: None
/// Read-Only: true
///
public static readonly DependencyProperty IsFocusedProperty =
UIElement.IsFocusedProperty.AddOwner(
typeof(ContentElement));
private static void IsFocused_Changed(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
ContentElement ce = ((ContentElement) d);
if ((bool) e.NewValue)
{
ce.OnGotFocus(new RoutedEventArgs(GotFocusEvent, ce));
}
else
{
ce.OnLostFocus(new RoutedEventArgs(LostFocusEvent, ce));
}
}
///
/// This method is invoked when the IsFocused property changes to true
///
/// RoutedEventArgs
protected virtual void OnGotFocus(RoutedEventArgs e)
{
RaiseEvent(e);
}
///
/// This method is invoked when the IsFocused property changes to false
///
/// RoutedEventArgs
protected virtual void OnLostFocus(RoutedEventArgs e)
{
RaiseEvent(e);
}
///
/// Gettor for IsFocused Property
///
public bool IsFocused
{
get { return (bool) GetValue(IsFocusedProperty); }
}
///
/// The DependencyProperty for the IsEnabled property.
///
public static readonly DependencyProperty IsEnabledProperty =
UIElement.IsEnabledProperty.AddOwner(
typeof(ContentElement),
new UIPropertyMetadata(
BooleanBoxes.TrueBox, // default value
new PropertyChangedCallback(OnIsEnabledChanged),
new CoerceValueCallback(CoerceIsEnabled)));
///
/// A property indicating if this element is enabled or not.
///
public bool IsEnabled
{
get { return (bool) GetValue(IsEnabledProperty); }
set { SetValue(IsEnabledProperty, BooleanBoxes.Box(value)); }
}
///
/// IsEnabledChanged event
///
public event DependencyPropertyChangedEventHandler IsEnabledChanged
{
add { EventHandlersStoreAdd(UIElement.IsEnabledChangedKey, value); }
remove { EventHandlersStoreRemove(UIElement.IsEnabledChangedKey, value); }
}
///
/// Fetches the value that IsEnabled should be coerced to.
///
///
/// This method is virtual is so that controls derived from UIElement
/// can combine additional requirements into the coersion logic.
///
/// It is important for anyone overriding this property to also
/// call CoerceValue when any of their dependencies change.
///
protected virtual bool IsEnabledCore
{
get
{
// As of 1/25/2006, the following controls override this method:
// Hyperlink.IsEnabledCore: CanExecute
return true;
}
}
private static object CoerceIsEnabled(DependencyObject d, object value)
{
ContentElement ce = (ContentElement) d;
// We must be false if our parent is false, but we can be
// either true or false if our parent is true.
//
// Another way of saying this is that we can only be true
// if our parent is true, but we can always be false.
if((bool) value)
{
// Use the "logical" parent. This is different that UIElement, which
// uses the visual parent. But the "content parent" is not a complete
// tree description (for instance, we don't track "content children"),
// so the best we can do is use the logical tree for ContentElements.
//
// Note: we assume the "logical" parent of a ContentElement is either
// a UIElement or ContentElement. We explicitly assume that there
// is never a raw Visual as the parent.
DependencyObject parent = ce.GetUIParentCore();
if(parent == null || (bool)parent.GetValue(IsEnabledProperty))
{
return BooleanBoxes.Box(ce.IsEnabledCore);
}
else
{
return BooleanBoxes.FalseBox;
}
}
else
{
return BooleanBoxes.FalseBox;
}
}
private static void OnIsEnabledChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
ContentElement ce = (ContentElement)d;
// Raise the public changed event.
ce.RaiseDependencyPropertyChanged(UIElement.IsEnabledChangedKey, e);
// Invalidate the children so that they will inherit the new value.
ce.InvalidateForceInheritPropertyOnChildren(e.Property);
// The input manager needs to re-hittest because something changed
// that is involved in the hit-testing we do, so a different result
// could be returned.
InputManager.SafeCurrentNotifyHitTestInvalidated();
}
//**********************************************************************
#region Focusable Property
//*********************************************************************
///
/// The DependencyProperty for the Focusable property.
///
[CommonDependencyProperty]
public static readonly DependencyProperty FocusableProperty =
UIElement.FocusableProperty.AddOwner(
typeof(ContentElement),
new UIPropertyMetadata(
BooleanBoxes.FalseBox, // default value
new PropertyChangedCallback(OnFocusableChanged)));
///
/// Gettor and Settor for Focusable Property
///
public bool Focusable
{
get { return (bool) GetValue(FocusableProperty); }
set { SetValue(FocusableProperty, BooleanBoxes.Box(value)); }
}
///
/// FocusableChanged event
///
public event DependencyPropertyChangedEventHandler FocusableChanged
{
add {EventHandlersStoreAdd(UIElement.FocusableChangedKey, value);}
remove {EventHandlersStoreRemove(UIElement.FocusableChangedKey, value);}
}
private static void OnFocusableChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
ContentElement ce = (ContentElement) d;
// Raise the public changed event.
ce.RaiseDependencyPropertyChanged(UIElement.FocusableChangedKey, e);
}
//*********************************************************************
#endregion Focusable Property
//*********************************************************************
///
/// A property indicating if the inptu method is enabled.
///
public bool IsInputMethodEnabled
{
get { return (bool) GetValue(InputMethod.IsInputMethodEnabledProperty); }
}
#endregion Input
#region Operations
private void RaiseMouseButtonEvent(EventPrivateKey key, MouseButtonEventArgs e)
{
EventHandlersStore store = EventHandlersStore;
if (store != null)
{
Delegate handler = store.Get(key);
if (handler != null)
{
((MouseButtonEventHandler)handler)(this, e);
}
}
}
// Helper method to retrieve and fire Clr Event handlers for DependencyPropertyChanged event
private void RaiseDependencyPropertyChanged(EventPrivateKey key, DependencyPropertyChangedEventArgs args)
{
EventHandlersStore store = EventHandlersStore;
if (store != null)
{
Delegate handler = store.Get(key);
if (handler != null)
{
((DependencyPropertyChangedEventHandler)handler)(this, args);
}
}
}
#endregion Operations
#region AllowDrop
///
/// The DependencyProperty for the AllowDrop property.
///
public static readonly DependencyProperty AllowDropProperty =
UIElement.AllowDropProperty.AddOwner(
typeof(ContentElement),
new PropertyMetadata(BooleanBoxes.FalseBox));
///
/// A dependency property that allows the drop object as DragDrop target.
///
public bool AllowDrop
{
get { return (bool) GetValue(AllowDropProperty); }
set { SetValue(AllowDropProperty, BooleanBoxes.Box(value)); }
}
#endregion AllowDrop
#region ForceInherit property support
// This has to be virtual, since there is no concept of "core" content children,
// so we have no choice by to rely on FrameworkContentElement to use logical
// children instead.
internal virtual void InvalidateForceInheritPropertyOnChildren(DependencyProperty property)
{
}
#endregion
#region Touch
///
/// A property indicating if any touch devices are over this element or not.
///
public bool AreAnyTouchesOver
{
get { return ReadFlag(CoreFlags.TouchesOverCache); }
}
///
/// A property indicating if any touch devices are directly over this element or not.
///
public bool AreAnyTouchesDirectlyOver
{
get { return (bool)GetValue(AreAnyTouchesDirectlyOverProperty); }
}
///
/// A property indicating if any touch devices are captured to elements in this subtree.
///
public bool AreAnyTouchesCapturedWithin
{
get { return ReadFlag(CoreFlags.TouchesCapturedWithinCache); }
}
///
/// A property indicating if any touch devices are captured to this element.
///
public bool AreAnyTouchesCaptured
{
get { return (bool)GetValue(AreAnyTouchesCapturedProperty); }
}
///
/// Captures the specified device to this element.
///
/// The touch device to capture.
/// True if capture was taken.
public bool CaptureTouch(TouchDevice touchDevice)
{
if (touchDevice == null)
{
throw new ArgumentNullException("touchDevice");
}
return touchDevice.Capture(this);
}
///
/// Releases capture from the specified touch device.
///
/// The device that is captured to this element.
/// true if capture was released, false otherwise.
public bool ReleaseTouchCapture(TouchDevice touchDevice)
{
if (touchDevice == null)
{
throw new ArgumentNullException("touchDevice");
}
if (touchDevice.Captured == this)
{
touchDevice.Capture(null);
return true;
}
else
{
return false;
}
}
///
/// Releases capture on any touch devices captured to this element.
///
public void ReleaseAllTouchCaptures()
{
TouchDevice.ReleaseAllCaptures(this);
}
///
/// The touch devices captured to this element.
///
public IEnumerable TouchesCaptured
{
get
{
return TouchDevice.GetCapturedTouches(this, /* includeWithin = */ false);
}
}
///
/// The touch devices captured to this element and any elements in the subtree.
///
public IEnumerable TouchesCapturedWithin
{
get
{
return TouchDevice.GetCapturedTouches(this, /* includeWithin = */ true);
}
}
///
/// The touch devices which are over this element and any elements in the subtree.
/// This is particularly relevant to elements which dont take capture (like Label).
///
public IEnumerable TouchesOver
{
get
{
return TouchDevice.GetTouchesOver(this, /* includeWithin = */ true);
}
}
///
/// The touch devices which are directly over this element.
/// This is particularly relevant to elements which dont take capture (like Label).
///
public IEnumerable TouchesDirectlyOver
{
get
{
return TouchDevice.GetTouchesOver(this, /* includeWithin = */ false);
}
}
#endregion
internal bool HasAutomationPeer
{
get { return ReadFlag(CoreFlags.HasAutomationPeer); }
set { WriteFlag(CoreFlags.HasAutomationPeer, value); }
}
#region Data
internal DependencyObject _parent;
///// ATTACHED STORAGE /////
internal static readonly UncommonField EventHandlersStoreField = UIElement.EventHandlersStoreField;
internal static readonly UncommonField InputBindingCollectionField = UIElement.InputBindingCollectionField;
internal static readonly UncommonField CommandBindingCollectionField = UIElement.CommandBindingCollectionField;
private static readonly UncommonField AutomationPeerField = new UncommonField();
// Caches the ContentElement's DependencyObjectType
private static DependencyObjectType ContentElementType = DependencyObjectType.FromSystemTypeInternal(typeof(ContentElement));
#endregion Data
}
}
// 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
- XmlUtf8RawTextWriter.cs
- TypeResolver.cs
- AttachedPropertyMethodSelector.cs
- Selector.cs
- RetrieveVirtualItemEventArgs.cs
- UnsafeNativeMethods.cs
- ConstrainedDataObject.cs
- FormsAuthenticationCredentials.cs
- ExceptionHandler.cs
- CreateParams.cs
- WorkflowViewManager.cs
- HebrewNumber.cs
- MemoryFailPoint.cs
- BlockingCollection.cs
- TextRunTypographyProperties.cs
- LicenseContext.cs
- SqlCommand.cs
- Menu.cs
- ActivationServices.cs
- PrintEvent.cs
- PipelineModuleStepContainer.cs
- UInt64Storage.cs
- BinaryConverter.cs
- ServiceHttpModule.cs
- ProcessStartInfo.cs
- ReadOnlyHierarchicalDataSource.cs
- ExtensionQuery.cs
- ContractComponent.cs
- GACIdentityPermission.cs
- EngineSiteSapi.cs
- KeySpline.cs
- StackSpiller.Bindings.cs
- NamespaceList.cs
- DataGridViewCellLinkedList.cs
- BitSet.cs
- BuildResult.cs
- TableLayoutColumnStyleCollection.cs
- XmlSchemaProviderAttribute.cs
- SoapElementAttribute.cs
- PeerCollaboration.cs
- ExtensionFile.cs
- ErrorRuntimeConfig.cs
- RegistrySecurity.cs
- CodeDirectionExpression.cs
- GridViewRowCollection.cs
- RoutedEvent.cs
- XmlnsCache.cs
- ErrorFormatterPage.cs
- WeakReadOnlyCollection.cs
- InfoCardRSAPKCS1SignatureFormatter.cs
- TransactionFlowElement.cs
- Delegate.cs
- CombinedHttpChannel.cs
- EmptyTextWriter.cs
- TextEditorLists.cs
- AncillaryOps.cs
- EventDescriptor.cs
- TypeDependencyAttribute.cs
- TextRangeAdaptor.cs
- Accessors.cs
- XmlSchemaDocumentation.cs
- __ComObject.cs
- ReceiveActivityValidator.cs
- BitmapSource.cs
- ConfigurationPropertyCollection.cs
- SqlBulkCopy.cs
- TabControlCancelEvent.cs
- MetafileHeader.cs
- ProcessModelSection.cs
- EnvelopedSignatureTransform.cs
- SqlNode.cs
- ProfileEventArgs.cs
- SiteMembershipCondition.cs
- HandleTable.cs
- InvalidTimeZoneException.cs
- SigningProgress.cs
- Span.cs
- WebServiceMethodData.cs
- SystemIPInterfaceStatistics.cs
- SrgsToken.cs
- _NetRes.cs
- ConnectionPointCookie.cs
- DashStyles.cs
- ParameterToken.cs
- XPathNavigatorReader.cs
- NopReturnReader.cs
- HttpTransportManager.cs
- ListViewSortEventArgs.cs
- GatewayIPAddressInformationCollection.cs
- newitemfactory.cs
- AndAlso.cs
- AuthenticationManager.cs
- IncrementalReadDecoders.cs
- SpeechRecognizer.cs
- SystemWebCachingSectionGroup.cs
- SecurityElement.cs
- XmlHierarchicalDataSourceView.cs
- Encoder.cs
- GridViewSortEventArgs.cs
- RotateTransform.cs