MD Settings: Languages model for language pages

chrome/browser/resources/settings/languages_page/languages_model.js

Index: chrome/browser/resources/settings/languages_page/languages_model.js
diff --git a/chrome/browser/resources/settings/languages_page/languages_model.js b/chrome/browser/resources/settings/languages_page/languages_model.js
new file mode 100644
index 0000000000000000000000000000000000000000..aaadac36e26321e781cdc79e8c5b605785c285f5
--- /dev/null
+++ b/chrome/browser/resources/settings/languages_page/languages_model.js
@@ -0,0 +1,350 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+/**
+ * @fileoverview 'cr-settings-languages-model' provides convenient access to
+ * Chrome's language and input method settings.
+ *
+ * @group Chrome Settings Elements
+ * @element cr-settings-languages-model
+ */
+
+/**
+ * @typedef {{spellCheckEnabled: boolean}}
+ */
+var LanguageState;
+
+/**
+ * @typedef {{language: !chrome.languageSettingsPrivate.Language,
+ *            state: !LanguageState}}
+ */
+var LanguageInfo;
+
+/**
+ * The model includes:
+ *     supportedLanguages: an array of languages, ordered alphabetically.
+ *     enabledLanguages: an array of enabled language info and state, ordered by
+ *         preference.
+ * As well as hash map equivalents: supportedLanguageMap, enabledLanguageMap.
+ * @typedef {{
+ *      supportedLanguages: !Array<!chrome.languageSettingsPrivate.Language>,
+ *      supportedLanguageMap: !Object<!chrome.languageSettingsPrivate.Language>,
+ *      enabledLanguages: !Array<!LanguageInfo>,
+ *      enabledLanguageMap: !Object<!LanguageInfo>
+ *  }}
+ */
+var LanguagesModel;
+
+(function() {
+'use strict';
+
+/** Exposes the singleton model to hosts. */
+Polymer({
+  is: 'cr-settings-languages-model',
+
+  properties: {
+    /**
+     * Shared languages model.
+     * @type {(LanguagesModel|undefined)}
+     */
+    model: {
+      type: Object,
+      notify: true,
+      readOnly: true,
+    },
+
+    /**
+     * Shared private state.
+     * @type {!Element}
+     */
+    privateModel_: {
+      type: Object,
+      value: document.createElement('cr-settings-languages-model-private'),
+    },
+  },
+
+  ready: function() {
+    this.squelching_(function() {
+      // This notifies the host via Polymer.
+      this._setModel(this.privateModel_.model);
+    });
+    this.listen(this.privateModel_, 'model-changed', 'privateModelChanged_');
+  },
+
+  /**
+   * On supported systems, sets the prospective UI language to the chosen
+   * language. This dosen't affect the actual UI language until a restart.
+   * @param {string} languageCode
+   */
+  setUILanguage: function(languageCode) {
+    this.privateModel_.setUILanguage(languageCode);
+  },
+
+  /**
+   * Enables the language, making it available for spell check and input.
+   * @param {string} languageCode
+   * */
+  enableLanguage: function(languageCode) {
+    this.privateModel_.enableLanguage(languageCode);
+  },
+
+  /**
+   * Disables the language.
+   * @param {string} languageCode
+   */
+  disableLanguage: function(languageCode) {
+    this.privateModel_.disableLanguage(languageCode);
+  },
+
+  /**
+   * Enables or disables spell check for the given language.
+   * @param {string} languageCode
+   * @param {boolean} enable
+   */
+  toggleSpellCheck: function(languageCode, enable) {
+    this.privateModel_.toggleSpellCheck(languageCode, enable);
+  },
+
+  /**
+   * Forwards changes reported by privateModel_ to the host.
+   * @private
+   */
+  privateModelChanged_: function(e) {
+    // Squelch because we've defeated Polymer's internal dirty-checking.
+    this.squelching_(function() {
+      // Forward notification to host.
+      this.fire(e.type, e.detail, {bubbles: false});
+    });
+  },
+
+  /**
+   * Sets a "squelch" switch before calling the function, so functions can
+   * return early when the switch is active.
+   * @param {!function()} fn
+   * @private
+   */
+  squelching_: function(fn) {
+    this.squelch_ = true;
+    fn.call(this);
+    // We can unset squelch_ now because change notifications are synchronous.
+    this.squelch_ = false;
+  },
+});
+
+var preferredLanguagesPath;
+if (cr.isChromeOS)
+  preferredLanguagesPath = 'prefs.settings.language.preferred_languages.value';
+else
+  preferredLanguagesPath = 'prefs.intl.accept_languages.value';
+
+/**
+ * Privately used element that contains, listens to and updates the shared
+ * languages model.
+ */
+Polymer({
+  is: 'cr-settings-languages-model-private',
+
+  properties: {
+    /**
+     * @type {(LanguagesModel|undefined)}
+     */
+    model: {
+      type: Object,
+      notify: true,
+    },
+
+    /**
+     * Object containing all preferences, for use by Polymer controls.
+     */
+    prefs: {
+      type: Object,
+      notify: true,
+    },
+  },
+
+  observers: [
+    'preferredLanguagesPrefChanged_(' + preferredLanguagesPath + ')',
+    'spellCheckDictionariesPrefChanged_(prefs.spellcheck.dictionaries.value.*)',
+  ],
+
+  /** @override */
+  created: function() {
+    chrome.languageSettingsPrivate.getLanguageList(function(languageList) {
+      // Wait until prefs are initialized before creating the model, so we can
+      // include information about enabled languages.
+      CrSettingsPrefs.initialized.then(function() {
+        this.createModel_(languageList);
+        this.initialized_ = true;
+      }.bind(this));
+    }.bind(this));
+  },
+
+  /**
+   * Constructs the model with the given language list.
+   * @param {!Array<!chrome.languageSettingsPrivate.Language>}
+   *     supportedLanguages
+   */
+  createModel_: function(supportedLanguages) {
+    // Create a hash table of supported languages.
+    var supportedLanguageMap = {};
+    for (var i = 0; i < supportedLanguages.length; i++)
+      supportedLanguageMap[supportedLanguages[i].code] = supportedLanguages[i];
+
+    // Create a list and map of enabled language info.
+    var enabledLanguages = this.getEnabledLanguages_(supportedLanguageMap);
+    var enabledLanguageMap = {};
+    for (var i = 0; i < enabledLanguages.length; i++) {
+      var languageInfo = enabledLanguages[i];
+      enabledLanguageMap[languageInfo.language.code] = languageInfo;
+    }
+
+    // Initialize the Polymer model.
+    this.model = {
+      supportedLanguages: supportedLanguages,
+      supportedLanguageMap: supportedLanguageMap,
+      enabledLanguages: enabledLanguages,
+      enabledLanguageMap: enabledLanguageMap,
+    };
+  },
+
+  /**
+   * Returns a list of LanguageInfos for each enabled language in the supported
+   * languages list.
+   * @private
+   * @param {!Object<!chrome.languageSettingsPrivate.Language>}
+   *     supportedLanguageMap
+   * @return {!Array<!LanguageInfo>}
+   */
+  getEnabledLanguages_: function(supportedLanguageMap) {
+    var languageCodes = this.get(preferredLanguagesPath).split(',');
+    var enabledLanguages = [];
+    var spellCheckMap = this.getSpellCheckMap_();
+    for (var i = 0; i < languageCodes.length; i++) {
+      var code = languageCodes[i];
+      var language = supportedLanguageMap[code];
+      if (!language)
+        continue;
+      var state = {spellCheckEnabled: !!spellCheckMap[code]};
+      enabledLanguages.push({language: language, state: state});
+    }
+    return enabledLanguages;
+  },
+
+  /**
+   * Creates a map whose keys are languages enabled for spell check.
+   * @return {!Object<boolean>}
+   */
+  getSpellCheckMap_: function() {
+    var spellCheckPref = /** @type {chrome.settingsPrivate.PrefObject} */(
+        this.get('prefs.spellcheck.dictionaries'));
+    var spellCheckCodes = spellCheckPref.value;
+    var spellCheckMap = {};
+    for (var i = 0; i < spellCheckCodes.length; i++)
+      spellCheckMap[spellCheckCodes[i]] = true;
+    return spellCheckMap;
+  },
+
+  /** @private */
+  preferredLanguagesPrefChanged_: function() {
+    if (!this.initialized_)
+      return;
+
+    var enabledLanguages =
+        this.getEnabledLanguages_(this.model.supportedLanguageMap);
+    this.set('model.enabledLanguages', enabledLanguages);
+    var enabledLanguageMap = {};
+    for (var i = 0; i < enabledLanguages.length; i++) {
+      var languageInfo = enabledLanguages[i];
+      enabledLanguageMap[languageInfo.language.code] = languageInfo;
+    }
+    this.set('model.enabledLanguageMap', enabledLanguageMap);
+  },
+
+  /**
+   * Updates the spellCheckEnabled state of each enabled language.
+   * @private
+   */
+  spellCheckDictionariesPrefChanged_: function() {
+    if (!this.initialized_)
+      return;
+
+    var spellCheckMap = this.getSpellCheckMap_();
+    for (var i = 0; i < this.model.enabledLanguages.length; i++) {
+      this.set('model.enabledLanguages.' + i + '.state.spellCheckEnabled',
+               !!spellCheckMap[this.model.enabledLanguages[i].language.code]);
+    }
+  },
+
+  /**
+   * On supported systems, sets the prospective UI language to the chosen
+   * language. This dosen't affect the actual UI language until a restart.
+   * @param {string} languageCode
+   */
+  setUILanguage: function(languageCode) {
+    // Set the prospective UI language. This won't take effect until a restart.
+    if (cr.isWindows)
+      this.set('prefs.intl.app_locale.value', languageCode);
+    else if (cr.isChromeOS)
+      chrome.send('setUILanguage', [languageCode]);
+  },
+
+  /**
+   * Enables the language, making it available for spell check and input.
+   * @param {string} languageCode
+   */
+  enableLanguage: function(languageCode) {
+    var languageCodes = this.get(preferredLanguagesPath);
+    var index = languageCodes.split(',').indexOf(languageCode);
+    if (index > -1)
+      return;
+    this.set(preferredLanguagesPath, languageCodes + ',' + languageCode);
+  },
+
+  /**
+   * Disables the language.
+   * @param {string} languageCode
+   */
+  disableLanguage: function(languageCode) {
+    // Don't disable the UI language.
+    var appLocale = this.get('prefs.intl.app_locale.value') ||
+                    navigator.language;
+    if (languageCode == appLocale)
+      return;
+
+    var languageCodes = this.get(preferredLanguagesPath).split(',');
+    // Don't disable the only enabled language.
+    if (languageCodes.length == 1)
+      return;
+
+    // Remove the language from spell check.
+    var spellCheckIndex =
+        this.get('prefs.spellcheck.dictionaries.value').indexOf(languageCode);
+    if (spellCheckIndex != -1)
+      this.splice('prefs.spellcheck.dictionaries.value', spellCheckIndex, 1);
+
+    var languageIndex = languageCodes.indexOf(languageCode);
+    if (languageIndex == -1)
+      return;
+    languageCodes.splice(languageIndex, 1);
+    this.set(preferredLanguagesPath, languageCodes.join(','));
+  },
+
+  /**
+   * Enables or disables spell check for the given language.
+   * @param {string} languageCode
+   * @param {boolean} enable
+   */
+  toggleSpellCheck: function(languageCode, enable) {
+    var spellCheckPref = /** @type {chrome.settingsPrivate.PrefObject} */(
+        this.get('prefs.spellcheck.dictionaries'));
+    if (enable) {
+      if (spellCheckPref.value.indexOf(languageCode) == -1)
+        this.push('prefs.spellcheck.dictionaries.value', languageCode);
+    } else {
+      // TODO: need update externs before committing
+      this.arrayDelete('prefs.spellcheck.dictionaries.value', languageCode);
+    }
+  },
+});
+})();