Code:
/ Dotnetfx_Vista_SP2 / Dotnetfx_Vista_SP2 / 8.0.50727.4016 / DEVDIV / depot / DevDiv / releases / Orcas / QFE / wpf / src / Core / CSharp / System / Windows / Media / VisualBrush.cs / 1 / VisualBrush.cs
//----------------------------------------------------------------------------
//
// Copyright (C) Microsoft Corporation. All rights reserved.
//
// File: VisualBrush.cs
//
// Description: This file contains the implementation of VisualBrush.
// The VisualBrush is a TileBrush which defines its tile content
// by use of a Visual.
//
// History:
//
//---------------------------------------------------------------------------
using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Security;
using System.Windows;
using System.Windows.Media;
using System.Windows.Media.Media3D;
using System.Windows.Media.Animation;
using System.Windows.Media.Composition;
using System.Windows.Threading;
using MS.Internal;
namespace System.Windows.Media
{
///
/// VisualBrush - This TileBrush defines its content as a Visual
///
public sealed partial class VisualBrush : TileBrush
{
// registration token used to register the brush with the media context
internal class VisualBrushRegisterToken: ICompositionTarget
{
public VisualBrushRegisterToken(VisualBrush vb)
{
Debug.Assert(vb != null);
_vb = vb;
}
public void Dispose() {}
public void Render(bool inResize, DUCE.Channel channel)
{
_vb.Render(channel);
}
void ICompositionTarget.AddRefOnChannel(DUCE.Channel channel, DUCE.Channel outOfBandChannel) {}
void ICompositionTarget.ReleaseOnChannel(DUCE.Channel channel, DUCE.Channel outOfBandChannel) {}
bool ICompositionTarget.VisualTreeContainsGraphness()
{
return true;
}
private VisualBrush _vb;
}
#region Constructors
///
/// Default constructor for VisualBrush. The resulting Brush has no content.
///
public VisualBrush()
{
_vbToken = new VisualBrushRegisterToken(this);
}
///
/// VisualBrush Constructor where the image is set to the parameter's value
///
/// The Visual representing the contents of this Brush.
public VisualBrush(Visual visual)
{
if (this.Dispatcher != null)
{
MediaSystem.AssertSameContext(this, visual);
Visual = visual;
}
}
#endregion Constructors
///
/// This node can introduce graphness
///
internal override bool CanIntroduceGraphness()
{
return true;
}
internal void FireOnChanged()
{
// Simple loop detection to avoid stack overflow in cyclic VisualBrush
// scenarios. This fix is only aimed at mitigating a very common
// VisualBrush scenario.
bool canEnter = Enter();
if (canEnter)
{
try
{
_isCacheDirty = true;
FireChanged();
}
finally
{
Exit();
}
}
}
internal void Render(DUCE.Channel channel)
{
if (Visual != null)
{
RenderForVisualBrush(channel);
}
}
internal VisualBrushRegisterToken BrushRegisterToken
{
get
{
if (_vbToken == null)
{
_vbToken = new VisualBrushRegisterToken(this);
}
return _vbToken;
}
}
internal void RenderForVisualBrush(
DUCE.Channel channel)
{
Visual vVisual = Visual;
if (vVisual != null)
{
// -----------------------------------------------------------------------------------
// 1) Prepare the visual for rendering.
//
// Mark the node as is in a brush. This ensures that in the render
// pass we initiate here, the node is forced to fully visible and
// properly marshaled.
vVisual.SetFlags(true, VisualFlags.NodeIsVisualBrushRoot);
vVisual.Precompute();
// -----------------------------------------------------------------------------------
// 2) Prepare the render context.
//
RenderContext rc = new RenderContext();
rc.Initialize(channel, DUCE.ResourceHandle.Null);
// ------------------------------------------------------------------------------------
// 3) Compile the scene.
if (channel.IsConnected)
{
vVisual.Render(rc, 0);
}
else
{
// We can issue the release here instead of putting it in queue
// since we are already in Render walk.
((DUCE.IResource)vVisual).ReleaseOnChannel(channel);
}
}
}
// Implement functions used to addref and release resources in codegen that need
// to be specialized for Visual which doesn't implement DUCE.IResource
internal void AddRefResource(Visual visual, DUCE.Channel channel)
{
if (visual != null)
{
visual.AddRefOnChannelForVisualBrush(this, channel);
}
}
internal void ReleaseResource(Visual visual, DUCE.Channel channel)
{
if (visual != null)
{
visual.ReleaseOnChannelForVisualBrush(this, channel);
}
}
///
/// Implementation of DependencyObject.OnPropertyInvalidated .
/// If the property is the Visual or the AutoLayoutContent property, we re-layout the Visual if
/// possible.
///
protected override void OnPropertyChanged(DependencyPropertyChangedEventArgs e)
{
base.OnPropertyChanged(e);
if (e.IsAValueChange || e.IsASubPropertyChange)
{
if ((e.Property == VisualProperty) || (e.Property == AutoLayoutContentProperty))
{
// Should we initiate a layout on this Visual?
// Yes, if AutoLayoutContent is true and if the Visual is a UIElement not already in
// another tree (i.e. the parent is null) or its not the hwnd root.
if (AutoLayoutContent)
{
Debug.Assert(!_pendingLayout);
UIElement element = Visual as UIElement;
if ((element != null)
&&
((VisualTreeHelper.GetParent(element) == null && !(element.IsRootElement))
|| (VisualTreeHelper.GetParent(element) is Visual3D)))
{
//
// We need 2 ways of initiating layout on the VisualBrush root.
// 1. We add a handler such that when the layout is done for the
// main tree and LayoutUpdated is fired, then we do layout for the
// VisualBrush tree.
// However, this can fail in the case where the main tree is composed
// of just Visuals and never does layout nor fires LayoutUpdated. So
// we also need the following approach.
// 2. We do a BeginInvoke to start layout on the Visual. This approach
// alone, also falls short in the scenario where if we are already in
// MediaContext.DoWork() then we will do layout (for main tree), then look
// at Loaded callbacks, then render, and then finally the Dispather will
// fire us for layout. So during loaded callbacks we would not have done
// layout on the VisualBrush tree.
//
// Depending upon which of the two layout passes comes first, we cancel
// the other layout pass.
//
element.LayoutUpdated += OnLayoutUpdated;
_DispatcherLayoutResult = Dispatcher.BeginInvoke(
DispatcherPriority.Normal,
new DispatcherOperationCallback(LayoutCallback),
element);
_pendingLayout = true;
}
}
}
}
}
///
/// We initiate the layout on the tree rooted at the Visual to which VisualBrush points.
///
private void DoLayout(UIElement element)
{
Debug.Assert(element != null);
DependencyObject parent = VisualTreeHelper.GetParent(element);
if (!(element.IsRootElement)
&& (parent == null || parent is Visual3D))
{
//
// PropagateResumeLayout sets the LayoutSuspended flag to false if it were true.
//
UIElement.PropagateResumeLayout(null, element);
element.Measure(new Size(Double.PositiveInfinity, Double.PositiveInfinity));
element.Arrange(new Rect(element.DesiredSize));
}
}
///
/// LayoutUpdate event handler.
///
/// event sender (not used)
/// event arguments (not used)
private void OnLayoutUpdated(object sender, EventArgs args)
{
Debug.Assert(_pendingLayout);
// Visual has to be a UIElement since the handler was added to it.
UIElement element = (UIElement)Visual;
Debug.Assert(element != null);
// Unregister for the event
element.LayoutUpdated -= OnLayoutUpdated;
_pendingLayout = false;
//
// Since we are in this function that means that layoutUpdated fired before
// Dispatcher.BeginInvoke fired. So we can abort the DispatcherOperation as
// we will do the layout here.
//
Debug.Assert(_DispatcherLayoutResult != null);
Debug.Assert(_DispatcherLayoutResult.Status == DispatcherOperationStatus.Pending);
bool abortStatus = _DispatcherLayoutResult.Abort();
Debug.Assert(abortStatus);
DoLayout(element);
}
///
/// DispatcherOperation callback to initiate layout.
///
/// The Visual root
private object LayoutCallback(object arg)
{
Debug.Assert(_pendingLayout);
UIElement element = arg as UIElement;
Debug.Assert(element != null);
//
// Since we are in this function that means that Dispatcher.BeginInvoke fired
// before LayoutUpdated fired. So we can remove the LayoutUpdated handler as
// we will do the layout here.
//
element.LayoutUpdated -= OnLayoutUpdated;
_pendingLayout = false;
DoLayout(element);
return null;
}
///
/// Enter is used for simple cycle detection in VisualBrush. If the method returns false
/// the brush has already been entered and cannot be entered again. Matching invocation of Exit
/// must be skipped if Enter returns false.
///
internal bool Enter()
{
if (_reentrancyFlag)
{
return false;
}
else
{
_reentrancyFlag = true;
return true;
}
}
///
/// Exits the VisualBrush. For more details see Enter method.
///
internal void Exit()
{
Debug.Assert(_reentrancyFlag); // Exit must be matched with Enter. See Enter comments.
_reentrancyFlag = false;
}
///
/// Obtains the current bounds of the brush's content
///
/// Output bounds of content
protected override void GetContentBounds(out Rect contentBounds)
{
// Obtain the current visual's outer space bounding box. We return the outer space
// bounding box because we want to have the bounding box of the Visual tree including
// transform/offset at the root.
if (_isCacheDirty)
{
_bbox = Visual.CalculateSubgraphBoundsOuterSpace();
_isCacheDirty = false;
}
contentBounds = _bbox;
}
///
/// Precompute is called during the frame preparation phase. Derived classes
/// typically check if the brush requires realizations during this phase.
///
internal override void Precompute()
{
Visual visual = Visual;
if (visual != null)
{
// Simple loop detection to avoid stack overflow in cyclic VisualBrush
// scenarios. This fix is only aimed at mitigating a very common
// VisualBrush scenario.
bool canEnter = Enter();
if (canEnter)
{
try
{
visual.Precompute();
_requiresRealizationUpdates = visual.RequiresRealizationUpdates;
}
finally
{
Exit();
}
}
}
else
{
_requiresRealizationUpdates = false;
}
}
///
/// Checks if realization updates are requried for this resource.
///
internal override bool RequiresRealizationUpdates
{
get
{
return _requiresRealizationUpdates;
}
}
///
/// Derived classes must override this method and update realizations on dependent
/// resources if required.
///
internal override void UpdateRealizations(Rect fillShapeBounds, RealizationContext ctx)
{
Visual visual = Visual;
if (_requiresRealizationUpdates && (visual != null))
{
// Simple loop detection to avoid stack overflow in cyclic VisualBrush
// scenarios. This fix is only aimed at mitigating a very common
// VisualBrush scenario.
bool canEnter = Enter();
if (canEnter)
{
try
{
Matrix m;
GetTileBrushMapping(fillShapeBounds, out m);
ctx.TransformStack.Push(ref m, true);
visual.MarkVisibleRealizations(ctx);
ctx.TransformStack.Pop();
}
finally
{
Exit();
}
}
}
}
internal VisualBrushRegisterToken _vbToken;
private DispatcherOperation _DispatcherLayoutResult;
private bool _pendingLayout;
private bool _reentrancyFlag;
private bool _requiresRealizationUpdates;
// Whether we need to re-calculate our content bounds.
private bool _isCacheDirty = true;
// Keep our content bounds cached.
private Rect _bbox = Rect.Empty;
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
//----------------------------------------------------------------------------
//
// Copyright (C) Microsoft Corporation. All rights reserved.
//
// File: VisualBrush.cs
//
// Description: This file contains the implementation of VisualBrush.
// The VisualBrush is a TileBrush which defines its tile content
// by use of a Visual.
//
// History:
//
//---------------------------------------------------------------------------
using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Security;
using System.Windows;
using System.Windows.Media;
using System.Windows.Media.Media3D;
using System.Windows.Media.Animation;
using System.Windows.Media.Composition;
using System.Windows.Threading;
using MS.Internal;
namespace System.Windows.Media
{
///
/// VisualBrush - This TileBrush defines its content as a Visual
///
public sealed partial class VisualBrush : TileBrush
{
// registration token used to register the brush with the media context
internal class VisualBrushRegisterToken: ICompositionTarget
{
public VisualBrushRegisterToken(VisualBrush vb)
{
Debug.Assert(vb != null);
_vb = vb;
}
public void Dispose() {}
public void Render(bool inResize, DUCE.Channel channel)
{
_vb.Render(channel);
}
void ICompositionTarget.AddRefOnChannel(DUCE.Channel channel, DUCE.Channel outOfBandChannel) {}
void ICompositionTarget.ReleaseOnChannel(DUCE.Channel channel, DUCE.Channel outOfBandChannel) {}
bool ICompositionTarget.VisualTreeContainsGraphness()
{
return true;
}
private VisualBrush _vb;
}
#region Constructors
///
/// Default constructor for VisualBrush. The resulting Brush has no content.
///
public VisualBrush()
{
_vbToken = new VisualBrushRegisterToken(this);
}
///
/// VisualBrush Constructor where the image is set to the parameter's value
///
/// The Visual representing the contents of this Brush.
public VisualBrush(Visual visual)
{
if (this.Dispatcher != null)
{
MediaSystem.AssertSameContext(this, visual);
Visual = visual;
}
}
#endregion Constructors
///
/// This node can introduce graphness
///
internal override bool CanIntroduceGraphness()
{
return true;
}
internal void FireOnChanged()
{
// Simple loop detection to avoid stack overflow in cyclic VisualBrush
// scenarios. This fix is only aimed at mitigating a very common
// VisualBrush scenario.
bool canEnter = Enter();
if (canEnter)
{
try
{
_isCacheDirty = true;
FireChanged();
}
finally
{
Exit();
}
}
}
internal void Render(DUCE.Channel channel)
{
if (Visual != null)
{
RenderForVisualBrush(channel);
}
}
internal VisualBrushRegisterToken BrushRegisterToken
{
get
{
if (_vbToken == null)
{
_vbToken = new VisualBrushRegisterToken(this);
}
return _vbToken;
}
}
internal void RenderForVisualBrush(
DUCE.Channel channel)
{
Visual vVisual = Visual;
if (vVisual != null)
{
// -----------------------------------------------------------------------------------
// 1) Prepare the visual for rendering.
//
// Mark the node as is in a brush. This ensures that in the render
// pass we initiate here, the node is forced to fully visible and
// properly marshaled.
vVisual.SetFlags(true, VisualFlags.NodeIsVisualBrushRoot);
vVisual.Precompute();
// -----------------------------------------------------------------------------------
// 2) Prepare the render context.
//
RenderContext rc = new RenderContext();
rc.Initialize(channel, DUCE.ResourceHandle.Null);
// ------------------------------------------------------------------------------------
// 3) Compile the scene.
if (channel.IsConnected)
{
vVisual.Render(rc, 0);
}
else
{
// We can issue the release here instead of putting it in queue
// since we are already in Render walk.
((DUCE.IResource)vVisual).ReleaseOnChannel(channel);
}
}
}
// Implement functions used to addref and release resources in codegen that need
// to be specialized for Visual which doesn't implement DUCE.IResource
internal void AddRefResource(Visual visual, DUCE.Channel channel)
{
if (visual != null)
{
visual.AddRefOnChannelForVisualBrush(this, channel);
}
}
internal void ReleaseResource(Visual visual, DUCE.Channel channel)
{
if (visual != null)
{
visual.ReleaseOnChannelForVisualBrush(this, channel);
}
}
///
/// Implementation of DependencyObject.OnPropertyInvalidated .
/// If the property is the Visual or the AutoLayoutContent property, we re-layout the Visual if
/// possible.
///
protected override void OnPropertyChanged(DependencyPropertyChangedEventArgs e)
{
base.OnPropertyChanged(e);
if (e.IsAValueChange || e.IsASubPropertyChange)
{
if ((e.Property == VisualProperty) || (e.Property == AutoLayoutContentProperty))
{
// Should we initiate a layout on this Visual?
// Yes, if AutoLayoutContent is true and if the Visual is a UIElement not already in
// another tree (i.e. the parent is null) or its not the hwnd root.
if (AutoLayoutContent)
{
Debug.Assert(!_pendingLayout);
UIElement element = Visual as UIElement;
if ((element != null)
&&
((VisualTreeHelper.GetParent(element) == null && !(element.IsRootElement))
|| (VisualTreeHelper.GetParent(element) is Visual3D)))
{
//
// We need 2 ways of initiating layout on the VisualBrush root.
// 1. We add a handler such that when the layout is done for the
// main tree and LayoutUpdated is fired, then we do layout for the
// VisualBrush tree.
// However, this can fail in the case where the main tree is composed
// of just Visuals and never does layout nor fires LayoutUpdated. So
// we also need the following approach.
// 2. We do a BeginInvoke to start layout on the Visual. This approach
// alone, also falls short in the scenario where if we are already in
// MediaContext.DoWork() then we will do layout (for main tree), then look
// at Loaded callbacks, then render, and then finally the Dispather will
// fire us for layout. So during loaded callbacks we would not have done
// layout on the VisualBrush tree.
//
// Depending upon which of the two layout passes comes first, we cancel
// the other layout pass.
//
element.LayoutUpdated += OnLayoutUpdated;
_DispatcherLayoutResult = Dispatcher.BeginInvoke(
DispatcherPriority.Normal,
new DispatcherOperationCallback(LayoutCallback),
element);
_pendingLayout = true;
}
}
}
}
}
///
/// We initiate the layout on the tree rooted at the Visual to which VisualBrush points.
///
private void DoLayout(UIElement element)
{
Debug.Assert(element != null);
DependencyObject parent = VisualTreeHelper.GetParent(element);
if (!(element.IsRootElement)
&& (parent == null || parent is Visual3D))
{
//
// PropagateResumeLayout sets the LayoutSuspended flag to false if it were true.
//
UIElement.PropagateResumeLayout(null, element);
element.Measure(new Size(Double.PositiveInfinity, Double.PositiveInfinity));
element.Arrange(new Rect(element.DesiredSize));
}
}
///
/// LayoutUpdate event handler.
///
/// event sender (not used)
/// event arguments (not used)
private void OnLayoutUpdated(object sender, EventArgs args)
{
Debug.Assert(_pendingLayout);
// Visual has to be a UIElement since the handler was added to it.
UIElement element = (UIElement)Visual;
Debug.Assert(element != null);
// Unregister for the event
element.LayoutUpdated -= OnLayoutUpdated;
_pendingLayout = false;
//
// Since we are in this function that means that layoutUpdated fired before
// Dispatcher.BeginInvoke fired. So we can abort the DispatcherOperation as
// we will do the layout here.
//
Debug.Assert(_DispatcherLayoutResult != null);
Debug.Assert(_DispatcherLayoutResult.Status == DispatcherOperationStatus.Pending);
bool abortStatus = _DispatcherLayoutResult.Abort();
Debug.Assert(abortStatus);
DoLayout(element);
}
///
/// DispatcherOperation callback to initiate layout.
///
/// The Visual root
private object LayoutCallback(object arg)
{
Debug.Assert(_pendingLayout);
UIElement element = arg as UIElement;
Debug.Assert(element != null);
//
// Since we are in this function that means that Dispatcher.BeginInvoke fired
// before LayoutUpdated fired. So we can remove the LayoutUpdated handler as
// we will do the layout here.
//
element.LayoutUpdated -= OnLayoutUpdated;
_pendingLayout = false;
DoLayout(element);
return null;
}
///
/// Enter is used for simple cycle detection in VisualBrush. If the method returns false
/// the brush has already been entered and cannot be entered again. Matching invocation of Exit
/// must be skipped if Enter returns false.
///
internal bool Enter()
{
if (_reentrancyFlag)
{
return false;
}
else
{
_reentrancyFlag = true;
return true;
}
}
///
/// Exits the VisualBrush. For more details see Enter method.
///
internal void Exit()
{
Debug.Assert(_reentrancyFlag); // Exit must be matched with Enter. See Enter comments.
_reentrancyFlag = false;
}
///
/// Obtains the current bounds of the brush's content
///
/// Output bounds of content
protected override void GetContentBounds(out Rect contentBounds)
{
// Obtain the current visual's outer space bounding box. We return the outer space
// bounding box because we want to have the bounding box of the Visual tree including
// transform/offset at the root.
if (_isCacheDirty)
{
_bbox = Visual.CalculateSubgraphBoundsOuterSpace();
_isCacheDirty = false;
}
contentBounds = _bbox;
}
///
/// Precompute is called during the frame preparation phase. Derived classes
/// typically check if the brush requires realizations during this phase.
///
internal override void Precompute()
{
Visual visual = Visual;
if (visual != null)
{
// Simple loop detection to avoid stack overflow in cyclic VisualBrush
// scenarios. This fix is only aimed at mitigating a very common
// VisualBrush scenario.
bool canEnter = Enter();
if (canEnter)
{
try
{
visual.Precompute();
_requiresRealizationUpdates = visual.RequiresRealizationUpdates;
}
finally
{
Exit();
}
}
}
else
{
_requiresRealizationUpdates = false;
}
}
///
/// Checks if realization updates are requried for this resource.
///
internal override bool RequiresRealizationUpdates
{
get
{
return _requiresRealizationUpdates;
}
}
///
/// Derived classes must override this method and update realizations on dependent
/// resources if required.
///
internal override void UpdateRealizations(Rect fillShapeBounds, RealizationContext ctx)
{
Visual visual = Visual;
if (_requiresRealizationUpdates && (visual != null))
{
// Simple loop detection to avoid stack overflow in cyclic VisualBrush
// scenarios. This fix is only aimed at mitigating a very common
// VisualBrush scenario.
bool canEnter = Enter();
if (canEnter)
{
try
{
Matrix m;
GetTileBrushMapping(fillShapeBounds, out m);
ctx.TransformStack.Push(ref m, true);
visual.MarkVisibleRealizations(ctx);
ctx.TransformStack.Pop();
}
finally
{
Exit();
}
}
}
}
internal VisualBrushRegisterToken _vbToken;
private DispatcherOperation _DispatcherLayoutResult;
private bool _pendingLayout;
private bool _reentrancyFlag;
private bool _requiresRealizationUpdates;
// Whether we need to re-calculate our content bounds.
private bool _isCacheDirty = true;
// Keep our content bounds cached.
private Rect _bbox = Rect.Empty;
}
}
// 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
- Timeline.cs
- DataGridState.cs
- FileDialogCustomPlace.cs
- BatchServiceHost.cs
- _SslStream.cs
- DbMetaDataColumnNames.cs
- QilPatternFactory.cs
- Barrier.cs
- DataServiceCollectionOfT.cs
- initElementDictionary.cs
- AppSecurityManager.cs
- XmlAttributes.cs
- ProtocolElement.cs
- _Connection.cs
- PromptBuilder.cs
- TdsParameterSetter.cs
- ListBase.cs
- RegexTree.cs
- AdornerPresentationContext.cs
- StopRoutingHandler.cs
- MessageSmuggler.cs
- DataContractSerializer.cs
- securitymgrsite.cs
- SoapExtensionTypeElementCollection.cs
- TypeDescriptionProviderAttribute.cs
- WebProxyScriptElement.cs
- DatePickerTextBox.cs
- SchemaInfo.cs
- Debugger.cs
- Primitive.cs
- RefType.cs
- HtmlMeta.cs
- PlainXmlDeserializer.cs
- ReflectEventDescriptor.cs
- TriState.cs
- TextBox.cs
- DispatcherHooks.cs
- PaperSource.cs
- ToolBarPanel.cs
- FamilyCollection.cs
- ToolStripContentPanelRenderEventArgs.cs
- TableItemProviderWrapper.cs
- RadioButtonBaseAdapter.cs
- SafeCertificateContext.cs
- ObjectStateFormatter.cs
- StorageMappingItemCollection.cs
- MaskedTextBoxDesignerActionList.cs
- PersonalizationDictionary.cs
- NativeMethods.cs
- BmpBitmapEncoder.cs
- WebPartUserCapability.cs
- HMACSHA1.cs
- RadioButtonStandardAdapter.cs
- XmlDataCollection.cs
- DbModificationClause.cs
- ValidationErrorEventArgs.cs
- ClientData.cs
- FileLogRecordHeader.cs
- MemoryStream.cs
- WebHttpSecurityModeHelper.cs
- SafeTimerHandle.cs
- TableCellCollection.cs
- DataConnectionHelper.cs
- validationstate.cs
- IgnorePropertiesAttribute.cs
- ExpressionSelection.cs
- DockAndAnchorLayout.cs
- HashSet.cs
- ConnectionOrientedTransportElement.cs
- GcHandle.cs
- InvalidFilterCriteriaException.cs
- WebEventTraceProvider.cs
- CompensatableTransactionScopeActivityDesigner.cs
- FlagsAttribute.cs
- Int32CollectionConverter.cs
- Bidi.cs
- SQLRoleProvider.cs
- XmlSchemaComplexContentRestriction.cs
- CollectionView.cs
- FixedSOMLineRanges.cs
- _ConnectOverlappedAsyncResult.cs
- QilFactory.cs
- Brushes.cs
- DataFormats.cs
- login.cs
- RoutingUtilities.cs
- Bidi.cs
- SelectedGridItemChangedEvent.cs
- CustomAttributeSerializer.cs
- SingleStorage.cs
- ClaimComparer.cs
- SqlExpander.cs
- GridViewEditEventArgs.cs
- TabItemWrapperAutomationPeer.cs
- BaseInfoTable.cs
- HtmlImage.cs
- TCPListener.cs
- ControlPropertyNameConverter.cs
- HandleCollector.cs
- FocusWithinProperty.cs