/// <summary> /// Removes the specified configuration from the selected configurations diplayed by this control, optionally attempts to restore the location /// </summary> /// <param name="configuration"></param> /// <param name="keepLocationIfPossible"></param> public void RemoveConfiguration(XmlConfiguration configuration, bool keepLocationIfPossible) { if (this.InvokeRequired) { this.Invoke(new RemoveConfigurationInvoker(this.RemoveConfiguration), new object[] { configuration, keepLocationIfPossible }); return; } try { if (configuration != null) { if (_selectedConfigurations.Contains(configuration)) { string path = null; TreeNode n = _treeView.SelectedNode; if (n != null) { path = n.FullPath; } _selectedConfigurations.Remove(configuration); this.RefreshDisplay(path, keepLocationIfPossible); } } } catch (Exception ex) { Debug.WriteLine(ex); } }
/// <summary> /// Adds the specified configuration to the selected configurations displayed by this control /// </summary> /// <param name="configuration"></param> public void AddConfiguration(XmlConfiguration configuration) { if (this.InvokeRequired) { this.Invoke(new AddConfigurationInvoker(this.AddConfiguration), new object[] { configuration }); return; } try { if (configuration != null) { configuration.Changed += new XmlConfigurationElementEventHandler(OnConfigurationChanged); if (_placeElementsIntoEditMode) { configuration.BeginEdit(); } _selectedConfigurations.Add(configuration); this.AddNodesForCategories(_treeView, null, configuration.Categories); //this.AddXmlTabForConfiguration(configuration); } } catch (Exception ex) { Debug.WriteLine(ex); } }
/// <summary> /// Reads an XmlConfiguration from a System.IO.Stream /// </summary> /// <param name="stream">The stream that contains the XmlConfiguration file</param> /// <param name="configuration">The configuration to load into</param> /// <returns></returns> public XmlConfiguration Read(Stream stream, XmlConfiguration configuration) { try { /// create a new xml document XmlDocument doc = new XmlDocument(); /// load it from the stream doc.Load(stream); /// create a new xpath navigator so that we can traverse the elements inside the xml XPathNavigator navigator = doc.CreateNavigator(); /// move to the version element navigator.MoveToFirstChild(); /// move to the file format description element navigator.MoveToNext(); this.ReadConfiguration(navigator, configuration); return(configuration); } catch (Exception ex) { Debug.WriteLine(ex); } return(null); }
public override bool ApplyChanges(ISupportsEditing editableObject, SupportedEditingActions actions) { if (base.ApplyChanges(editableObject, actions)) { XmlConfiguration configuration = editableObject as XmlConfiguration; if (configuration != null) { if (_isBeingEdited) { this.BeginInit(); } if (_categories != null) { _categories.ApplyChanges((ISupportsEditing)configuration.Categories, actions); } if (_isBeingEdited) { this.EndInit(); } } return(true); } return(false); }
/// <summary> /// Writes an entire configuration file using the specified configuration and stream. /// </summary> /// <param name="configuration"></param> /// <param name="stream"></param> /// <param name="alwaysPersist"></param> public void Write(XmlConfiguration configuration, Stream stream, bool alwaysPersist) { try { /// create a new xml document XmlDocument doc = new XmlDocument(); /// create the root element XmlElement root = doc.CreateElement(@"ConfigurationFile"); /// append the root element as the first element doc.AppendChild(root); /// mark the xml as version 1.0 compliant XmlDeclaration versionDeclaration = doc.CreateXmlDeclaration(@"1.0", null, null); /// insert the version element as the first element doc.InsertBefore(versionDeclaration, root); this.WriteConfiguration(doc, root, configuration, alwaysPersist); /// save the xml document to the stream doc.Save(stream); } catch (Exception ex) { System.Diagnostics.Debug.Write(ex); } }
public void Remove(XmlConfiguration configuration) { if (this.Contains(configuration)) { base.InnerList.Remove(configuration); } }
/// <summary> /// Writes a configuration to the XmlDocument /// </summary> /// <param name="doc"></param> /// <param name="parent"></param> /// <param name="configuration"></param> /// <param name="alwaysPersist"></param> private void WriteConfiguration(XmlDocument doc, XmlElement parent, XmlConfiguration configuration, bool alwaysPersist) { try { if (configuration.Persistent || alwaysPersist) { // System.Diagnostics.Debug.WriteLine("Writing configuration '" + configuration.ElementName + "'"); /// create an element for the category XmlElement child = doc.CreateElement(@"Configuration"); /// write the properties of this category child.SetAttribute(@"ElementName", configuration.ElementName); child.SetAttribute(@"HasChanges", XmlConvert.ToString(configuration.HasChanges)); child.SetAttribute(@"Category", configuration.Category); child.SetAttribute(@"Description", configuration.Description); child.SetAttribute(@"DisplayName", configuration.DisplayName); child.SetAttribute(@"Hidden", XmlConvert.ToString(configuration.Hidden)); /// append the child to our parent parent.AppendChild(child); this.WriteCategories(doc, child, configuration.Categories, alwaysPersist); } } catch (Exception ex) { Debug.WriteLine(ex); } }
/// <summary> /// Gets an XmlConfiguration using a elementName, optionally creates a new or loads an existing configuration (.xml) file using the path specified, and optionally adds it to the collection if new /// </summary> /// <param name="elementName">The elementName by which this collection will be accessed</param> /// <param name="createIfNotFound">A flag indicating whether the configuration should be created if it does not exist</param> /// <param name="path">The path to the configuration</param> public XmlConfiguration this[string elementName, bool createIfNotFound, bool addToCollectionIfNew, string path] { get { /// try and find the configuration in the collection XmlConfiguration configuration = this[elementName]; /// if it's not in the collection if (configuration == null) { /// perhaps it does in the filesystem, if so then read it, and optionally add it to the collection if (File.Exists(path)) { try { FileStream stream = new FileStream(path, FileMode.Open, FileAccess.Read); XmlConfigurationReader reader = new XmlConfigurationReader(); configuration = reader.Read(stream); configuration.Path = path; stream.Close(); if (addToCollectionIfNew) { this.Add(configuration); } return(configuration); } catch (Exception ex) { Debug.WriteLine(ex); } } /// apparently it doesnt' exist in the filesystem if (createIfNotFound) { /// so create a new file configuration = new XmlConfiguration(); configuration.Path = path; configuration.ElementName = elementName; /// save the blank config Directory.CreateDirectory(path); FileStream stream = new FileStream(path, FileMode.Create, FileAccess.Write); XmlConfigurationWriter writer = new XmlConfigurationWriter(); writer.Write(configuration, stream, false); stream.Close(); /// add it to the config if so instructed if (addToCollectionIfNew) { this.Add(configuration); } } } return(configuration); } }
public bool Contains(XmlConfiguration configuration) { foreach (XmlConfiguration config in base.InnerList) { if (config.ElementName == configuration.ElementName) { return(true); } } return(false); }
public int Add(XmlConfiguration configuration) { if (this.Contains(configuration)) { throw new ArgumentException("ElementName already exists. ElementName in collection: " + configuration.ElementName + " ElementName being added: " + configuration.ElementName); } int index = base.InnerList.Add(configuration); /// bind to events return(0); }
/// <summary> /// Reads a configuration using the specified XPathNavigator /// </summary> /// <param name="navigator"></param> /// <returns></returns> private XmlConfiguration ReadConfiguration(XPathNavigator navigator, XmlConfiguration configuration) { if (navigator.MoveToFirstChild()) { if (string.Compare(navigator.Name, @"Configuration", true) == 0) { // does the cateogry have attributes, it should! if (navigator.HasAttributes) { // break off yet another clone to navigate the attributes of this element XPathNavigator attributesNavigator = navigator.Clone(); if (attributesNavigator.MoveToFirstAttribute()) { configuration.ElementName = attributesNavigator.Value; while (attributesNavigator.MoveToNextAttribute()) { switch (attributesNavigator.Name) { case @"HasChanges": configuration.HasChanges = XmlConvert.ToBoolean(attributesNavigator.Value); break; case @"Category": configuration.Category = attributesNavigator.Value; break; case @"Description": configuration.Description = attributesNavigator.Value; break; case @"DisplayName": configuration.DisplayName = attributesNavigator.Value; break; case @"Hidden": configuration.Hidden = XmlConvert.ToBoolean(attributesNavigator.Value); break; } ; } } } } } // recursively read the categories within this configuration file this.ReadCategories(navigator, configuration.Categories); return(configuration); }
/// <summary> /// Clones this configuration /// </summary> /// <returns></returns> public override object Clone() { XmlConfiguration clone = null; XmlConfigurationElement element = (XmlConfigurationElement)base.Clone(); if (element != null) { clone = new XmlConfiguration(element); clone.ResetBeforeEdit(); clone.ResetChanged(); clone.ResetAfterEdit(); clone.Path = this.Path; clone.SetHasUnpersistedChanges(this.HasUnpersistedChanges()); clone.Categories = (XmlConfigurationCategoryCollection)this.Categories.Clone(); } return(clone); }
public override bool ApplyToSelf(ISupportsEditing editableObject, SupportedEditingActions actions) { if (base.ApplyToSelf(editableObject, actions)) { XmlConfiguration configuration = editableObject as XmlConfiguration; if (configuration != null) { if (_categories != null) { _categories.ApplyToSelf((ISupportsEditing)configuration.Categories, actions); } } return(true); } this.ItIsNowTimeToSave(); return(false); }
/// <summary> /// Reads an XmlConfiguration from a System.IO.Stream /// </summary> /// <param name="stream">The stream that contains the XmlConfiguration file</param> /// <returns></returns> public XmlConfiguration Read(Stream stream) { try { // create a new xml document XmlDocument doc = new XmlDocument(); // load it from the stream doc.Load(stream); // create a new xpath navigator so that we can traverse the elements inside the xml XPathNavigator navigator = doc.CreateNavigator(); // move to the version element navigator.MoveToFirstChild(); // move to the file format description element navigator.MoveToNext(); // create a new configuration XmlConfiguration configuration = new XmlConfiguration(); // begin initialization so that events do not fire inside the configuration configuration.BeginInit(); // using the xpath navigator, read the xml document and turn it into a configuration this.ReadConfiguration(navigator, configuration); // end initialization configuration.EndInit(); return(configuration); } catch (Exception ex) { Debug.WriteLine(ex); } return(null); }
public XmlConfigurationEventArgs(XmlConfiguration configuration, XmlConfigurationElementActions action) : base(configuration, action) { }
protected override XmlConfigurationElement GetElementToEdit() { XmlConfiguration configuration = (XmlConfiguration)this.Clone(); return((XmlConfigurationElement)configuration); }
/// <summary> /// Initializes a new instance of the XmlConfigurationOption class /// </summary> /// <param name="option">The option to base this option on</param> public XmlConfiguration(XmlConfiguration configuration) : base((XmlConfigurationElement)configuration) { _path = configuration.Path; _categories = configuration.Categories; }
public void AddConfiguration(XmlConfiguration configuration) { _xmlConfigurationView.AddConfiguration(configuration); }
public void RemoveConfiguration(XmlConfiguration configuration, bool keepLocationIfPossible) { _xmlConfigurationView.RemoveConfiguration(configuration, keepLocationIfPossible); }