# Settings Manager

A framework for making any serializable field a setting, complete with a pre-built settings interface.

## Quick Start

Settings are stored and managed by a `Settings` instance. This class is responsible for setting and retrieving serialized values from the appropriate repository.

Settings repositories are used to save and load settingsfor a settings scope. Two are provided with this package: one for saving User preferences (`UserSettingsRepository`, backed by the `EditorPrefs` class) and one for Project settings (`ProjecSettingsRepository`, which saves a JSON file to the `ProjectSettings` directory).

Usually you will want to create and manage a singleton `Settings` instance. Ex:

```
using UnityEditor.SettingsManagement;

namespace UnityEditor.SettingsManagement.Examples
{
    static class MySettingsManager
    {
        internal const string k_ProjectSettingsPath = "ProjectSettings/MySettingsExample.json";

        static Settings s_Instance;

        internal static Settings instance
        {
            get
            {
                if (s_Instance == null)
                    s_Instance = new Settings(new ISettingsRepository[]
                    {
                        new ProjectSettingsRepository(k_ProjectSettingsPath),
                        new UserSettingsRepository()
                    });

                return s_Instance;
            }
        }
    }
}
```

Values are set and retrieved using generic methods on on your `Settings` instance:

```
MySettingsManager.instance.Get<float>("myFloatValue", SettingsScope.Project);
```

There are two arguments: key, and scope. The `Settings` class will handle finding an appropriate `ISettingsRepository` for the scope, while `key` and `T` are used to find the value. Setting keys are unique among types, meaning you may re-use keys as long as the setting type is different.

Alternatively, you can use the `UserSetting<T>` class to manage settings. This is a wrapper class around the `Settings` get/set properties, and makes it very easy to make any field a saved setting.

```
// UserSetting<T>(Settings instance, string key, T defaultValue, SettingsScope scope = SettingsScope.Project)
Setting<int> myIntValue = new Setting<int>(MySettingsManager.instance, "int.key", 42, SettingsScope.User);
```

`UserSetting<T>` caches the current value, and keeps a copy of the default value so that it may be reset. `UserSetting<T>` fields are also eligible for use with the `[UserSettingAttribute]` attribute, which lets the `SettingsManagerProvider` automatically add it to a settings inspector.

## Settings Provider

To register your settings in the `Settings Window` you can either write your own `SettingsProvider` implementation, or use the provided `SettingsManagerProvider` and let it automatically create your interface.

Making use of `SettingsManagerProvider` comes with many benefits, including a uniform look for your settings UI, support for search, and per-field or mass reset support.

```
using UnityEngine;

namespace UnityEditor.SettingsManagement.Examples
{
	static class MySettingsProvider
	{
		const string k_PreferencesPath = "Preferences/My Settings";

		[SettingsProvider]
		static SettingsProvider CreateSettingsProvider()
		{
			// The last parameter tells the provider where to search for settings.
			var provider = new SettingsManagerProvider(k_PreferencesPath,
				MySettingsManager.instance,
				new [] { typeof(MySettingsProvider).Assembly });

			return provider;
		}
	}
}
```

To register a field with the `SettingsManagerProvider`, simply decorate it with `[UserSettingAttribute(string displayCategory, string key)]`. `[UserSettingAttribute]` is only valid for static fields.

For more complex settings that require additional UI (or simply don't have a built-in editor), you can use `UserSettingBlockAttribute`. This provides access to the settings provider GUI. See `SettingsExamples.cs` for more on this.

