- Added a new UserPreferencesChanged event that gets propagated to the web client

- added set/getUserPreference to the Preferences class and accessed via the Editor class
- exposed the instantiated Editor class to the EditorUI class so that the extensions can get to it.

Script/AtomicEditor/editor/Editor.ts

@@ -55,7 +55,7 @@ class Editor extends Atomic.ScriptObject {
 
         this.editorLicense = new EditorLicense();
 
-        EditorUI.initialize();
+        EditorUI.initialize(this);
 
         this.playMode = new PlayMode();
 
@@ -138,6 +138,29 @@ class Editor extends Atomic.ScriptObject {
         return true;
     }
 
+    /**
+     * Return a preference value or the provided default from the user settings file
+     * @param  {string} extensionName name of the extension the preference lives under
+     * @param  {string} preferenceName name of the preference to retrieve
+     * @param  {number | boolean | string} defaultValue value to return if pref doesn't exist
+     * @return {number|boolean|string}
+     */
+    getUserPreference(extensionName: string, preferenceName: string, defaultValue?: number | boolean | string): number | boolean | string {
+        return Preferences.getInstance().getUserPreference(extensionName, preferenceName, defaultValue);
+    }
+
+
+    /**
+     * Sets a user preference value in the user settings file
+     * @param  {string} extensionName name of the extension the preference lives under
+     * @param  {string} preferenceName name of the preference to set
+     * @param  {number | boolean | string} value value to set
+     */
+    setUserPreference(extensionName: string, preferenceName: string, value: number | boolean | string) {
+        Preferences.getInstance().setUserPreference(extensionName, preferenceName, value);
+        this.sendEvent(EditorEvents.UserPreferencesChangedNotification);
+    }
+
     handleEditorLoadProject(event: EditorEvents.LoadProjectEvent): boolean {
 
         var system = ToolCore.getToolSystem();

Script/AtomicEditor/editor/EditorEvents.ts

@@ -157,3 +157,5 @@ export const RemoveCurrentAssetAssigned = "RemoveCurrentAssetAssigned";
 export interface RemoveCurrentAssetAssignedEvent {
 
 }
+
+export const UserPreferencesChangedNotification  = "UserPreferencesChangedNotification";

Script/AtomicEditor/editor/Preferences.ts

@@ -145,6 +145,63 @@ class Preferences {
     static getInstance(): Preferences {
         return Preferences.instance;
     }
+
+    /**
+     * Return a preference value or the provided default from the user settings file located in the project
+     * @param  {string} settingsGroup name of the group these settings should fall under
+     * @param  {string} preferenceName name of the preference to retrieve
+     * @param  {number | boolean | string} defaultValue value to return if pref doesn't exist
+     * @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;
+                }
+            } finally {
+                prefsFile.close();
+            }
+        }
+
+        // if all else fails
+        return defaultValue;
+    }
+
+    /**
+     * Sets a user preference value in the user settings file located in the project
+     * @param  {string} settingsGroup name of the group the preference lives under
+     * @param  {string} preferenceName name of the preference to set
+     * @param  {number | boolean | string} value value to set
+     */
+    setUserPreference(settingsGroup: string, preferenceName: string, value: number | boolean | string) {
+
+        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] || {};
+        prefs[settingsGroup][preferenceName] = value;
+
+        let saveFile = new Atomic.File(prefsFileLoc, Atomic.FILE_WRITE);
+        try {
+            saveFile.writeString(JSON.stringify(prefs, null, "  "));
+        } finally {
+            saveFile.flush();
+            saveFile.close();
+        }
+    }
 }
 
 interface WindowData {

Script/AtomicEditor/hostExtensions/HostExtensionServices.ts

@@ -25,6 +25,8 @@ import * as EditorUI from "../ui/EditorUI";
 import MainFrame = require("../ui/frames/MainFrame");
 import ModalOps = require("../ui/modal/ModalOps");
 import ResourceOps = require("../resources/ResourceOps");
+import Editor = require("../editor/Editor");
+
 /**
  * Generic registry for storing Editor Extension Services
  */
@@ -132,22 +134,7 @@ export class ProjectServicesProvider extends ServicesProvider<Editor.HostExtensi
      * @return {number|boolean|string}
      */
     getUserPreference(extensionName: 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());
-                let extensionPrefs = prefs["extensions"];
-                if (extensionPrefs && extensionPrefs[extensionName]) {
-                    return extensionPrefs[extensionName][preferenceName] || defaultValue;
-                }
-            } finally {
-                prefsFile.close();
-            }
-        }
-
-        // if all else fails
-        return defaultValue;
+        return EditorUI.getEditor().getUserPreference(extensionName, preferenceName);
     }
 
 
@@ -158,30 +145,7 @@ export class ProjectServicesProvider extends ServicesProvider<Editor.HostExtensi
      * @param  {number | boolean | string} value value to set
      */
     setUserPreference(extensionName: string, preferenceName: string, value: number | boolean | string) {
-
-        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["extensions"] = prefs["extensions"] || {};
-        prefs["extensions"][extensionName] = prefs["extensions"][extensionName] || {};
-        prefs["extensions"][extensionName][preferenceName] = value;
-
-        let saveFile = new Atomic.File(prefsFileLoc, Atomic.FILE_WRITE);
-        try {
-            saveFile.writeString(JSON.stringify(prefs, null, "  "));
-        } finally {
-            saveFile.flush();
-            saveFile.close();
-        }
+        EditorUI.getEditor().setUserPreference(extensionName, preferenceName, value);
     }
 }
 

Script/AtomicEditor/ui/EditorUI.ts

@@ -25,6 +25,7 @@ import MainFrame = require("./frames/MainFrame");
 import ModalOps = require("./modal/ModalOps");
 import Shortcuts = require("./Shortcuts");
 import ServiceLocator from "../hostExtensions/ServiceLocator";
+import Editor = require("editor/Editor");
 
 // this is designed with public get functions to solve
 // circular dependency issues in TS
@@ -47,8 +48,12 @@ export function getShortcuts():Shortcuts {
   return editorUI.shortcuts;
 }
 
-export function initialize() {
-  editorUI = new EditorUI();
+export function initialize(editor: Editor) {
+  editorUI = new EditorUI(editor);
+}
+
+export function getEditor(): Editor {
+    return editorUI.editor;
 }
 
 export function shutdown() {
@@ -68,10 +73,9 @@ export function getCurrentResourceEditor():Editor.ResourceEditor {
     return getMainFrame().resourceframe.currentResourceEditor;
 }
 
-
 class EditorUI extends Atomic.ScriptObject {
 
-  constructor() {
+  constructor(editor: Editor) {
 
     super();
 
@@ -83,6 +87,8 @@ class EditorUI extends Atomic.ScriptObject {
 
     this.view.addChild(this.mainframe);
 
+    this.editor = editor;
+
     this.subscribeToEvent("ScreenMode", (ev:Atomic.ScreenModeEvent) => {
 
       this.mainframe.setSize(ev.width, ev.height);
@@ -97,7 +103,7 @@ class EditorUI extends Atomic.ScriptObject {
 
     // Hook the service locator into the event system and give it the ui objects it needs
     ServiceLocator.uiServices.init(
-      this.mainframe, 
+      this.mainframe,
       this.modalOps);
     ServiceLocator.subscribeToEvents(this.mainframe);
 
@@ -115,5 +121,6 @@ class EditorUI extends Atomic.ScriptObject {
   mainframe: MainFrame;
   modalOps: ModalOps;
   shortcuts: Shortcuts;
+  editor: Editor;
 
 }

Script/AtomicWebViewEditor/clientExtensions/ClientExtensionServices.ts

@@ -231,16 +231,16 @@ export class WebViewServicesProvider extends ServicesProvider<Editor.ClientExten
 
     /**
      * Return a preference value or the provided default from the user settings file
-     * @param  {string} extensionName name of the extension the preference lives under
+     * @param  {string} gorupName name of the group the preference lives under
      * @param  {string} preferenceName name of the preference to retrieve
      * @param  {number | boolean | string} defaultValue value to return if pref doesn't exist
      * @return {number|boolean|string}
      */
-    getUserPreference(extensionName: string, preferenceName: string, defaultValue?: number | boolean | string): number | boolean | string {
+    getUserPreference(groupName: string, preferenceName: string, defaultValue?: number | boolean | string): number | boolean | string {
         if (this.userPreferences) {
-            let extensionPrefs = this.userPreferences["extensions"];
-            if (extensionPrefs && extensionPrefs[extensionName]) {
-                return extensionPrefs[extensionName][preferenceName] || defaultValue;
+            let prefs = this.userPreferences[groupName];
+            if (prefs) {
+                return prefs[groupName][preferenceName] || defaultValue;
             }
         }