- cache the settings file so that it only reads the file once for multiple setting requests

- added a new method setUserPreferenceGroup to allow setting a batch of settings at once.  This will ensure that the settings changed event only gets fired once and not for every setpreference`

Script/AtomicEditor/editor/Editor.ts

@@ -161,6 +161,18 @@ class Editor extends Atomic.ScriptObject {
         this.sendEvent(EditorEvents.UserPreferencesChangedNotification);
     }
 
+    /**
+     * Sets a group of user preference values in the user settings file located in the project.  Elements in the
+     * group will merge in with existing group preferences.  Use this method if setting a bunch of settings
+     * at once.
+     * @param  {string} settingsGroup name of the group the preference lives under
+     * @param  {string} groupPreferenceValues an object literal containing all of the preferences for the group.
+     */
+    setUserPreferenceGroup(settingsGroup: string, groupPreferenceValues: Object) {
+        Preferences.getInstance().setUserPreferenceGroup(settingsGroup, groupPreferenceValues);
+        this.sendEvent(EditorEvents.UserPreferencesChangedNotification);
+    }
+
     handleEditorLoadProject(event: EditorEvents.LoadProjectEvent): boolean {
 
         var system = ToolCore.getToolSystem();

Script/AtomicEditor/editor/Preferences.ts

@@ -31,6 +31,8 @@ class Preferences {
     private static instance: Preferences;
     private _prefs: PreferencesFormat;
 
+    private cachedProjectjPreferences: Object = null;
+
     constructor() {
         this.fileSystem = Atomic.getFileSystem();
         Preferences.instance = this;
@@ -154,19 +156,25 @@ class Preferences {
      * @return {number|boolean|string}
      */
     getUserPreference(settingsGroup: string, preferenceName: string, defaultValue?: number | boolean | string): number | boolean | string {
-        const prefsFileLoc = ToolCore.toolSystem.project.userPrefsFullPath;
-        if (Atomic.fileSystem.fileExists(prefsFileLoc)) {
-            let prefsFile = new Atomic.File(prefsFileLoc, Atomic.FILE_READ);
-            try {
-                let prefs = JSON.parse(prefsFile.readText());
-                if (prefs && prefs[settingsGroup]) {
-                    return prefs[settingsGroup][preferenceName] || defaultValue;
+
+        // Cache the settings so we don't keep going out to the file
+        if (this.cachedProjectjPreferences == null) {
+            const prefsFileLoc = ToolCore.toolSystem.project.userPrefsFullPath;
+            if (Atomic.fileSystem.fileExists(prefsFileLoc)) {
+                let prefsFile = new Atomic.File(prefsFileLoc, Atomic.FILE_READ);
+                try {
+                    let prefs = JSON.parse(prefsFile.readText());
+                    this.cachedProjectjPreferences = prefs;
+                } finally {
+                    prefsFile.close();
                 }
-            } finally {
-                prefsFile.close();
             }
         }
 
+        if (this.cachedProjectjPreferences && this.cachedProjectjPreferences[settingsGroup]) {
+            return this.cachedProjectjPreferences[settingsGroup][preferenceName] || defaultValue;
+        }
+
         // if all else fails
         return defaultValue;
     }
@@ -201,6 +209,48 @@ class Preferences {
             saveFile.flush();
             saveFile.close();
         }
+
+        // Cache the update
+        this.cachedProjectjPreferences = prefs;
+    }
+
+
+    /**
+     * Sets a group of user preference values in the user settings file located in the project.  Elements in the
+     * group will merge in with existing group preferences.  Use this method if setting a bunch of settings
+     * at once.
+     * @param  {string} settingsGroup name of the group the preference lives under
+     * @param  {string} groupPreferenceValues an object literal containing all of the preferences for the group.
+     */
+    setUserPreferenceGroup(settingsGroup: string, groupPreferenceValues: Object) {
+
+        const prefsFileLoc = ToolCore.toolSystem.project.userPrefsFullPath;
+        let prefs = {};
+
+        if (Atomic.fileSystem.fileExists(prefsFileLoc)) {
+            let prefsFile = new Atomic.File(prefsFileLoc, Atomic.FILE_READ);
+            try {
+                prefs = JSON.parse(prefsFile.readText());
+            } finally {
+                prefsFile.close();
+            }
+        }
+
+        prefs[settingsGroup] = prefs[settingsGroup] || {};
+        for (let preferenceName in groupPreferenceValues) {
+            prefs[settingsGroup][preferenceName] = groupPreferenceValues[preferenceName];
+        }
+
+        let saveFile = new Atomic.File(prefsFileLoc, Atomic.FILE_WRITE);
+        try {
+            saveFile.writeString(JSON.stringify(prefs, null, "  "));
+        } finally {
+            saveFile.flush();
+            saveFile.close();
+        }
+
+        // Cache the update
+        this.cachedProjectjPreferences = prefs;
     }
 }
 

Script/AtomicEditor/hostExtensions/HostExtensionServices.ts

@@ -147,6 +147,17 @@ export class ProjectServicesProvider extends ServicesProvider<Editor.HostExtensi
     setUserPreference(extensionName: string, preferenceName: string, value: number | boolean | string) {
         EditorUI.getEditor().setUserPreference(extensionName, preferenceName, value);
     }
+
+    /**
+     * Sets a group of user preference values in the user settings file located in the project.  Elements in the
+     * group will merge in with existing group preferences.  Use this method if setting a bunch of settings
+     * at once.
+     * @param  {string} extensionName name of the group the preference lives under
+     * @param  {string} groupPreferenceValues an object literal containing all of the preferences for the group.
+     */
+    setUserPreferenceGroup(extensionName: string, groupPreferenceValues: Object) {
+        EditorUI.getEditor().setUserPreferenceGroup(extensionName, groupPreferenceValues);
+    }
 }
 
 /**