Code:
/ DotNET / DotNET / 8.0 / untmp / whidbey / REDBITS / ndp / fx / src / Designer / WinForms / System / WinForms / Design / ToolStripItemDesigner.cs / 1 / ToolStripItemDesigner.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
/*
*/
namespace System.Windows.Forms.Design
{
using System.Design;
using System.ComponentModel;
using System;
using System.Windows.Forms;
using System.ComponentModel.Design;
using System.Drawing;
using System.Windows.Forms.Design.Behavior;
using System.Drawing.Design;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Collections;
using System.ComponentModel.Design.Serialization;
using System.Configuration;
using System.Runtime.InteropServices;
///
/// Designer for ToolStripItems.
///
internal class ToolStripItemDesigner : ComponentDesigner
{
private const int GLYPHBORDER = 1;
private const int GLYPHINSET = 2;
//
// Cached in value of the TemplateNode (which is the InSitu Editor)
//
private ToolStripTemplateNode _editorNode;
//
// Used by the ParentDesigner (ToolStripDesigner) to know whether there
// is any active Editor.
//
private bool isEditorActive = false;
// this property is used in the InitializeNewComponent not to set the text for the ToolstripItem
private bool internalCreate = false;
//hook to SelectionService to listen to SelectionChanged
private ISelectionService selSvc = null;
//ToolStripItems Visibility needs to be WYSIWYG.
private bool currentVisible = false;
private Rectangle lastInsertionMarkRect = Rectangle.Empty;
// Required to remove Body Glyphs ....
internal ControlBodyGlyph bodyGlyph = null;
//bool which is set if we Add Dummy Item
internal bool dummyItemAdded = false;
//Needed to Store the DRAGDROP Rect from the WinbarItemBehavior.
internal Rectangle dragBoxFromMouseDown = Rectangle.Empty;
//defaulted to invalid index.
// this will be set by the behaviour.
internal int indexOfItemUnderMouseToDrag = -1;
// ToolStrip's Own Context Menu
//private BaseContextMenuStrip toolStripContextMenu;
private ToolStripItemCustomMenuItemCollection toolStripItemCustomMenuItemCollection;
///
/// ShadowProperty.
///
internal bool AutoSize
{
get
{
return (bool)ShadowProperties["AutoSize"];
}
set
{
bool autoSize = (bool)ShadowProperties["AutoSize"];
// always set this in regardless of whether the property changed.
// it can come back to bite later after in-situ editing if we dont.
ShadowProperties["AutoSize"] = value;
if (value != autoSize)
{
ToolStripItem.AutoSize = value;
}
}
}
///
/// ShadowProperty.
///
private string AccessibleName
{
get
{
return (string)ShadowProperties["AccessibleName"];
}
set
{
ShadowProperties["AccessibleName"] = value;
}
}
///
/// Associated Parent Designer
///
internal override bool CanBeAssociatedWith(IDesigner parentDesigner)
{
return (parentDesigner is ToolStripDesigner);
}
///
/// Designer Custom ContextMenu.
///
private ContextMenuStrip DesignerContextMenu
{
get
{
BaseContextMenuStrip toolStripContextMenu = new BaseContextMenuStrip(Component.Site, ToolStripItem);
// If multiple Items Selected dont show the custom properties...
if (selSvc.SelectionCount > 1)
{
toolStripContextMenu.GroupOrdering.Clear();
toolStripContextMenu.GroupOrdering.AddRange(new string[] { StandardGroups.Code,
StandardGroups.Selection,
StandardGroups.Edit,
StandardGroups.Properties});
}
else
{
toolStripContextMenu.GroupOrdering.Clear();
toolStripContextMenu.GroupOrdering.AddRange(new string[] { StandardGroups.Code,
StandardGroups.Custom,
StandardGroups.Selection,
StandardGroups.Edit,
StandardGroups.Properties});
toolStripContextMenu.Text = "CustomContextMenu";
if (toolStripItemCustomMenuItemCollection == null)
{
toolStripItemCustomMenuItemCollection = new ToolStripItemCustomMenuItemCollection(Component.Site, ToolStripItem);
}
foreach (ToolStripItem item in toolStripItemCustomMenuItemCollection)
{
toolStripContextMenu.Groups[StandardGroups.Custom].Items.Add(item);
}
}
// Refresh the list on every show..
if (toolStripItemCustomMenuItemCollection != null)
{
toolStripItemCustomMenuItemCollection.RefreshItems();
}
toolStripContextMenu.Populated = false;
return toolStripContextMenu;
}
}
///
/// ToolStripEditorManager used this internal property to
/// Activate the editor.
///
internal virtual ToolStripTemplateNode Editor
{
get
{
return _editorNode;
}
set
{
_editorNode = value;
}
}
// ToolStripItems if Inherited ACT as Readonly.
protected override InheritanceAttribute InheritanceAttribute
{
get
{
if ((base.InheritanceAttribute == InheritanceAttribute.Inherited))
{
return InheritanceAttribute.InheritedReadOnly;
}
return base.InheritanceAttribute;
}
}
///
/// ToolStripEditorManager used this internal property to
/// set the the desinger's IsEditorActive to notify
/// if this item has entered or exited the InSitu Edit Mode.
///
internal bool IsEditorActive
{
get
{
return isEditorActive;
}
set
{
isEditorActive = value;
}
}
///
/// When the ToolStripItem is created we dont want InitializeNewComponent to set the "text"
/// we do it ourselves from the Text the User has provided in the InSitu Edit Mode
/// Reason being the item and the Parent unnecessarily Layout and cause flicker.
///
internal bool InternalCreate
{
get
{
return internalCreate;
}
set
{
internalCreate = value;
}
}
///
/// Parent ToolStrip.
///
protected IComponent ImmediateParent
{
get
{
if (ToolStripItem != null)
{
ToolStrip parent = ToolStripItem.GetCurrentParent();
return (parent != null) ? parent : ToolStripItem.Owner;
}
return null;
}
}
///
/// ShadowProperty.
///
private ToolStripItemOverflow Overflow
{
get
{
return (ToolStripItemOverflow)ShadowProperties["Overflow"];
}
set
{
// first Hide the Overflow..
if (ToolStripItem.IsOnOverflow)
{
ToolStrip strip = ToolStripItem.Owner as ToolStrip;
if (strip.OverflowButton.DropDown.Visible)
{
strip.OverflowButton.HideDropDown();
}
}
if (ToolStripItem is ToolStripDropDownItem)
{
ToolStripDropDownItem item = ToolStripItem as ToolStripDropDownItem;
item.HideDropDown();
}
//set the value on actual item
if (value != ToolStripItem.Overflow)
{
ToolStripItem.Overflow = value;
ShadowProperties["Overflow"] = value;
}
// Since this cause the whole Layout to Change ...
// Call SyncSelection to reset the glyphs...
BehaviorService b = (BehaviorService)GetService(typeof(BehaviorService));
if (b != null)
{
b.SyncSelection();
}
}
}
///
/// Parent ToolStrip.
///
protected override IComponent ParentComponent
{
get
{
if (ToolStripItem != null)
{
if (ToolStripItem.IsOnDropDown && !ToolStripItem.IsOnOverflow)
{
ToolStripDropDown parentDropDown = ImmediateParent as ToolStripDropDown;
if (parentDropDown != null)
{
if (parentDropDown.IsAutoGenerated)
{
return parentDropDown.OwnerItem;
}
else
{
return parentDropDown;
}
}
}
return GetMainToolStrip();
}
return null;
}
}
///
/// Easy method for getting to the ToolStripItem
///
public ToolStripItem ToolStripItem
{
get
{
return (ToolStripItem)Component;
}
}
///
/// ShadowProperty.
///
protected bool Visible
{
get
{
return (bool)ShadowProperties["Visible"];
}
set
{
ShadowProperties["Visible"] = value;
currentVisible = value;
}
}
////////////////////////////////////////////////////////////////////////////////////
//// ////
//// Methods ////
//// ////
////////////////////////////////////////////////////////////////////////////////////
///
/// This method adds the Parent Hierarchy to arraylist and returns that arraylist to the Base ContextMenu provider.
/// This way the ToolStripItem can show the right parents in the contextMenu
///
///
internal ArrayList AddParentTree()
{
ArrayList parentControls = new ArrayList();
IDesignerHost designerHost = (IDesignerHost)GetService(typeof(IDesignerHost));
if (designerHost != null)
{
IComponent root = designerHost.RootComponent;
Component startComp = ToolStripItem;
if (startComp != null && root != null)
{
while (startComp != root)
{
if (startComp is ToolStripItem)
{
ToolStripItem item = startComp as ToolStripItem;
if (item.IsOnDropDown)
{
if (item.IsOnOverflow)
{
parentControls.Add(item.Owner);
startComp = item.Owner;
}
else
{
ToolStripDropDown parentDropDown = item.Owner as ToolStripDropDown;
if (parentDropDown != null)
{
ToolStripItem ownerItem = parentDropDown.OwnerItem;
if (ownerItem != null)
{
parentControls.Add(ownerItem);
startComp = ownerItem;
}
}
}
}
else
{
if (item.Owner.Site != null)
{
parentControls.Add(item.Owner);
}
startComp = item.Owner;
}
}
else if (startComp is Control)
{
Control selectedControl = startComp as Control;
Control parentControl = selectedControl.Parent;
if (parentControl.Site != null)
{
parentControls.Add(parentControl);
}
startComp = parentControl;
}
}
}
}
return parentControls;
}
///
/// Creates the InSitu Edit Node (which is called the TemplateNode).
///
///
/// This is called by the TemplateNode to Commit the Edit.
/// This Function Simply changes the "Text and Image" property of the
/// current ToolStripItem.
///
///
/// Disposes of this designer.
///
protected override void Dispose(bool disposing)
{
if (disposing)
{
//clean up
if (_editorNode != null)
{
_editorNode.CloseEditor();
_editorNode = null;
}
if (ToolStripItem != null)
{
ToolStripItem.Paint -= new System.Windows.Forms.PaintEventHandler(OnItemPaint);
}
// Now, unhook the component rename event
//
IComponentChangeService cs = (IComponentChangeService)GetService(typeof(IComponentChangeService));
if (cs != null)
{
cs.ComponentRename -= new ComponentRenameEventHandler(this.OnComponentRename);
}
//clean up
if (selSvc != null)
{
selSvc.SelectionChanged -= new EventHandler(this.OnSelectionChanged);
}
//clean up the ToolStripItem Glyph if Any
if (bodyGlyph != null)
{
ToolStripAdornerWindowService toolStripAdornerWindowService = (ToolStripAdornerWindowService)GetService(typeof(ToolStripAdornerWindowService));
if (toolStripAdornerWindowService != null && toolStripAdornerWindowService.DropDownAdorner.Glyphs.Contains(bodyGlyph))
{
toolStripAdornerWindowService.DropDownAdorner.Glyphs.Remove(bodyGlyph);
}
}
// Remove the Collection
if (toolStripItemCustomMenuItemCollection != null && toolStripItemCustomMenuItemCollection.Count > 0)
{
foreach (ToolStripItem item in toolStripItemCustomMenuItemCollection)
{
item.Dispose();
}
toolStripItemCustomMenuItemCollection.Clear();
}
toolStripItemCustomMenuItemCollection = null;
}
base.Dispose(disposing);
}
///
/// Returns the owner of the current ToolStripItem.
///
protected virtual Component GetOwnerForActionList()
{
return (ToolStripItem.Placement == ToolStripItemPlacement.Main) ? ToolStripItem.GetCurrentParent() : ToolStripItem.Owner;
}
internal virtual ToolStrip GetMainToolStrip()
{
return ToolStripItem.Owner;
}
public Rectangle GetGlyphBounds()
{
BehaviorService b = (BehaviorService)GetService(typeof(BehaviorService));
Rectangle r = Rectangle.Empty;
if (b != null && ImmediateParent != null)
{
Point loc = b.ControlToAdornerWindow((Control)ImmediateParent);
r = ToolStripItem.Bounds;
r.Offset(loc);
}
return r;
}
// Need to Fire ComponentChanging on all the DropDownItems. Please see "MorphToolStripItem" function for more details.
private void FireComponentChanging(ToolStripDropDownItem parent)
{
if (parent != null)
{
IComponentChangeService changeSvc = (IComponentChangeService)GetService(typeof(IComponentChangeService));
if (changeSvc != null && parent.Site != null)
{
changeSvc.OnComponentChanging(parent, TypeDescriptor.GetProperties(parent)["DropDownItems"]);
}
foreach (ToolStripItem item in parent.DropDownItems)
{
ToolStripDropDownItem dropDownItem = item as ToolStripDropDownItem;
//Dont Serialize the DesignerToolStripControlHost...
if (dropDownItem != null && dropDownItem.DropDownItems.Count > 1 /*including TN*/)
{
FireComponentChanging(dropDownItem);
}
}
}
}
private void FireComponentChanged(ToolStripDropDownItem parent)
{
if (parent != null)
{
IComponentChangeService changeSvc = (IComponentChangeService)GetService(typeof(IComponentChangeService));
if (changeSvc != null && parent.Site != null)
{
changeSvc.OnComponentChanged(parent, TypeDescriptor.GetProperties(parent)["DropDownItems"], null, null);
}
foreach (ToolStripItem item in parent.DropDownItems)
{
ToolStripDropDownItem dropDownItem = item as ToolStripDropDownItem;
//Dont Serialize the DesignerToolStripControlHost...
if (dropDownItem != null && dropDownItem.DropDownItems.Count > 1 /*including TN*/)
{
FireComponentChanged(dropDownItem);
}
}
}
}
public void GetGlyphs(ref GlyphCollection glyphs, System.Windows.Forms.Design.Behavior.Behavior standardBehavior)
{
if (ImmediateParent != null)
{
Rectangle r = GetGlyphBounds();
ToolStripDesignerUtils.GetAdjustedBounds(ToolStripItem, ref r);
BehaviorService b = (BehaviorService)GetService(typeof(BehaviorService));
Rectangle parentBounds = b.ControlRectInAdornerWindow((Control)ImmediateParent);
if (parentBounds.Contains(r.Left, r.Top))
{
// Dont paint the glyphs if we are opening a DropDown...
if (ToolStripItem.IsOnDropDown)
{
ToolStrip parent = ToolStripItem.GetCurrentParent();
if (parent == null)
{
parent = ToolStripItem.Owner;
}
if (parent != null && parent.Visible)
{
glyphs.Add(new MiniLockedBorderGlyph(r, SelectionBorderGlyphType.Top, standardBehavior, true));
glyphs.Add(new MiniLockedBorderGlyph(r, SelectionBorderGlyphType.Bottom, standardBehavior, true));
glyphs.Add(new MiniLockedBorderGlyph(r, SelectionBorderGlyphType.Left, standardBehavior, true));
glyphs.Add(new MiniLockedBorderGlyph(r, SelectionBorderGlyphType.Right, standardBehavior, true));
}
}
else
{
glyphs.Add(new MiniLockedBorderGlyph(r, SelectionBorderGlyphType.Top, standardBehavior, true));
glyphs.Add(new MiniLockedBorderGlyph(r, SelectionBorderGlyphType.Bottom, standardBehavior, true));
glyphs.Add(new MiniLockedBorderGlyph(r, SelectionBorderGlyphType.Left, standardBehavior, true));
glyphs.Add(new MiniLockedBorderGlyph(r, SelectionBorderGlyphType.Right, standardBehavior, true));
}
}
}
}
///
/// Returns the root dropdown in the chain.
///
internal ToolStripDropDown GetFirstDropDown(ToolStripItem currentItem)
{
if (currentItem.Owner is ToolStripDropDown)
{
ToolStripDropDown topmost = currentItem.Owner as ToolStripDropDown;
// walk back up the chain of windows to get the topmost
while (topmost.OwnerItem != null && (topmost.OwnerItem.Owner is ToolStripDropDown))
{
topmost = topmost.OwnerItem.Owner as ToolStripDropDown;
}
return topmost;
}
return null;
}
///
/// This helper function resets the AutoSize property so that
/// the item SNAPS back to its "preferredSize".
///
///
/// Get the designer set up to run.
///
public override void Initialize(IComponent component)
{
base.Initialize(component);
//Shadow AutoSize
AutoSize = ToolStripItem.AutoSize;
Visible = true;
currentVisible = Visible;
//Shadow the AccessibleName as we are going to change it at DesignTime
AccessibleName = ToolStripItem.AccessibleName;
ToolStripItem.Paint += new System.Windows.Forms.PaintEventHandler(OnItemPaint);
//Change the AccessibleName to point to ToolStirpItem.Name
ToolStripItem.AccessibleName = ToolStripItem.Name;
// Now, hook the component rename event so we can update the AccessibleName
//
IComponentChangeService cs = (IComponentChangeService)GetService(typeof(IComponentChangeService));
if (cs != null)
{
cs.ComponentRename += new ComponentRenameEventHandler(this.OnComponentRename);
}
//hook our SelectionService.
selSvc = (ISelectionService)GetService(typeof(ISelectionService));
if (selSvc != null)
{
selSvc.SelectionChanged += new EventHandler(this.OnSelectionChanged);
}
}
///
/// Overriden to always Initialise the ToolStripItem with Text property.
///
///
/// This will morph the current item to the provided type "t" of the item...
///
///
/// Raised when a component's name changes. Here we update the AccessibleName Property to match the newName.
///
private void OnComponentRename(object sender, ComponentRenameEventArgs e)
{
if (e.Component == ToolStripItem)
{
ToolStripItem.AccessibleName = e.NewName;
}
}
///
/// This can be used for OVERFLOW !!!
///
///
/// For ToolStripItems that are not MenuItems and are on Dropdown we need ot update Selection Rect.
///
private void OnSelectionChanged(object sender, EventArgs e)
{
ISelectionService sSvc = sender as ISelectionService;
if (sSvc == null)
{
return;
}
//determine if we are selected
ToolStripItem currentSelection = sSvc.PrimarySelection as ToolStripItem;
ToolStripItem.ToolStripItemAccessibleObject acc = ToolStripItem.AccessibilityObject as ToolStripItem.ToolStripItemAccessibleObject;
// Accessibility information
//
if (acc != null)
{
acc.AddState(AccessibleStates.None);
ToolStrip tool = GetMainToolStrip();
if (sSvc.GetComponentSelected(ToolStripItem)) {
ToolStrip owner = ImmediateParent as ToolStrip;
int focusIndex = 0;
if (owner != null)
{
focusIndex = owner.Items.IndexOf(currentSelection);
}
acc.AddState(AccessibleStates.Selected);
if (tool != null) {
Debug.WriteLineIf(CompModSwitches.MSAA.TraceInfo, "MSAA: SelectionAdd, tool = " + tool.ToString());
UnsafeNativeMethods.NotifyWinEvent((int)AccessibleEvents.SelectionAdd, new HandleRef(owner, owner.Handle), NativeMethods.OBJID_CLIENT, focusIndex + 1);
}
if (currentSelection == ToolStripItem) {
acc.AddState(AccessibleStates.Focused);
if (tool != null) {
UnsafeNativeMethods.NotifyWinEvent((int)AccessibleEvents.Focus, new HandleRef(owner, owner.Handle), NativeMethods.OBJID_CLIENT, focusIndex + 1);
}
}
}
}
if (currentSelection != null)
{
if ((ToolStripItem != null) && (currentSelection.IsOnDropDown))
{
if (ToolStripItem.Equals(currentSelection) && !(ToolStripItem is ToolStripMenuItem))
{
//If the Item is on DropDown ... Show its DropDown and all PArent Dropdown if not visible..
IDesignerHost designerHost = (IDesignerHost)GetService(typeof(IDesignerHost));
if (designerHost != null)
{
ToolStripDropDown parentDropDown = currentSelection.Owner as ToolStripDropDown;
if (parentDropDown != null && !parentDropDown.Visible)
{
ToolStripDropDownItem parentItem = parentDropDown.OwnerItem as ToolStripDropDownItem;
if (parentItem != null)
{
ToolStripMenuItemDesigner parentItemDesigner = (ToolStripMenuItemDesigner)designerHost.GetDesigner(parentItem);
if (parentItemDesigner != null)
{
parentItemDesigner.InitializeDropDown();
}
// Refresh on SelectionManager... To Change Glyph Size.
SelectionManager selMgr = (SelectionManager)GetService(typeof(SelectionManager));
// used the cached value...
if (selMgr != null)
{
selMgr.Refresh();
}
}
}
}
}
}
}
}
///
/// Allows a designer to filter the set of properties
/// the component it is designing will expose through the
/// TypeDescriptor object. This method is called
/// immediately before its corresponding "Post" method.
/// If you are overriding this method you should call
/// the base implementation before you perform your own
/// filtering.
///
protected override void PreFilterProperties(IDictionary properties)
{
base.PreFilterProperties(properties);
// Handle shadowed properties
//
string[] shadowProps = new string[] {
"AutoSize",
"AccessibleName",
"Visible",
"Overflow"
};
PropertyDescriptor prop;
Attribute[] empty = new Attribute[0];
for (int i = 0; i < shadowProps.Length; i++)
{
prop = (PropertyDescriptor)properties[shadowProps[i]];
if (prop != null)
{
properties[shadowProps[i]] = TypeDescriptor.CreateProperty(typeof(ToolStripItemDesigner), prop, empty);
}
}
}
// CALLED ONLY IF THE EDIT ACTION WAS ROLLBACKED!!!
public void RemoveItem()
{
dummyItemAdded = false;
IDesignerHost host = (IDesignerHost)GetService(typeof(IDesignerHost));
if (host == null)
{
Debug.Fail("Couldn't get designer host!");
return;
}
//Remove the dummy Item since the Edit was CANCELLED..
ToolStrip parent = (ToolStrip)ImmediateParent;
if (parent is ToolStripOverflow)
{
parent = ParentComponent as ToolStrip;
}
parent.Items.Remove(ToolStripItem);
host.DestroyComponent(ToolStripItem);
}
//
// Resets the ToolStripItemAutoSize to be the default autosize
//
// Restores the AutoSize to be the value set in the property grid.
//
// Resets the ToolStrip Visible to be the default value
//
// Restore Overflow
//
// Resets Overflow
//
// Resets the ToolStripItem AccessibleName to the default
//
// Restores the AutoSize to be the value set in the property grid.
//
// Since we're shadowing autosize, we get called here to determine whether or not to serialize
//
// Since we're shadowing autosize, we get called here to determine whether or not to serialize
//
// Since we're Overflow Size, we get called here to determine whether or not to serialize
//
/// This Function is called thru the ToolStripEditorManager which is listening for the
/// F2 command.
///
///
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- DefaultAssemblyResolver.cs
- GridErrorDlg.cs
- Errors.cs
- VisualStyleRenderer.cs
- AnimationLayer.cs
- PartitionResolver.cs
- UDPClient.cs
- BatchServiceHost.cs
- AutomationPatternInfo.cs
- ACL.cs
- DictionaryManager.cs
- ImportedNamespaceContextItem.cs
- WorkflowEventArgs.cs
- ExceptionUtil.cs
- Pair.cs
- CodeTypeReferenceCollection.cs
- ObjectReferenceStack.cs
- MbpInfo.cs
- MapPathBasedVirtualPathProvider.cs
- CollectionConverter.cs
- SystemBrushes.cs
- SizeFConverter.cs
- Point3DAnimationBase.cs
- TextTreeFixupNode.cs
- AnimationLayer.cs
- ConfigurationPropertyCollection.cs
- ZipIOExtraFieldZip64Element.cs
- ImageClickEventArgs.cs
- ExpressionConverter.cs
- MetadataHelper.cs
- SystemIPv4InterfaceProperties.cs
- QuaternionAnimation.cs
- DataGridPageChangedEventArgs.cs
- DescendantOverDescendantQuery.cs
- DelegatingConfigHost.cs
- DocumentGridContextMenu.cs
- ChannelCacheDefaults.cs
- CodeTypeParameterCollection.cs
- Util.cs
- DataSourceXmlClassAttribute.cs
- MergablePropertyAttribute.cs
- PrimitiveXmlSerializers.cs
- ToolBarTray.cs
- ManagedIStream.cs
- TemplatingOptionsDialog.cs
- XsdCachingReader.cs
- NonParentingControl.cs
- PhysicalFontFamily.cs
- Margins.cs
- HttpServerChannel.cs
- CodeArrayIndexerExpression.cs
- processwaithandle.cs
- IdnMapping.cs
- EntityProviderFactory.cs
- XmlCharCheckingWriter.cs
- RuntimeWrappedException.cs
- CollectionContainer.cs
- GlyphCollection.cs
- SByteStorage.cs
- ColorPalette.cs
- RelationshipNavigation.cs
- ArrangedElementCollection.cs
- CollectionBuilder.cs
- ExpressionParser.cs
- TimeStampChecker.cs
- RepeaterItemEventArgs.cs
- TableLayout.cs
- CapabilitiesAssignment.cs
- Wildcard.cs
- MetaType.cs
- ExpressionBuilderCollection.cs
- CryptoConfig.cs
- MachineSettingsSection.cs
- HtmlInputRadioButton.cs
- WebPartConnectionsDisconnectVerb.cs
- BoolExpression.cs
- NameValueConfigurationCollection.cs
- WebControlsSection.cs
- OdbcPermission.cs
- XPathSelectionIterator.cs
- MediaScriptCommandRoutedEventArgs.cs
- ElapsedEventArgs.cs
- NetworkAddressChange.cs
- SQLDateTimeStorage.cs
- EndOfStreamException.cs
- PlaceHolder.cs
- MenuItemCollectionEditor.cs
- RequestQueue.cs
- WrappedReader.cs
- SecurityCapabilities.cs
- _SecureChannel.cs
- SystemIcmpV4Statistics.cs
- ScrollChrome.cs
- DetailsViewPagerRow.cs
- WindowsScroll.cs
- XamlVector3DCollectionSerializer.cs
- CodeTypeOfExpression.cs
- IdentityValidationException.cs
- GeometryModel3D.cs
- StickyNoteAnnotations.cs