protected override void ExecuteCore(ConfigurationNode node)
{
TypeSelectorUI selector = new TypeSelectorUI(
typeof(RijndaelManaged),
typeof(SymmetricAlgorithm),
TypeSelectorIncludeFlags.Default
);
DialogResult typeResult = selector.ShowDialog();
if (typeResult == DialogResult.OK)
{
KeySettings keySettings = new KeySettings(new SymmetricAlgorithmKeyCreator(selector.SelectedType.AssemblyQualifiedName));
KeyManagerEditorUI keyManager = new KeyManagerEditorUI(keySettings);
DialogResult keyResult = keyManager.ShowDialog();
if (keyResult == DialogResult.OK)
{
INodeNameCreationService service = GetService(typeof(INodeNameCreationService)) as INodeNameCreationService;
Debug.Assert(service != null, "Could not find the INodeNameCreationService");
base.ExecuteCore(node);
SymmetricAlgorithmProviderNode providerNode = (SymmetricAlgorithmProviderNode)ChildNode;
providerNode.AlgorithmType = selector.SelectedType.AssemblyQualifiedName;
providerNode.Name = service.GetUniqueDisplayName(providerNode.Parent, selector.SelectedType.Name);
providerNode.Key = keyManager.KeySettings;
}
}
}
private bool TryAndSaveApplication(ConfigurationNode node)
{
SaveApplicationConfigurationNodeCommand cmd = new SaveApplicationConfigurationNodeCommand(ServiceProvider);
cmd.Execute(node);
return(cmd.SaveSucceeded);
}
/// <summary>
/// <para>Closes the application configuration.</para>
/// </summary>
/// <param name="node">
/// <para>The node to execute the command upon.</para>
/// </param>
protected override void ExecuteCore(ConfigurationNode node)
{
try
{
UIService.BeginUpdate();
if (UIService.IsDirty(node.Hierarchy))
{
DialogResult result = UIService.ShowMessage(SR.SaveApplicationRequest, SR.SaveApplicationCaption, MessageBoxButtons.YesNo);
if (DialogResult.Yes == result)
{
if (!TryAndSaveApplication(node))
{
return;
}
}
}
if (ConfigurationErrorLogService.ConfigurationErrors.Count > 0)
{
UIService.DisplayErrorLog(ConfigurationErrorLogService);
DialogResult result = UIService.ShowMessage(SR.SaveApplicationErrorRequestMessage, SR.SaveApplicationCaption, MessageBoxButtons.YesNo);
if (result == DialogResult.No)
{
return;
}
}
UIHierarchyService.RemoveHierarchy(node.Hierarchy.Id);
}
finally
{
UIService.EndUpdate();
}
}
/// <summary>
/// Executes the moving the node after it's sibling.
/// </summary>
/// <param name="node">
/// The node to execute the command upon.
/// </param>
protected override void ExecuteCore(ConfigurationNode node)
{
if (node.NextSibling != null)
{
node.Parent.MoveAfter(node, node.NextSibling);
}
}
/// <summary>
/// <para>Creates an instance of the child node class and adds it as a child of the parent node. The node will be a <see cref="SymmetricAlgorithmProviderNode"/>.</para>
/// </summary>
/// <param name="node">
/// <para>The parent node to add the newly created <see cref="AddChildNodeCommand.ChildNode"/>.</para>
/// </param>
protected override void ExecuteCore(ConfigurationNode node)
{
TypeSelectorUI selector = new TypeSelectorUI(
typeof(RijndaelManaged),
typeof(SymmetricAlgorithm),
TypeSelectorIncludes.None
);
DialogResult typeResult = selector.ShowDialog();
if (typeResult == DialogResult.OK)
{
Type algorithmType = selector.SelectedType;
CryptographicKeyWizard keyManager = new CryptographicKeyWizard(new SymmetricAlgorithmKeyCreator(algorithmType));
DialogResult keyResult = keyManager.ShowDialog();
if (keyResult == DialogResult.OK)
{
INodeNameCreationService service = ServiceHelper.GetNameCreationService(ServiceProvider);
Debug.Assert(service != null, "Could not find the INodeNameCreationService");
base.ExecuteCore(node);
SymmetricAlgorithmProviderNode providerNode = (SymmetricAlgorithmProviderNode)ChildNode;
providerNode.AlgorithmType = selector.SelectedType;
providerNode.Name = service.GetUniqueName(selector.SelectedType.Name, providerNode, providerNode.Parent);
providerNode.Key = keyManager.KeySettings;
}
}
}
/// <summary>
/// Executes the moving the node before it's sibling.
/// </summary>
/// <param name="node">
/// The node to execute the command upon.
/// </param>
protected override void ExecuteCore(ConfigurationNode node)
{
if (node.PreviousSibling != null)
{
node.Parent.MoveBefore(node, node.PreviousSibling);
}
}
private void AddXmlIncludeTypes(ConfigurationNode node)
{
using (AddXmlIncludeTypesCommand includeTypesCommand = new AddXmlIncludeTypesCommand(ServiceProvider, false, childNode.GetType()))
{
includeTypesCommand.Execute(node);
}
}
/// <summary>
/// Closes the application configuration.
/// </summary>
/// <param name="node">
/// The node to execute the command upon.
/// </param>
protected override void ExecuteCore(ConfigurationNode node)
{
try
{
UIService.BeginUpdate();
if (UIService.IsDirty(node.Hierarchy))
{
DialogResult result = UIService.ShowMessage(Resources.SaveApplicationRequest, Resources.SaveApplicationCaption, MessageBoxButtons.YesNo);
if (DialogResult.Yes == result)
{
if (!TryAndSaveApplication(node))
{
return;
}
}
}
if (ErrorLogService.ConfigurationErrorCount > 0)
{
UIService.DisplayErrorLog(ErrorLogService);
DialogResult result = UIService.ShowMessage(Resources.SaveApplicationErrorRequestMessage, Resources.SaveApplicationCaption, MessageBoxButtons.YesNo);
if (result == DialogResult.No) return;
}
ConfigurationUIHierarchyService.RemoveHierarchy(node.Hierarchy.Id);
}
finally
{
UIService.EndUpdate();
}
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
protected override void ExecuteCore(ConfigurationNode node)
{
base.ExecuteCore(node);
RuleNode ruleNode = ChildNode as RuleNode;
if (ruleNode == null) return;
}
/// <summary>
/// Creates the commands and adds them to the <see cref="IStorageService"/>.
/// </summary>
/// <param name="node">The node to execute the command upon.</param>
protected override void ExecuteCore(ConfigurationNode node)
{
// clear out the service first since we are going to refill it
IStorageService storageService = ServiceHelper.GetCurrentStorageService(ServiceProvider);
storageService.Clear();
CreateCommands(node);
}
protected override void ExecuteCore(ConfigurationNode node)
{
TypeSelectorUI selector = new TypeSelectorUI(
typeof(Exception),
typeof(Exception),
TypeSelectorIncludeFlags.BaseType |
TypeSelectorIncludeFlags.AbstractTypes);
DialogResult result = selector.ShowDialog();
if (result == DialogResult.OK)
{
base.ExecuteCore(node);
ExceptionTypeNode typeNode = (ExceptionTypeNode) ChildNode;
typeNode.TypeName = selector.SelectedType.AssemblyQualifiedName;
typeNode.PostHandlingAction = PostHandlingAction.NotifyRethrow;
try
{
typeNode.Name = selector.SelectedType.Name;
}
catch (InvalidOperationException)
{
typeNode.Remove();
UIService.ShowError(SR.DuplicateExceptionTypeErrorMessage(selector.SelectedType.Name));
}
}
}
private void CreateCommands(ConfigurationNode node)
{
Type t = node.GetType();
PropertyInfo[] properties = t.GetProperties(BindingFlags.Public | BindingFlags.Instance);
CreateCommandsOnNode(node, properties);
CreateCommandsOnChildNodeProperties(node);
}
/// <summary>
/// Executes the moving the node before it's sibling.
/// </summary>
/// <param name="node">
/// The node to execute the command upon.
/// </param>
protected override void ExecuteCore(ConfigurationNode node)
{
if (node.PreviousSibling != null)
{
node.Parent.MoveBefore(node, node.PreviousSibling);
}
}
/// <summary>
/// Edits the value of the specified object using the editor style indicated by <seealso cref="UITypeEditor.GetEditStyle(ITypeDescriptorContext)"/>.
/// </summary>
/// <param name="context">An <see cref="ITypeDescriptorContext"/> that can be used to gain additional context information. </param>
/// <param name="provider">An <see cref="IServiceProvider"/> that this editor can use to obtain services.</param>
/// <param name="value">The object to edit.</param>
/// <returns>The new value of the object.</returns>
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
if (null == context)
{
return(null);
}
if (null == provider)
{
return(null);
}
IWindowsFormsEditorService service = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
if (service != null)
{
ReferenceTypeAttribute refTypeAttribute = GetReferenceType(context);
ConfigurationNode currentNode = (ConfigurationNode)context.Instance;
ConfigurationApplicationNode appNode = GetApplicationNode(currentNode);
ConfigurationNode contextNode = (refTypeAttribute.LocalOnly) ? currentNode : appNode;
ReferenceEditorUI control = new ReferenceEditorUI(contextNode, refTypeAttribute.ReferenceType, (ConfigurationNode)value, service, IsRequired(context));
service.DropDownControl(control);
if (control.SelectedNode != null)
{
Type propertyType = context.PropertyDescriptor.PropertyType;
Type selectedNodeType = control.SelectedNode.GetType();
if (propertyType == selectedNodeType || selectedNodeType.IsSubclassOf(propertyType))
{
return(control.SelectedNode);
}
}
}
return(null);
}
private void CreateCommandsOnChildNodeProperties(ConfigurationNode node)
{
foreach (ConfigurationNode childNode in node.Nodes)
{
CreateCommands(childNode);
}
}
/// <summary>
/// Executes the moving the node after it's sibling.
/// </summary>
/// <param name="node">
/// The node to execute the command upon.
/// </param>
protected override void ExecuteCore(ConfigurationNode node)
{
if (node.NextSibling != null)
{
node.Parent.MoveAfter(node, node.NextSibling);
}
}
protected override void ExecuteCore(ConfigurationNode node)
{
ConfigurationSectionCollectionNode configurationSectionCollectionNode = node.Hierarchy.FindNodeByType(typeof(ConfigurationSectionCollectionNode)) as ConfigurationSectionCollectionNode;
if (configurationSectionCollectionNode == null) return;
IXmlIncludeTypeService service = GetService(typeof(IXmlIncludeTypeService)) as IXmlIncludeTypeService;
Type[] types = null;
XmlSerializerTransformerNode transformerNode = null;
foreach (ConfigurationNode configurationNode in configurationSectionCollectionNode.Nodes)
{
transformerNode = node.Hierarchy.FindNodeByType(configurationNode, typeof(XmlSerializerTransformerNode)) as XmlSerializerTransformerNode;
if (transformerNode == null) continue;
types = service.GetXmlIncludeTypes(configurationNode.Name);
if (types == null) continue;
foreach (Type t in types)
{
INodeCreationService nodeCreationService = (INodeCreationService)GetService(typeof(INodeCreationService));
if (!nodeCreationService.DoesNodeTypeMatchDataType(nodeType, t)) continue;
if (node.Hierarchy.FindNodeByName(transformerNode, t.Name) == null)
{
transformerNode.Nodes.Add(new XmlIncludeTypeNode(new XmlIncludeTypeData(t.Name, t.AssemblyQualifiedName)));
}
}
}
}
/// <summary>
/// <para>Opens the configuration settings and registers them with the application.</para>
/// </summary>
/// <param name="serviceProvider">
/// <para>The a mechanism for retrieving a service object; that is, an object that provides custom support to other objects.</para>
/// </param>
public void Open(IServiceProvider serviceProvider)
{
ConfigurationContext configurationContext = ServiceHelper.GetCurrentConfigurationContext(serviceProvider);
ConfigurationSectionCollectionNode sectionsNode = null;
ConfigurationNode configurationNode = ServiceHelper.GetCurrentRootNode(serviceProvider);
RemoveCurrentConfigurationSectionCollectionNode(serviceProvider);
try
{
string appName = SR.DefaultApplicationName;
ConfigurationSettings configurationSettings = configurationContext.GetMetaConfiguration();
if (null != configurationSettings)
{
appName = configurationSettings.ApplicationName;
if (configurationSettings.ConfigurationSections.Count > 0)
{
sectionsNode = new ConfigurationSectionCollectionNode(configurationSettings);
configurationNode.Nodes.Add(sectionsNode);
}
}
if (configurationNode is ApplicationConfigurationNode)
{
((ApplicationConfigurationNode)configurationNode).Name = appName;
}
}
catch (ConfigurationException e)
{
ServiceHelper.LogError(serviceProvider, sectionsNode, e);
}
}
/// <summary>
/// Saves the application configuration.
/// </summary>
/// <param name="node">
/// The node to execute the command upon.
/// </param>
protected override void ExecuteCore(ConfigurationNode node)
{
if (!DoValidationCommand())
{
return;
}
DoApplicationSave();
}
internal void UpdateHierarchy(ConfigurationNode configurationNode)
{
if (hierarchy != null)
{
hierarchy.AddNode(configurationNode);
UpdateHierarchyRecursive(hierarchy, configurationNode);
}
}
/// <summary>
/// <para>Initializes a new instance of the <see cref="ConfigurationNodeChangedEventArgs"/> class with an action, the node it was performed upon, and the parent node.</para>
/// </summary>
/// <param name="action">
/// <para>One of the <see cref="ConfigurationNodeChangedAction"/> values.</para>
/// </param>
/// <param name="node">
/// <para>The <see cref="ConfigurationNode"/> that the action occured upon.</para>
/// </param>
/// <param name="parent"><para>The parent node of the <paramref name="node"/>.</para></param>
public ConfigurationNodeChangedEventArgs(ConfigurationNodeChangedAction action,
ConfigurationNode node,
ConfigurationNode parent)
{
this.action = action;
this.node = node;
this.parent = parent;
}
/// <summary>
/// Adds the <see cref="LoggingSettingsNode"/> and adds the default nodes.
/// </summary>
/// <param name="node">The <see cref="LoggingSettingsNode"/> added.</param>
protected override void ExecuteCore(ConfigurationNode node)
{
base.ExecuteCore(node);
ApplicationBlockSettingsNode blockSettingsNode = ChildNode as ApplicationBlockSettingsNode;
if (blockSettingsNode == null) return;
// TODO: Initialize your initial configuration settings for the MyNewApplicationBlock7 Design Time.
}
/// <summary>
/// After the <see cref="SecuritySettingsNode"/> is added, adds the default nodes.
/// </summary>
/// <param name="node">The <see cref="SecuritySettingsNode"/>.S</param>
protected override void ExecuteCore(ConfigurationNode node)
{
base.ExecuteCore(node);
SecuritySettingsNode securitySettingsNode = (SecuritySettingsNode)ChildNode;
securitySettingsNode.AddNode(new AuthorizationProviderCollectionNode());
securitySettingsNode.AddNode(new SecurityCacheProviderCollectionNode());
}
/// <summary>
/// <para>Adds a previously created node to the end of the collection and adds any default.</para>
/// </summary>
/// <param name="node"><para>The <see cref="ConfigurationNode"/> to add to the collection.</para></param>
/// <returns><para>The zero-based index value of the <see cref="ConfigurationNode"/> added to the tree node collection.</para></returns>
/// <exception cref="ArgumentNullException">
/// <para><paramref name="node"/> is a <see langword="null"/> reference (Nothing in Visual Basic).</para>
/// </exception>
public int AddWithDefaultChildren(ConfigurationNode node)
{
if (node == null)
{
throw new ArgumentNullException("node");
}
return(owner.AddNodeWithDefaultChildren(node));
}
private void Validate(ConfigurationNode node, ValidationErrorCollection errors)
{
Type t = node.GetType();
PropertyInfo[] properties = t.GetProperties(BindingFlags.Public | BindingFlags.Instance);
ValidateProperties(node, properties, errors);
ValidateChildNodeProperties(node, errors);
}
private void CreateCommands(ConfigurationNode node)
{
Type t = node.GetType();
PropertyInfo[] properties = t.GetProperties(BindingFlags.Public | BindingFlags.Instance);
CreateCommandsOnNode(node, properties);
CreateCommandsOnChildNodeProperties(node);
}
/// <summary>
/// Saves the application configuration.
/// </summary>
/// <param name="node">
/// The node to execute the command upon.
/// </param>
protected override void ExecuteCore(ConfigurationNode node)
{
if (!DoValidationCommand())
{
return;
}
DoApplicationSave();
}
/// <summary>
/// <para>Initializes a new instance of the <see cref="ConfigurationNodeChangedEventArgs"/> class with an action, the node it was performed upon, and the parent node.</para>
/// </summary>
/// <param name="action">
/// <para>One of the <see cref="ConfigurationNodeChangedAction"/> values.</para>
/// </param>
/// <param name="node">
/// <para>The <see cref="ConfigurationNode"/> that the action occured upon.</para>
/// </param>
/// <param name="parent"><para>The parent node of the <paramref name="node"/>.</para></param>
public ConfigurationNodeChangedEventArgs(ConfigurationNodeChangedAction action,
ConfigurationNode node,
ConfigurationNode parent)
{
this.action = action;
this.node = node;
this.parent = parent;
}
/// <summary>
/// Creates the commands and adds them to the <see cref="IStorageService"/>.
/// </summary>
/// <param name="node">The node to execute the command upon.</param>
protected override void ExecuteCore(ConfigurationNode node)
{
// clear out the service first since we are going to refill it
IStorageService storageService = ServiceHelper.GetCurrentStorageService(ServiceProvider);
storageService.Clear();
CreateCommands(node);
}
/// <summary>
/// <para>Adds a previously created node to the end of the collection.</para>
/// </summary>
/// <param name="node"><para>The <see cref="ConfigurationNode"/> to add to the collection.</para></param>
/// <returns><para>The zero-based index value of the <see cref="ConfigurationNode"/> added to the tree node collection.</para></returns>
/// <exception cref="ArgumentNullException">
/// <para><paramref name="node"/> is a <see langword="null"/> reference (Nothing in Visual Basic).</para>
/// </exception>
/// <see cref="IList.Add"/>
public int Add(ConfigurationNode node)
{
if (node == null)
{
throw new ArgumentNullException("node");
}
return(owner.AddNode(node));
}
public void RemoveNode(ConfigurationNode configurationNode)
{
if (null == configurationNode)
{
throw new ArgumentNullException("configurationNode");
}
configurationNode.RemoveThisNode(ParentNodeNotification.Notify);
}
/// <summary>
/// Shows an dialog that allows the user to export an cryptographic key.
/// </summary>
/// <param name="node">
/// The <see cref="ConfigurationNode"/> of which an cryptographic key should be exported.
/// </param>
protected override void ExecuteCore(ConfigurationNode node)
{
ICryptographicKeyConfigurationNode cryptographicNode = node as ICryptographicKeyConfigurationNode;
if (cryptographicNode != null)
{
ExportKeyUI exportKeyDialog = new ExportKeyUI(cryptographicNode.KeySettings.ProtectedKey);
exportKeyDialog.ShowDialog();
}
}
/// <summary>
/// Load an error when creating a node.
/// </summary>
/// <param name="node">The node where the error occurred.</param>
/// <param name="configType">The type trying to be created.</param>
protected void LogNodeMapError(ConfigurationNode node, MemberInfo configType)
{
if (null == configType)
{
throw new ArgumentNullException("configType");
}
LogError(node, string.Format(CultureInfo.CurrentUICulture, Resources.ExceptionNodeMapNotRegistered, configType.Name));
}
public ReferenceEditorUI(ConfigurationNode rootNode, Type referenceType, ConfigurationNode currentReference, IWindowsFormsEditorService service, bool isRequired) : this()
{
this.rootNode = rootNode;
this.referenceType = referenceType;
this.currentNode = currentReference;
this.service = service;
this.isRequired = isRequired;
DisplayList();
}
/// <summary>
/// <para>Creates an instance of the child node class and adds it as a child of the parent node. The node will be a <see cref="RuleSetNode"/>.</para>
/// </summary>
/// <param name="node">
/// <para>The parent node to add the newly created <see cref="RuleSetNode"/>.</para>
/// </param>
protected override void ExecuteCore(ConfigurationNode node)
{
base.ExecuteCore(node);
RuleSetNode ruleNode = ChildNode as RuleSetNode;
if (ruleNode == null) return;
ruleNode.AddNode(new SelfNode());
}
/// <summary>
/// Compares the specified node to the current node based on the value of the <seealso cref="Name"/> property.
/// </summary>
/// <param name="obj">An object to compare.></param>
/// <returns>
/// A signed integer that indicates the relative order of this node and the node being compared.
/// </returns>
int IComparable.CompareTo(object obj)
{
ConfigurationNode compareNode = obj as ConfigurationNode;
if (compareNode == null)
{
return -1;
}
return id.CompareTo(compareNode.Id);
}
/// <summary>
/// Gets the command state of the node.
/// </summary>
/// <param name="node">The node used to get the command state.</param>
/// <returns>One of the <see cref="CommandState"/> values.</returns>
/// <remarks>
/// If the node is the last node in the list, the command state will be <see cref="CommandState.Disabled"/>.
/// </remarks>
public override CommandState GetCommandState(ConfigurationNode node)
{
if (null == node)
{
throw new ArgumentNullException("node");
}
return(node.NextSibling != null ? CommandState.Enabled : CommandState.Disabled);
}
/// <summary>
/// <para>Finds nodes by their <see cref="Type"/>.</para>
/// </summary>
/// <param name="parent">
/// <para>The parent to start the search.</para>
/// </param>
/// <param name="type">
/// <para>The <see cref="Type"/> of the node.</para>
/// </param>
/// <returns>
/// <para>The node if found or <see langword="null"/> if not found.</para>
/// </returns>
/// <remarks>
/// <para>If this is more than one type in the hierachy, this function will only find the first one found.</para>
/// </remarks>
public ConfigurationNode FindNodeByType(ConfigurationNode parent, Type type)
{
ConfigurationNode[] nodes = FindNodesByType(parent, type);
if (nodes.Length > 0)
{
return(nodes[0]);
}
return(null);
}
/// <summary>
/// <para>Initialize a new instance of the <see cref="MoveNodeAfterCommand"/> class with an <see cref="IServiceProvider"/>, the node to move, and the sibling node to move it after.</para>
/// </summary>
/// <param name="serviceProvider">
/// <para>The a mechanism for retrieving a service object; that is, an object that provides custom support to other objects.</para>
/// </param>
/// <param name="clearErrorLog">
/// <para>Determines if all the messages in the <see cref="IConfigurationErrorLogService"/> should be cleared when the command has executed.</para>
/// </param>
/// <param name="nodeToMove">
/// <para>The node to move.</para>
/// </param>
/// <param name="siblingNode">
/// <para>The sibling node to move <paramref name="nodeToMove"/> after.</para>
/// </param>
public MoveNodeAfterCommand(IServiceProvider serviceProvider, bool clearErrorLog, ConfigurationNode nodeToMove, ConfigurationNode siblingNode)
: base(serviceProvider, clearErrorLog)
{
if (nodeToMove == null) throw new ArgumentNullException("nodeToMove");
if (siblingNode == null) throw new ArgumentNullException("siblingNode");
this.nodeToMove = nodeToMove;
this.siblingNode = siblingNode;
}
/// <summary>
/// Log an error to the <see cref="IErrorLogService"/>.
/// </summary>
/// <param name="serviceProvider">
/// The a mechanism for retrieving a service object; that is, an object that provides custom support to other objects.
/// </param>
/// <param name="node">The configuration node associated with the error.</param>
/// <param name="e">The <see cref="Exception"/> to log.</param>
public static void LogError(IServiceProvider serviceProvider, ConfigurationNode node, Exception e)
{
Exception exception = e;
while (exception != null)
{
LogError(serviceProvider, new ConfigurationError(node, exception.Message));
exception = exception.InnerException;
}
}
public ConfigurationMenuItem(ConfigurationNode node, ConfigurationUICommand command)
{
Debug.Assert(node != null);
this.command = command;
Shortcut = command.Shortcut;
Text = command.Text;
this.node = node;
this.Enabled = (command.GetCommandState(node) == CommandState.Enabled);
}
/// <summary>
/// Finds nodes by their <see cref="Type"/>.
/// </summary>
/// <param name="parent">
/// The parent to start the search.
/// </param>
/// <param name="type">
/// The <see cref="Type"/> of the node.
/// </param>
/// <returns>
/// The node if found or <see langword="null"/> if not found.
/// </returns>
/// <remarks>
/// If this is more than one type in the hierachy, this function will only find the first one found.
/// </remarks>
public ConfigurationNode FindNodeByType(ConfigurationNode parent, Type type)
{
IList <ConfigurationNode> nodes = FindNodesByType(parent, type);
if (nodes.Count > 0)
{
return(nodes[0]);
}
return(null);
}
public UIHierarchy(ConfigurationNode node, IServiceProvider serviceProvider, ConfigurationContext configurationContext) : this(serviceProvider, configurationContext)
{
if (node == null)
{
throw new ArgumentNullException("node");
}
rootNode = node;
selectedNode = node;
AddNode(node);
}
public ValidationErrorListViewItem(ValidationError error) : base()
{
Text = error.InvalidItem.ToString();
this.error = error;
node = error.InvalidItem as ConfigurationNode;
StateImageIndex = 0;
SubItems.Add(error.PropertyName);
SubItems.Add(error.Message);
SubItems.Add(node.Path);
}
/// <summary>
/// <para>Finds nodes by their <seealso cref="ConfigurationNode.Name"/>.</para>
/// </summary>
/// <param name="parent">
/// <para>The parent to start the search.</para>
/// </param>
/// <param name="name">
/// <para>The name of the node.</para>
/// </param>
/// <returns>
/// <para>The node if found or <see langword="null"/> if not found.</para>
/// </returns>
public ConfigurationNode FindNodeByName(ConfigurationNode parent, string name)
{
if (!nodesByName.Contains(parent.Id))
{
return(null);
}
Hashtable childs = (Hashtable)nodesByName[parent.Id];
return((ConfigurationNode)childs[name]);
}
private static void AddBaseTypes(ConfigurationNode node, ArrayList tableToAddTypes)
{
Type searchType = node.GetType().BaseType;
while (searchType != null && searchType != typeof(ConfigurationNode))
{
tableToAddTypes.Add(new NodeTypeEntry(node, searchType.FullName));
searchType = searchType.BaseType;
}
}
/// <summary>
/// Log an error to the <see cref="IErrorLogService"/>.
/// </summary>
/// <param name="serviceProvider">
/// The a mechanism for retrieving a service object; that is, an object that provides custom support to other objects.
/// </param>
/// <param name="node">The configuration node associated with the error.</param>
/// <param name="e">The <see cref="Exception"/> to log.</param>
public static void LogError(IServiceProvider serviceProvider, ConfigurationNode node, Exception e)
{
Exception exception = e;
while (exception != null)
{
LogError(serviceProvider, new ConfigurationError(node, exception.Message));
exception = exception.InnerException;
}
}
/// <summary>
/// <para>Compares the specified node to the current node based on the value of the <seealso cref="Name"/> property.</para>
/// </summary>
/// <param name="node"><para>An object to compare.</para></param>
/// <returns>
/// <para>A signed integer that indicates the relative order of this node and the node being compared.</para>
/// </returns>
int IComparable.CompareTo(object node)
{
ConfigurationNode compareNode = node as ConfigurationNode;
if (compareNode == null)
{
return(-1);
}
return(Id.CompareTo(compareNode.Id));
}
public ReferenceEditorUI(ConfigurationNode rootNode, Type referenceType, ConfigurationNode currentReference, IWindowsFormsEditorService service, bool isRequired)
: this()
{
this.rootNode = rootNode;
this.referenceType = referenceType;
this.currentNode = currentReference;
this.service = service;
this.isRequired = isRequired;
DisplayList();
}
/// <summary>
/// Creates an instance of the child node class and adds it as a child of the parent node.
/// </summary>
/// <param name="node">
/// The parent node to add the newly created <see cref="AddChildNodeCommand.ChildNode"/>.
/// </param>
protected override void ExecuteCore(ConfigurationNode node)
{
base.ExecuteCore(node);
EnvironmentNode envNode = ChildNode as EnvironmentNode;
if (envNode != null)
{
envNode.EnvironmentDeltaFile = string.Concat(envNode.Name, Resources.DefaultEnvironmentDeltaFileExtension);
}
}
/// <summary>
/// <para>Creates a <see cref="ConfigurationSectionNode"/> for the parent node.</para>
/// </summary>
/// <param name="node">
/// <para>The parent node to add the newly created <see cref="ConfigurationSectionNode"/>.</para>
/// </param>
protected override void ExecuteCore(ConfigurationNode node)
{
ConfigurationSectionCollectionNode sectionsNode = SelectConfigurationSectionsNode();
ConfigurationSectionNode sectionNode = UIHierarchyService.SelectedHierarchy.FindNodeByName(sectionsNode, sectionName) as ConfigurationSectionNode;
newSectionNode = sectionNode;
if (sectionNode == null)
{
newSectionNode = ConfigurationSectionNode.CreateReadOnlyDefault(sectionName, sectionsNode);
}
base.ExecuteCore(node);
}
public UIHierarchy(ConfigurationNode node, IServiceProvider serviceProvider, ConfigurationContext configurationContext)
: this(serviceProvider, configurationContext)
{
if (node == null)
{
throw new ArgumentNullException("node");
}
rootNode = node;
selectedNode = node;
AddNode(node);
}
private static void RemoveBaseTypes(ConfigurationNode node, NodeTypeEntryArrayList tableToAddTypes)
{
Type searchType = node.GetType().BaseType;
while (searchType != null)
{
NodeTypeEntry entry = new NodeTypeEntry(node, searchType.FullName);
tableToAddTypes.Remove(entry);
searchType = searchType.BaseType;
}
}
private bool CreateMetaDataConfiguration(ConfigurationNode node)
{
MetaDataStorageCreationCommand cmd = new MetaDataStorageCreationCommand(node.Hierarchy.StorageTable.MetaConfigurationFile, ServiceProvider);
cmd.Execute();
if (cmd.CreationCancled)
{
return(false);
}
return(true);
}
/// <summary>
/// <para>Determines the index of a specific node in the collection.</para>
/// </summary>
/// <param name="node"><para>Determines the index of a specific node in the collection.</para></param>
/// <returns><para>The index of the node if found in the list; otherwise, -1.</para></returns>
/// <seealso cref="IList.IndexOf"/>
public int IndexOf(ConfigurationNode node)
{
for (int index = 0; index < Count; ++index)
{
if (this[index].CompareTo(node) == 0)
{
return(index);
}
}
return(-1);
}
/// <summary>
/// <para>Saves the application configuration.</para>
/// </summary>
/// <param name="node">
/// <para>The node to execute the command upon.</para>
/// </param>
protected override void ExecuteCore(ConfigurationNode node)
{
Debug.Assert(node.GetType().Equals(typeof(ApplicationConfigurationNode)));
if (!DoValidationCommand(node))
{
return;
}
if (!DoApplicationSave(node))
{
return;
}
}
/// <summary>
/// Intercepts Command.Execute() and launches a <c>KeyManager</c> prompting the user to manage a key.
/// </summary>
protected override void ExecuteCore(ConfigurationNode node)
{
ExpressionEditorFormUI formUI = new ExpressionEditorFormUI();
formUI.RuleName = SR.AuthorizationRuleNodeName;
DialogResult result = formUI.ShowDialog();
if (result == DialogResult.OK)
{
base.ExecuteCore(node);
AuthorizationRuleNode ruleNode = (AuthorizationRuleNode)ChildNode;
ruleNode.Expression = formUI.Expression;
}
}
protected override void ExecuteCore(ConfigurationNode node)
{
DpapiSettingsEditorUI dpapi = new DpapiSettingsEditorUI();
DialogResult result = dpapi.ShowDialog();
if (result == DialogResult.OK)
{
base.ExecuteCore(node);
DpapiSymmetricCryptoProviderNode cryptoNode = (DpapiSymmetricCryptoProviderNode)ChildNode;
DpapiSettings settings = new DpapiSettings(dpapi.DpapiSettingsData);
cryptoNode.DataProtectionMode = settings;
}
}
/// <devdoc>
/// Get the reference to a ConfigurationNode wiring up the ConfigurationNode.Removed and ConfigurationNode.Renamed events.
/// </devdoc>
public ConfigurationNode CreateReference(ConfigurationNode oldReference, ConfigurationNode newReference, ConfigurationNodeChangedEventHandler referenceRemovedHandler, ConfigurationNodeChangedEventHandler referenceRenamedHandler)
{
ConfigurationNode node = CreateReference(oldReference, newReference, referenceRemovedHandler);
if (node != null && node != oldReference)
{
if (oldReference != null)
{
oldReference.Renamed -= referenceRenamedHandler;
}
node.Renamed += referenceRenamedHandler;
}
return node;
}
/// <summary>
/// Removes the node from the <see cref="IConfigurationUIHierarchy"/>.
/// </summary>
/// <param name="node">
/// The node to execute the command upon.
/// </param>
protected override void ExecuteCore(ConfigurationNode node)
{
try
{
UIService.BeginUpdate();
UIService.SetUIDirty(node.Hierarchy);
node.Remove();
}
finally
{
UIService.EndUpdate();
}
}
