/// <summary>
 /// Occurs when the default configuration is needed to initialize a new configuration from memory.
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 protected virtual void FormatConfiguration(object sender, XmlConfigurationEventArgs e)
 {
     e.Element = this.DefaultConfiguration;
 }
        /// <summary>
        /// Reads or creates an XmlConfiguration from a name, path, and/or a handler function to provide structure to a new configuration.
        /// </summary>
        /// <param name="name">The name that will be given to the configuration</param>
        /// <param name="path">The path to the file where the configuration is stored</param>
        /// <param name="configuration">The configuration that will be returned after creation or reading has finished</param>
        /// <param name="encryptionEngine">The encryption engine to use when reading the file</param>
        /// <param name="handler">The event handler to call if structure is needed for a new configuration</param>
        /// <returns>True if a configuration was created or read</returns>
        public static bool ReadOrCreateConfiguration(
            bool verbose,
            string name,
            string path,
            out XmlConfiguration configuration,
            FileEncryptionEngine encryptionEngine,
            XmlConfigurationEventHandler handler)
        {
            configuration = null;

            Log.WriteLineIf(verbose, "Checking to see if the path '" + path + "' exists.");

            /// if the file exists, we need to try and read it
            if (System.IO.File.Exists(path))
            {
                Log.WriteLineIf(verbose, "The path '" + path + "' exists.");

                try
                {
                    /// but first see if we have permissions to read it
                    using (SecurityAccessRight right = new SecurityAccessRight(path))
                    {
                        Log.WriteLineIf(verbose, "Checking to see if the path '" + path + "' has read access.");

                        /// if we don't have rights to the file
                        if (!right.AssertReadAccess())
                        {
                            Log.WriteLineIf(verbose, "The path '" + path + "' does not have write access.");
                            Log.WriteLineIf(verbose, "Prompting for user intervention for the path '" + path + "'.");

                            /// prompt to see what we should do about this
                            DialogResult result = ExceptionUtilities.DisplayException(
                                null,
                                "Read access denied - Unable to read from file",
                                MessageBoxIcon.Error,
                                MessageBoxButtons.AbortRetryIgnore,
                                null,
                                "Read access has been denied for the '" + name + "'.",
                                "Ignoring this exception will result in a default set of options to be loaded in the '" + name + "' for this application instance.",
                                "If the file has write access enabled, it will be overwritten with the loaded options when the application exits.",
                                "WARNING: Aborting this operation will exit the application!");

                            switch (result)
                            {
                                case DialogResult.Abort:
                                    Log.WriteLineIf(verbose, "Aborting attempt to read from the path '" + path + "' because of user intervention.");
                                    return false;

                                case DialogResult.Retry:
                                    Log.WriteLineIf(verbose, "Retrying attempt to read from the path '" + path + "' because of user intervention.");
                                    return ReadOrCreateConfiguration(verbose, name, path, out configuration, encryptionEngine, handler);

                                case DialogResult.Ignore:
                                    Log.WriteLineIf(verbose, "Ignoring attempt to read from the path '" + path + "' because of user intervention.");
                                    return true;
                                //break;					
                            };
                        }
                        else
                        {
                            Log.WriteLineIf(verbose, "The path '" + path + "' has read access, preparing to read the configuration.");

                            /// rights to read the file
                            /// ask the configuration engine to read our configuration file for us into our configuration 
                            if (!ReadConfiguration(encryptionEngine, out configuration, path))
                            {
                                Log.WriteLineIf(verbose, "Failed to write the configuration, throwing exception from the last operation.");
                                throw _lastException;
                            }

                            /// let the configuration know where it lives							
                            //							configuration.Path = path;

                            /// ensure that the configuration has no changes visible
                            if (configuration != null)
                            {
                                Log.WriteLineIf(verbose, "Succeeded in reading the configuration, accepting changes .");
                                configuration.AcceptChanges();
                            }

                            return true;
                        }
                    }
                }
                catch (Exception ex)
                {
                    Log.WriteLineIf(verbose, "An unexpected exception was encountered while reading the configuration, dumping exception.");
                    Log.WriteLine(ex);
                    Log.WriteLineIf(verbose, "Prompting for user intervention for the path '" + path + "'.");

                    /// failed for some reason reading the file
                    /// prompt to see what we should do about this
                    DialogResult result = ExceptionUtilities.DisplayException(
                        null,
                        "Exception encountered - Unable to read from file",
                        MessageBoxIcon.Error,
                        MessageBoxButtons.AbortRetryIgnore,
                        ex,
                        "An exception was encountered while trying to read '" + name + "'.",
                        "Ignoring this exception will result in a default set of options to be loaded in the '" + name + "' for this application instance.",
                        "If the file has write access enabled, it will be overwritten with the loaded options when the application exits.",
                        "WARNING: Aborting this operation will exit the application!");

                    switch (result)
                    {
                        case DialogResult.Abort:
                            Log.WriteLineIf(verbose, "Aborting attempt to read from the path '" + path + "' because of user intervention.");
                            return false;

                        case DialogResult.Retry:
                            Log.WriteLineIf(verbose, "Retrying attempt to read from the path '" + path + "' because of user intervention.");
                            return ReadOrCreateConfiguration(verbose, name, path, out configuration, encryptionEngine, handler);

                        case DialogResult.Ignore:
                            Log.WriteLineIf(verbose, "Ignoring attempt to read from the path '" + path + "' because of user intervention.");
                            break;
                    };
                }
            }
            else
            {
                Log.WriteLineIf(verbose, "The path '" + path + "' does not exist.");
            }

            /// if for some reason the configuration hasn't been loaded yet
            if (configuration == null)
            {
                Log.WriteLineIf(verbose, "Creating new configuration named '" + name + "'.");
                configuration = new XmlConfiguration();
                configuration.ElementName = name;

                Log.WriteLineIf(verbose, "Checking for formatting callback for the configuration named '" + name + "'.");

                if (handler != null)
                {
                    Log.WriteLineIf(verbose, "Formatting callback found for the configuration named '" + name + "', calling formatting callback to apply structure to the configuration.");
                    try
                    {
                        XmlConfigurationEventArgs e = new XmlConfigurationEventArgs(configuration, XmlConfigurationElementActions.None);
                        handler(null, e);
                        configuration = e.Element;
                    }
                    catch (Exception ex)
                    {
                        Log.WriteLineIf(verbose, "An unexpected exception was encountered while reading the configuration named '" + name + "', dumping exception.");
                        Log.WriteLine(ex);
                    }
                }
            }

            Log.WriteLineIf(verbose, "Setting the path for the configuration named '" + name + "' and accepting changes to the configuration.");

            /// let the configuration know where it lives
            configuration.Path = path;

            /// ensure that the configuration has no changes visible
            configuration.AcceptChanges();

            return true;
        }