webfontloader 1.3.0 → 1.3.1

data/src/core/eventdispatcher.js

@@ -1,3 +1,7 @@
+goog.provide('webfont.EventDispatcher');
+
+goog.require('webfont.CssClassName');
+
 /**
  * A class to dispatch events and manage the event class names on an html
  * element that represent the current state of fonts on the page. Active class
@@ -49,115 +53,119 @@ webfont.EventDispatcher.INACTIVE = 'inactive';
  */
 webfont.EventDispatcher.FONT = 'font';
 
-/**
- * Dispatch the loading event and append the loading class name.
- */
-webfont.EventDispatcher.prototype.dispatchLoading = function() {
-  this.domHelper_.appendClassName(this.htmlElement_,
-      this.cssClassName_.build(
-          this.namespace_, webfont.EventDispatcher.LOADING));
-  this.dispatch_(webfont.EventDispatcher.LOADING);
-};
-
-/**
- * Dispatch the font loading event and append the font loading class name.
- * @param {string} fontFamily
- * @param {string} fontDescription
- */
-webfont.EventDispatcher.prototype.dispatchFontLoading = function(fontFamily, fontDescription) {
-  this.domHelper_.appendClassName(this.htmlElement_,
-      this.cssClassName_.build(
-          this.namespace_, fontFamily, fontDescription, webfont.EventDispatcher.LOADING));
-  this.dispatch_(
-      webfont.EventDispatcher.FONT + webfont.EventDispatcher.LOADING, fontFamily, fontDescription);
-};
+goog.scope(function () {
+  var EventDispatcher = webfont.EventDispatcher;
 
-/**
- * Dispatch the font active event, remove the font loading class name, remove
- * the font inactive class name, and append the font active class name.
- * @param {string} fontFamily
- * @param {string} fontDescription
- */
-webfont.EventDispatcher.prototype.dispatchFontActive = function(fontFamily, fontDescription) {
-  this.domHelper_.removeClassName(this.htmlElement_,
-      this.cssClassName_.build(
-          this.namespace_, fontFamily, fontDescription, webfont.EventDispatcher.LOADING));
-  this.domHelper_.removeClassName(this.htmlElement_,
-      this.cssClassName_.build(
-          this.namespace_, fontFamily, fontDescription, webfont.EventDispatcher.INACTIVE));
-  this.domHelper_.appendClassName(this.htmlElement_,
-      this.cssClassName_.build(
-          this.namespace_, fontFamily, fontDescription, webfont.EventDispatcher.ACTIVE));
-  this.dispatch_(
-      webfont.EventDispatcher.FONT + webfont.EventDispatcher.ACTIVE, fontFamily, fontDescription);
-};
+  /**
+   * Dispatch the loading event and append the loading class name.
+   */
+  EventDispatcher.prototype.dispatchLoading = function() {
+    this.domHelper_.appendClassName(this.htmlElement_,
+        this.cssClassName_.build(
+            this.namespace_, webfont.EventDispatcher.LOADING));
+    this.dispatch_(webfont.EventDispatcher.LOADING);
+  };
 
-/**
- * Dispatch the font inactive event, remove the font loading class name, and
- * append the font inactive class name (unless the font active class name is
- * already present).
- * @param {string} fontFamily
- * @param {string} fontDescription
- */
-webfont.EventDispatcher.prototype.dispatchFontInactive = function(fontFamily, fontDescription) {
-  this.domHelper_.removeClassName(this.htmlElement_,
-      this.cssClassName_.build(
-          this.namespace_, fontFamily, fontDescription, webfont.EventDispatcher.LOADING));
-  var hasFontActive = this.domHelper_.hasClassName(this.htmlElement_,
-      this.cssClassName_.build(
-          this.namespace_, fontFamily, fontDescription, webfont.EventDispatcher.ACTIVE));
-  if (!hasFontActive) {
+  /**
+   * Dispatch the font loading event and append the font loading class name.
+   * @param {string} fontFamily
+   * @param {string} fontDescription
+   */
+  EventDispatcher.prototype.dispatchFontLoading = function(fontFamily, fontDescription) {
     this.domHelper_.appendClassName(this.htmlElement_,
         this.cssClassName_.build(
-            this.namespace_, fontFamily, fontDescription, webfont.EventDispatcher.INACTIVE));
-  }
-  this.dispatch_(
-      webfont.EventDispatcher.FONT + webfont.EventDispatcher.INACTIVE, fontFamily, fontDescription);
-};
+            this.namespace_, fontFamily, fontDescription, webfont.EventDispatcher.LOADING));
+    this.dispatch_(
+        webfont.EventDispatcher.FONT + webfont.EventDispatcher.LOADING, fontFamily, fontDescription);
+  };
 
-/**
- * Dispatch the inactive event, remove the loading class name, and append the
- * inactive class name (unless the active class name is already present).
- */
-webfont.EventDispatcher.prototype.dispatchInactive = function() {
-  this.domHelper_.removeClassName(this.htmlElement_,
-      this.cssClassName_.build(
-          this.namespace_, webfont.EventDispatcher.LOADING));
-  var hasActive = this.domHelper_.hasClassName(this.htmlElement_,
-      this.cssClassName_.build(
-          this.namespace_, webfont.EventDispatcher.ACTIVE));
-  if (!hasActive) {
+  /**
+   * Dispatch the font active event, remove the font loading class name, remove
+   * the font inactive class name, and append the font active class name.
+   * @param {string} fontFamily
+   * @param {string} fontDescription
+   */
+  EventDispatcher.prototype.dispatchFontActive = function(fontFamily, fontDescription) {
+    this.domHelper_.removeClassName(this.htmlElement_,
+        this.cssClassName_.build(
+            this.namespace_, fontFamily, fontDescription, webfont.EventDispatcher.LOADING));
+    this.domHelper_.removeClassName(this.htmlElement_,
+        this.cssClassName_.build(
+            this.namespace_, fontFamily, fontDescription, webfont.EventDispatcher.INACTIVE));
     this.domHelper_.appendClassName(this.htmlElement_,
         this.cssClassName_.build(
-          this.namespace_, webfont.EventDispatcher.INACTIVE));
-  }
-  this.dispatch_(webfont.EventDispatcher.INACTIVE);
-};
+            this.namespace_, fontFamily, fontDescription, webfont.EventDispatcher.ACTIVE));
+    this.dispatch_(
+        webfont.EventDispatcher.FONT + webfont.EventDispatcher.ACTIVE, fontFamily, fontDescription);
+  };
 
-/**
- * Dispatch the active event, remove the loading class name, remove the inactive
- * class name, and append the active class name.
- */
-webfont.EventDispatcher.prototype.dispatchActive = function() {
-  this.domHelper_.removeClassName(this.htmlElement_,
-      this.cssClassName_.build(
-          this.namespace_, webfont.EventDispatcher.LOADING));
-  this.domHelper_.removeClassName(this.htmlElement_,
-      this.cssClassName_.build(
-          this.namespace_, webfont.EventDispatcher.INACTIVE));
-  this.domHelper_.appendClassName(this.htmlElement_,
-      this.cssClassName_.build(
-          this.namespace_, webfont.EventDispatcher.ACTIVE));
-  this.dispatch_(webfont.EventDispatcher.ACTIVE);
-};
+  /**
+   * Dispatch the font inactive event, remove the font loading class name, and
+   * append the font inactive class name (unless the font active class name is
+   * already present).
+   * @param {string} fontFamily
+   * @param {string} fontDescription
+   */
+  EventDispatcher.prototype.dispatchFontInactive = function(fontFamily, fontDescription) {
+    this.domHelper_.removeClassName(this.htmlElement_,
+        this.cssClassName_.build(
+            this.namespace_, fontFamily, fontDescription, webfont.EventDispatcher.LOADING));
+    var hasFontActive = this.domHelper_.hasClassName(this.htmlElement_,
+        this.cssClassName_.build(
+            this.namespace_, fontFamily, fontDescription, webfont.EventDispatcher.ACTIVE));
+    if (!hasFontActive) {
+      this.domHelper_.appendClassName(this.htmlElement_,
+          this.cssClassName_.build(
+              this.namespace_, fontFamily, fontDescription, webfont.EventDispatcher.INACTIVE));
+    }
+    this.dispatch_(
+        webfont.EventDispatcher.FONT + webfont.EventDispatcher.INACTIVE, fontFamily, fontDescription);
+  };
 
-/**
- * @param {string} event
- * @param {string=} opt_arg1
- * @param {string=} opt_arg2
- */
-webfont.EventDispatcher.prototype.dispatch_ = function(event, opt_arg1, opt_arg2) {
-  if (this.callbacks_[event]) {
-    this.callbacks_[event](opt_arg1, opt_arg2);
-  }
-};
+  /**
+   * Dispatch the inactive event, remove the loading class name, and append the
+   * inactive class name (unless the active class name is already present).
+   */
+  EventDispatcher.prototype.dispatchInactive = function() {
+    this.domHelper_.removeClassName(this.htmlElement_,
+        this.cssClassName_.build(
+            this.namespace_, webfont.EventDispatcher.LOADING));
+    var hasActive = this.domHelper_.hasClassName(this.htmlElement_,
+        this.cssClassName_.build(
+            this.namespace_, webfont.EventDispatcher.ACTIVE));
+    if (!hasActive) {
+      this.domHelper_.appendClassName(this.htmlElement_,
+          this.cssClassName_.build(
+            this.namespace_, webfont.EventDispatcher.INACTIVE));
+    }
+    this.dispatch_(webfont.EventDispatcher.INACTIVE);
+  };
+
+  /**
+   * Dispatch the active event, remove the loading class name, remove the inactive
+   * class name, and append the active class name.
+   */
+  EventDispatcher.prototype.dispatchActive = function() {
+    this.domHelper_.removeClassName(this.htmlElement_,
+        this.cssClassName_.build(
+            this.namespace_, webfont.EventDispatcher.LOADING));
+    this.domHelper_.removeClassName(this.htmlElement_,
+        this.cssClassName_.build(
+            this.namespace_, webfont.EventDispatcher.INACTIVE));
+    this.domHelper_.appendClassName(this.htmlElement_,
+        this.cssClassName_.build(
+            this.namespace_, webfont.EventDispatcher.ACTIVE));
+    this.dispatch_(webfont.EventDispatcher.ACTIVE);
+  };
+
+  /**
+   * @param {string} event
+   * @param {string=} opt_arg1
+   * @param {string=} opt_arg2
+   */
+  EventDispatcher.prototype.dispatch_ = function(event, opt_arg1, opt_arg2) {
+    if (this.callbacks_[event]) {
+      this.callbacks_[event](opt_arg1, opt_arg2);
+    }
+  };
+});

data/src/core/font.js

@@ -1,96 +1,138 @@
+goog.provide('webfont.WebFont');
+
+goog.require('webfont.DomHelper');
+goog.require('webfont.EventDispatcher');
+goog.require('webfont.FontWatcher');
+goog.require('webfont.Size');
+
 /**
  * @param {Window} mainWindow The main application window containing
  *   webfontloader.js.
  * @param {webfont.FontModuleLoader} fontModuleLoader A loader instance to use.
- * @param {function(function(), number=)} asyncCall An async function to use.
  * @param {webfont.UserAgent} userAgent The detected user agent to load for.
  * @constructor
  */
-webfont.WebFont = function(mainWindow, fontModuleLoader, asyncCall, userAgent) {
+webfont.WebFont = function(mainWindow, fontModuleLoader, userAgent) {
   this.mainWindow_ = mainWindow;
   this.fontModuleLoader_ = fontModuleLoader;
-  this.asyncCall_ = asyncCall;
   this.userAgent_ = userAgent;
   this.moduleLoading_ = 0;
   this.moduleFailedLoading_ = 0;
 };
 
-webfont.WebFont.prototype.addModule = function(name, factory) {
-  this.fontModuleLoader_.addModuleFactory(name, factory);
-};
+goog.scope(function () {
+  var WebFont = webfont.WebFont,
+      DomHelper = webfont.DomHelper,
+      EventDispatcher = webfont.EventDispatcher,
+      FontWatcher = webfont.FontWatcher,
+      Size = webfont.Size;
 
-webfont.WebFont.prototype.load = function(configuration) {
-  var context = configuration['context'] || this.mainWindow_;
-  this.domHelper_ = new webfont.DomHelper(this.mainWindow_, context);
+  /**
+   * @param {string} name
+   * @param {webfont.FontModuleFactory} factory
+   */
+  WebFont.prototype.addModule = function(name, factory) {
+    this.fontModuleLoader_.addModuleFactory(name, factory);
+  };
 
-  var eventDispatcher = new webfont.EventDispatcher(
-      this.domHelper_, context.document.documentElement, configuration);
+  /**
+   * @param {Object} configuration
+   */
+  WebFont.prototype.load = function(configuration) {
+    var context = configuration['context'] || this.mainWindow_;
+    this.domHelper_ = new DomHelper(this.mainWindow_, context);
 
-  if (this.userAgent_.getBrowserInfo().hasWebFontSupport()) {
-    this.load_(eventDispatcher, configuration);
-  } else {
-    eventDispatcher.dispatchInactive();
-  }
-};
+    var eventDispatcher = new EventDispatcher(
+        this.domHelper_, context.document.documentElement, configuration);
 
-webfont.WebFont.prototype.isModuleSupportingUserAgent_ = function(module, eventDispatcher,
-    fontWatcher, support) {
-  var fontWatchRunnerCtor = module.getFontWatchRunnerCtor ?
-      module.getFontWatchRunnerCtor() : webfont.FontWatchRunner;
-  if (!support) {
+    if (this.userAgent_.getBrowserInfo().hasWebFontSupport()) {
+      this.load_(eventDispatcher, configuration);
+    } else {
+      eventDispatcher.dispatchInactive();
+    }
+  };
+
+  /**
+   * @param {webfont.FontModule} module
+   * @param {webfont.EventDispatcher} eventDispatcher
+   * @param {webfont.FontWatcher} fontWatcher
+   * @param {boolean} support
+   */
+  WebFont.prototype.isModuleSupportingUserAgent_ = function(module, eventDispatcher,
+      fontWatcher, support) {
+    var fontWatchRunnerCtor = module.getFontWatchRunnerCtor ?
+        module.getFontWatchRunnerCtor() : webfont.FontWatchRunner,
+        that = this;
+
+    if (!support) {
+      var allModulesLoaded = --this.moduleLoading_ == 0;
+
+      this.moduleFailedLoading_--;
+      if (allModulesLoaded) {
+        if (this.moduleFailedLoading_ == 0) {
+          eventDispatcher.dispatchInactive();
+        } else {
+          eventDispatcher.dispatchLoading();
+        }
+      }
+      fontWatcher.watch([], {}, {}, fontWatchRunnerCtor, allModulesLoaded);
+      return;
+    }
+
+    module.load(function (fontFamilies, fontVariations) {
+      that.onModuleReady_(eventDispatcher, fontWatcher, fontWatchRunnerCtor, fontFamilies, fontVariations);
+    });
+  };
+
+  /**
+   * @param {webfont.EventDispatcher} eventDispatcher
+   * @param {webfont.FontWatcher} fontWatcher
+   * @param {function(new:webfont.FontWatchRunner,
+   *                  function(string, string),
+   *                  function(string, string),
+   *                  webfont.DomHelper,
+   *                  string,
+   *                  string,
+   *                  webfont.BrowserInfo,
+   *                  number=,
+   *                  Object.<string, boolean>=,
+   *                  string=)} fontWatchRunnerCtor
+   * @param {webfont.FontFamilies} fontFamilies
+   * @param {webfont.FontVariations=} opt_fontVariations
+   * @param {webfont.FontTestStrings=} opt_fontTestStrings
+   */
+  WebFont.prototype.onModuleReady_ = function(eventDispatcher, fontWatcher,
+      fontWatchRunnerCtor, fontFamilies, opt_fontVariations, opt_fontTestStrings) {
     var allModulesLoaded = --this.moduleLoading_ == 0;
 
-    this.moduleFailedLoading_--;
     if (allModulesLoaded) {
-      if (this.moduleFailedLoading_ == 0) {
-        eventDispatcher.dispatchInactive();
-      } else {
-        eventDispatcher.dispatchLoading();
-      }
+      eventDispatcher.dispatchLoading();
     }
-    fontWatcher.watch([], {}, {}, fontWatchRunnerCtor, allModulesLoaded);
-    return;
-  }
-  module.load(webfont.bind(this, this.onModuleReady_, eventDispatcher,
-      fontWatcher, fontWatchRunnerCtor));
-};
 
-webfont.WebFont.prototype.onModuleReady_ = function(eventDispatcher, fontWatcher,
-    fontWatchRunnerCtor, fontFamilies, opt_fontDescriptions, opt_fontTestStrings) {
-  var allModulesLoaded = --this.moduleLoading_ == 0;
-
-  if (allModulesLoaded) {
-    eventDispatcher.dispatchLoading();
-  }
-  this.asyncCall_(webfont.bind(this, function(_fontWatcher, _fontFamilies,
-      _fontDescriptions, _fontTestStrings, _fontWatchRunnerCtor,
-      _allModulesLoaded) {
-        _fontWatcher.watch(_fontFamilies, _fontDescriptions || {},
-          _fontTestStrings || {}, _fontWatchRunnerCtor, _allModulesLoaded);
-      }, fontWatcher, fontFamilies, opt_fontDescriptions, opt_fontTestStrings,
-      fontWatchRunnerCtor, allModulesLoaded));
-};
+    setTimeout(function () {
+      fontWatcher.watch(fontFamilies, opt_fontVariations || {}, opt_fontTestStrings || {}, fontWatchRunnerCtor, allModulesLoaded);
+    }, 0);
+  };
 
-webfont.WebFont.prototype.load_ = function(eventDispatcher, configuration) {
-  var modules = this.fontModuleLoader_.getModules(configuration, this.domHelper_),
-      timeout = configuration['timeout'],
-      self = this;
+  /**
+   * @param {webfont.EventDispatcher} eventDispatcher
+   * @param {Object} configuration
+   */
+  WebFont.prototype.load_ = function(eventDispatcher, configuration) {
+    var modules = this.fontModuleLoader_.getModules(configuration, this.domHelper_),
+        timeout = configuration['timeout'],
+        self = this;
 
-  this.moduleFailedLoading_ = this.moduleLoading_ = modules.length;
+    this.moduleFailedLoading_ = this.moduleLoading_ = modules.length;
 
-  var fontWatcher = new webfont.FontWatcher(this.userAgent_, this.domHelper_,
-      eventDispatcher, {
-        getSize: function(elem) {
-          return new webfont.Size(elem.offsetWidth, elem.offsetHeight);
-        }}, self.asyncCall_, function() {
-          return new Date().getTime();
-        }, timeout);
+    var fontWatcher = new webfont.FontWatcher(this.userAgent_, this.domHelper_, eventDispatcher, timeout);
 
-  for (var i = 0, len = modules.length; i < len; i++) {
-    var module = modules[i];
+    for (var i = 0, len = modules.length; i < len; i++) {
+      var module = modules[i];
 
-    module.supportUserAgent(this.userAgent_,
-        webfont.bind(this, this.isModuleSupportingUserAgent_, module,
-        eventDispatcher, fontWatcher));
-  }
-};
+      module.supportUserAgent(this.userAgent_,
+          goog.bind(this.isModuleSupportingUserAgent_, this, module,
+          eventDispatcher, fontWatcher));
+    }
+  };
+});

data/src/core/fontmoduleloader.js

@@ -1,25 +1,68 @@
+goog.provide('webfont.FontModuleLoader');
+goog.provide('webfont.FontModule');
+goog.provide('webfont.FontModuleFactory');
+
+/**
+ * @interface
+ */
+webfont.FontModule = function () {};
+
+goog.scope(function () {
+  var FontModule = webfont.FontModule;
+
+  /**
+   * @param {webfont.UserAgent} userAgent
+   * @param {function(boolean)} support
+   */
+  FontModule.prototype.supportUserAgent = function (userAgent, support) {};
+
+  /**
+   * @param {function(webfont.FontFamilies, webfont.FontVariations=, webfont.FontTestStrings=)} onReady
+   */
+  FontModule.prototype.load = function (onReady) {};
+});
+
+/** @typedef {function(Object, webfont.DomHelper): webfont.FontModule} */
+webfont.FontModuleFactory;
+
 /**
  * @constructor
  */
 webfont.FontModuleLoader = function() {
+  /**
+   * @type {Object.<string, webfont.FontModuleFactory>}
+   */
   this.modules_ = {};
 };
 
-webfont.FontModuleLoader.prototype.addModuleFactory = function(name, factory) {
-  this.modules_[name] = factory;
-};
+goog.scope(function () {
+  var FontModuleLoader = webfont.FontModuleLoader;
 
-webfont.FontModuleLoader.prototype.getModules = function(configuration, domHelper) {
-  var modules = [];
+  /**
+   * @param {string} name
+   * @param {webfont.FontModuleFactory} factory
+   */
+  FontModuleLoader.prototype.addModuleFactory = function(name, factory) {
+    this.modules_[name] = factory;
+  };
 
-  for (var key in configuration) {
-    if (configuration.hasOwnProperty(key)) {
-      var moduleFactory = this.modules_[key];
+  /**
+   * @param {Object} configuration
+   * @param {webfont.DomHelper} domHelper
+   * @return {Array.<webfont.FontModule>}
+   */
+  FontModuleLoader.prototype.getModules = function(configuration, domHelper) {
+    var modules = [];
 
-      if (moduleFactory) {
-        modules.push(moduleFactory(configuration[key], domHelper));
+    for (var key in configuration) {
+      if (configuration.hasOwnProperty(key)) {
+        var moduleFactory = this.modules_[key];
+
+        if (moduleFactory) {
+          modules.push(moduleFactory(configuration[key], domHelper));
+        }
       }
     }
-  }
-  return modules;
-};
+    return modules;
+  };
+});