webfontloader 1.0.5

data/src/async_load.js

@@ -0,0 +1,3 @@
+if (window['WebFontConfig']) {
+  window['WebFont']['load'](window['WebFontConfig']);
+}

data/src/closure.js

@@ -0,0 +1,3 @@
+;(function(window,document,undefined){
+{{source}}
+})(this,document);

data/src/core/cssclassname.js

@@ -0,0 +1,21 @@
+/**
+ * @constructor
+ */
+webfont.CssClassName = function(opt_joinChar) {
+  this.joinChar_ = opt_joinChar || webfont.CssClassName.DEFAULT_JOIN_CHAR;
+};
+
+webfont.CssClassName.DEFAULT_JOIN_CHAR = '-';
+
+webfont.CssClassName.prototype.sanitize = function(name) {
+  return name.replace(/[\W_]+/g, '').toLowerCase();
+};
+
+webfont.CssClassName.prototype.build = function(__args__) {
+  var parts = []
+  for (var i = 0; i < arguments.length; i++) {
+    parts.push(this.sanitize(arguments[i]));
+  }
+  return parts.join(this.joinChar_);
+};
+

data/src/core/cssfontfamilyname.js

@@ -0,0 +1,20 @@
+/**
+ * @constructor
+ */
+webfont.CssFontFamilyName = function() {
+  this.quote_ = '"';
+};
+
+webfont.CssFontFamilyName.prototype.quote = function(name) {
+  var quoted = [];
+  var split = name.split(/,\s*/);
+  for (var i = 0; i < split.length; i++) {
+    var part = split[i].replace(/['"]/g, '');
+    if (part.indexOf(' ') == -1) {
+      quoted.push(part);
+    } else {
+      quoted.push(this.quote_ + part + this.quote_);
+    }
+  }
+  return quoted.join(',');
+};

data/src/core/domhelper.js

@@ -0,0 +1,103 @@
+/**
+ * @constructor
+ */
+webfont.DomHelper = function(doc, userAgent) {
+  this.document_ = doc;
+  this.userAgent_ = userAgent;
+};
+
+webfont.DomHelper.prototype.createElement = function(elem, opt_attr,
+    opt_innerHtml) {
+  var domElement = this.document_.createElement(elem);
+
+  if (opt_attr) {
+    for (var attr in opt_attr) {
+      // protect against native prototype augmentations
+      if (opt_attr.hasOwnProperty(attr)) {
+        if (attr == "style" && this.userAgent_.getName() == "MSIE") {
+          domElement.style.cssText = opt_attr[attr];
+        } else {
+          domElement.setAttribute(attr, opt_attr[attr]);
+        }
+      }
+    }
+  }
+  if (opt_innerHtml) {
+    domElement.appendChild(this.document_.createTextNode(opt_innerHtml));
+  }
+  return domElement;
+};
+
+webfont.DomHelper.prototype.insertInto = function(tagName, e) {
+  var t = this.document_.getElementsByTagName(tagName)[0];
+
+  if (!t) { // opera allows documents without a head
+    t = document.documentElement;
+  }
+
+  if (t && t.lastChild) {
+    // This is safer than appendChild in IE. appendChild causes random
+    // JS errors in IE. Sometimes errors in other JS exectution, sometimes
+    // complete 'This page cannot be displayed' errors. For our purposes,
+    // it's equivalent because we don't need to insert at any specific
+    // location.
+    t.insertBefore(e, t.lastChild);
+    return true;
+  }
+  return false;
+};
+
+webfont.DomHelper.prototype.whenBodyExists = function(callback) {
+  var check = function() {
+    if (document.body) {
+      callback();
+    } else {
+      setTimeout(check, 0);
+    }
+  }
+  check();
+};
+
+webfont.DomHelper.prototype.removeElement = function(node) {
+  if (node.parentNode) {
+    node.parentNode.removeChild(node);
+    return true;
+  }
+  return false;
+};
+
+webfont.DomHelper.prototype.createCssLink = function(src) {
+  return this.createElement('link', {
+    'rel': 'stylesheet',
+    'href': src
+  });
+};
+
+webfont.DomHelper.prototype.createScriptSrc = function(src) {
+  return this.createElement('script', {
+    'src': src
+  });
+};
+
+webfont.DomHelper.prototype.appendClassName = function(e, name) {
+  var classes = e.className.split(/\s+/);
+  for (var i = 0, len = classes.length; i < len; i++) {
+    if (classes[i] == name) {
+      return;
+    }
+  }
+  classes.push(name);
+  e.className = classes.join(' ').replace(/^\s+/, '');
+};
+
+webfont.DomHelper.prototype.removeClassName = function(e, name) {
+  var classes = e.className.split(/\s+/);
+  var remainingClasses = [];
+  for (var i = 0, len = classes.length; i < len; i++) {
+    if (classes[i] != name) {
+      remainingClasses.push(classes[i]);
+    }
+  }
+  e.className = remainingClasses.join(' ').replace(/^\s+/, '')
+      .replace(/\s+$/, '');
+};

data/src/core/eventdispatcher.js

@@ -0,0 +1,78 @@
+/**
+ * @constructor
+ */
+webfont.EventDispatcher = function(domHelper, htmlElement, callbacks,
+    opt_namespace) {
+  this.domHelper_ = domHelper;
+  this.htmlElement_ = htmlElement;
+  this.callbacks_ = callbacks;
+  this.namespace_ = opt_namespace || webfont.EventDispatcher.DEFAULT_NAMESPACE;
+  this.cssClassName_ = new webfont.CssClassName('-');
+};
+
+webfont.EventDispatcher.DEFAULT_NAMESPACE = 'wf';
+webfont.EventDispatcher.LOADING = 'loading';
+webfont.EventDispatcher.ACTIVE = 'active';
+webfont.EventDispatcher.INACTIVE = 'inactive';
+webfont.EventDispatcher.FONT = 'font';
+
+webfont.EventDispatcher.prototype.dispatchLoading = function() {
+  this.domHelper_.appendClassName(this.htmlElement_,
+      this.cssClassName_.build(
+          this.namespace_, webfont.EventDispatcher.LOADING));
+  this.dispatch_(webfont.EventDispatcher.LOADING);
+};
+
+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);
+};
+
+webfont.EventDispatcher.prototype.dispatchFontActive = function(fontFamily, fontDescription) {
+  this.domHelper_.removeClassName(this.htmlElement_,
+      this.cssClassName_.build(
+          this.namespace_, fontFamily, fontDescription, webfont.EventDispatcher.LOADING));
+  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);
+};
+
+webfont.EventDispatcher.prototype.dispatchFontInactive = function(fontFamily, fontDescription) {
+  this.domHelper_.removeClassName(this.htmlElement_,
+      this.cssClassName_.build(
+          this.namespace_, fontFamily, fontDescription, webfont.EventDispatcher.LOADING));
+  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);
+};
+
+webfont.EventDispatcher.prototype.dispatchInactive = function() {
+  this.domHelper_.appendClassName(this.htmlElement_,
+      this.cssClassName_.build(
+        this.namespace_, webfont.EventDispatcher.INACTIVE));
+  this.dispatch_(webfont.EventDispatcher.INACTIVE);
+};
+
+webfont.EventDispatcher.prototype.dispatchActive = function() {
+  // what about inactive? maybe if all fonts failed to load?
+  this.domHelper_.removeClassName(this.htmlElement_,
+      this.cssClassName_.build(
+          this.namespace_, webfont.EventDispatcher.LOADING));
+  this.domHelper_.appendClassName(this.htmlElement_,
+      this.cssClassName_.build(
+          this.namespace_, webfont.EventDispatcher.ACTIVE));
+  this.dispatch_(webfont.EventDispatcher.ACTIVE);
+};
+
+webfont.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

@@ -0,0 +1,84 @@
+/**
+ * @constructor
+ */
+webfont.WebFont = function(domHelper, fontModuleLoader, htmlElement, asyncCall,
+    userAgent) {
+  this.domHelper_ = domHelper;
+  this.fontModuleLoader_ = fontModuleLoader;
+  this.htmlElement_ = htmlElement;
+  this.asyncCall_ = asyncCall;
+  this.userAgent_ = userAgent;
+  this.moduleLoading_ = 0;
+  this.moduleFailedLoading_ = 0;
+};
+
+webfont.WebFont.prototype.addModule = function(name, factory) {
+  this.fontModuleLoader_.addModuleFactory(name, factory);
+};
+
+webfont.WebFont.prototype.load = function(configuration) {
+  var eventDispatcher = new webfont.EventDispatcher(
+      this.domHelper_, this.htmlElement_, configuration);
+
+  if (this.userAgent_.isSupportingWebFont()) {
+    this.load_(eventDispatcher, configuration);
+  } else {
+    eventDispatcher.dispatchInactive();
+  }
+};
+
+webfont.WebFont.prototype.isModuleSupportingUserAgent_ = function(module, eventDispatcher,
+    fontWatcher, support) {
+  if (!support) {
+    var allModulesLoaded = --this.moduleLoading_ == 0;
+
+    this.moduleFailedLoading_--;
+    if (allModulesLoaded) {
+      if (this.moduleFailedLoading_ == 0) {
+        eventDispatcher.dispatchInactive();
+      } else {
+        eventDispatcher.dispatchLoading();
+      }
+    }
+    fontWatcher.watch([], {}, allModulesLoaded);
+    return;
+  }
+  module.load(webfont.bind(this, this.onModuleReady_, eventDispatcher,
+      fontWatcher));
+};
+
+webfont.WebFont.prototype.onModuleReady_ = function(eventDispatcher, fontWatcher,
+    fontFamilies, opt_fontDescriptions) {
+  var allModulesLoaded = --this.moduleLoading_ == 0;
+
+  if (allModulesLoaded) {
+    eventDispatcher.dispatchLoading();
+  }
+  this.asyncCall_(webfont.bind(this, function(_fontWatcher, _fontFamilies,
+      _fontDescriptions, _allModulesLoaded) {
+    _fontWatcher.watch(_fontFamilies, _fontDescriptions || {}, _allModulesLoaded);
+  }, fontWatcher, fontFamilies, opt_fontDescriptions, allModulesLoaded));
+};
+
+webfont.WebFont.prototype.load_ = function(eventDispatcher, configuration) {
+  var modules = this.fontModuleLoader_.getModules(configuration),
+      self = this;
+
+  this.moduleFailedLoading_ = this.moduleLoading_ = modules.length;
+
+  var fontWatcher = new webfont.FontWatcher(this.domHelper_,
+      eventDispatcher, {
+        getWidth: function(elem) {
+          return elem.offsetWidth;
+        }}, self.asyncCall_, function() {
+          return new Date().getTime();
+        });
+
+  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));
+  }
+};

data/src/core/fontmoduleloader.js

@@ -0,0 +1,25 @@
+/**
+ * @constructor
+ */
+webfont.FontModuleLoader = function() {
+  this.modules_ = {};
+};
+
+webfont.FontModuleLoader.prototype.addModuleFactory = function(name, factory) {
+  this.modules_[name] = factory;
+};
+
+webfont.FontModuleLoader.prototype.getModules = function(configuration) {
+  var modules = [];
+
+  for (var key in configuration) {
+    if (configuration.hasOwnProperty(key)) {
+      var moduleFactory = this.modules_[key];
+
+      if (moduleFactory) {
+        modules.push(moduleFactory(configuration[key]));
+      }
+    }
+  }
+  return modules;
+};

data/src/core/fontvariationdescription.js

@@ -0,0 +1,112 @@
+/**
+ * @constructor
+ */
+webfont.FontVariationDescription = function() {
+  this.properties_ = webfont.FontVariationDescription.PROPERTIES;
+  this.values_ = webfont.FontVariationDescription.VALUES;
+};
+
+webfont.FontVariationDescription.PROPERTIES = [
+  'font-style',
+  'font-weight'
+];
+
+webfont.FontVariationDescription.VALUES = {
+  'font-style': [
+    ['n', 'normal'],
+    ['i', 'italic'],
+    ['o', 'oblique']
+  ],
+  'font-weight': [
+    ['1', '100'],
+    ['2', '200'],
+    ['3', '300'],
+    ['4', '400'],
+    ['5', '500'],
+    ['6', '600'],
+    ['7', '700'],
+    ['8', '800'],
+    ['9', '900'],
+    ['4', 'normal'],
+    ['7', 'bold']
+  ]
+};
+
+/**
+ * @constructor
+ */
+webfont.FontVariationDescription.Item = function(index, property, values) {
+  this.index_ = index;
+  this.property_ = property;
+  this.values_ = values;
+}
+
+webfont.FontVariationDescription.Item.prototype.compact = function(output, value) {
+  for (var i = 0; i < this.values_.length; i++) {
+    if (value == this.values_[i][1]) {
+      output[this.index_] = this.values_[i][0];
+      return;
+    }
+  }
+}
+
+webfont.FontVariationDescription.Item.prototype.expand = function(output, value) {
+  for (var i = 0; i < this.values_.length; i++) {
+    if (value == this.values_[i][0]) {
+      output[this.index_] = this.property_ + ':' + this.values_[i][1];
+      return;
+    }
+  }
+}
+
+webfont.FontVariationDescription.prototype.compact = function(input) {
+  var result = ['n', '4'];
+  var descriptors = input.split(';');
+
+  for (var i = 0, len = descriptors.length; i < len; i++) {
+    var pair = descriptors[i].replace(/\s+/g, '').split(':');
+    if (pair.length == 2) {
+      var property = pair[0];
+      var value = pair[1];
+      var item = this.getItem_(property);
+      if (item) {
+        item.compact(result, value);
+      }
+    }
+  }
+
+  return result.join('');
+};
+
+webfont.FontVariationDescription.prototype.expand = function(fvd) {
+  if (fvd.length != 2) {
+    return null;
+  }
+
+  var result = [null, null];
+
+  for (var i = 0, len = this.properties_.length; i < len; i++) {
+    var property = this.properties_[i];
+    var key = fvd.substr(i, 1);
+    var values = this.values_[property];
+    var item = new webfont.FontVariationDescription.Item(i, property, values);
+    item.expand(result, key);
+  }
+
+  if (result[0] && result[1]) {
+    return result.join(';') + ';';
+  } else {
+    return null;
+  }
+}
+
+webfont.FontVariationDescription.prototype.getItem_ = function(property) {
+  for (var i = 0; i < this.properties_.length; i++) {
+    if (property == this.properties_[i]) {
+      var values = this.values_[property];
+      return new webfont.FontVariationDescription.Item(i, property, values);
+    }
+  }
+
+  return null;
+};