webfontloader 1.0.5

data/src/core/fontwatcher.js

@@ -0,0 +1,121 @@
+/**
+ * @constructor
+ */
+webfont.FontWatcher = function(domHelper, eventDispatcher, fontSizer,
+    asyncCall, getTime) {
+  this.domHelper_ = domHelper;
+  this.eventDispatcher_ = eventDispatcher;
+  this.fontSizer_ = fontSizer;
+  this.asyncCall_ = asyncCall;
+  this.getTime_ = getTime;
+  this.currentlyWatched_ = 0;
+  this.last_ = false;
+  this.success_ = false;
+  this.nameHelper_ = new webfont.CssFontFamilyName();
+  this.fvd_ = new webfont.FontVariationDescription();
+};
+
+webfont.FontWatcher.DEFAULT_FONT = '_,arial,helvetica';
+webfont.FontWatcher.DEFAULT_VARIATION = 'n4';
+
+webfont.FontWatcher.prototype.watch = function(fontFamilies, fontDescriptions, last) {
+  var length = fontFamilies.length;
+
+  for (var i = 0; i < length; i++) {
+    var fontFamily = fontFamilies[i];
+    if (!fontDescriptions[fontFamily]) {
+      fontDescriptions[fontFamily] = [webfont.FontWatcher.DEFAULT_VARIATION];
+    }
+    this.currentlyWatched_ += fontDescriptions[fontFamily].length;
+  }
+
+  if (last) {
+    this.last_ = last;
+  }
+
+  for (var i = 0; i < length; i++) {
+    var fontFamily = fontFamilies[i];
+    var descriptions = fontDescriptions[fontFamily];
+
+    for (var j = 0, len = descriptions.length; j < len; j++) {
+      var fontDescription = descriptions[j];
+      var originalSize = this.getDefaultFontSize_(fontDescription);
+
+      this.watch_(fontFamily, fontDescription, originalSize);
+    }
+  }
+};
+
+webfont.FontWatcher.prototype.watch_ = function(fontFamily, fontDescription, originalSize) {
+  this.eventDispatcher_.dispatchFontLoading(fontFamily, fontDescription);
+  var requestedFont = this.createHiddenElementWithFont_(this.nameHelper_.quote(fontFamily),
+      fontDescription);
+  var size = this.fontSizer_.getWidth(requestedFont);
+
+  if (originalSize != size) {
+    this.domHelper_.removeElement(requestedFont);
+    this.eventDispatcher_.dispatchFontActive(fontFamily, fontDescription);
+    this.success_ = true;
+    this.decreaseCurrentlyWatched_();
+  } else {
+    this.asyncCheck_(this.getTime_(), originalSize, requestedFont,
+        fontFamily, fontDescription);
+  }
+};
+
+webfont.FontWatcher.prototype.decreaseCurrentlyWatched_ = function() {
+  if (--this.currentlyWatched_ == 0 && this.last_) {
+    if (this.success_) {
+      this.eventDispatcher_.dispatchActive();
+    } else {
+      this.eventDispatcher_.dispatchInactive();
+    }
+  }
+};
+
+webfont.FontWatcher.prototype.check_ = function(started, originalSize,
+    requestedFont, fontFamily, fontDescription) {
+  var size = this.fontSizer_.getWidth(requestedFont);
+
+  if (originalSize != size) {
+    this.domHelper_.removeElement(requestedFont);
+    this.eventDispatcher_.dispatchFontActive(fontFamily, fontDescription);
+    this.success_ = true;
+    this.decreaseCurrentlyWatched_();
+  } else if ((this.getTime_() - started) < 5000) {
+    this.asyncCheck_(started, originalSize, requestedFont, fontFamily, fontDescription);
+  } else {
+    this.domHelper_.removeElement(requestedFont);
+    this.eventDispatcher_.dispatchFontInactive(fontFamily, fontDescription);
+    this.decreaseCurrentlyWatched_();
+  }
+};
+
+webfont.FontWatcher.prototype.asyncCheck_ = function(started, originalSize,
+    requestedFont, fontFamily, fontDescription) {
+  this.asyncCall_(function(context, func) {
+    return function() {
+      func.call(context, started, originalSize, requestedFont, fontFamily, fontDescription);
+    }
+  }(this, this.check_), 50);
+};
+
+webfont.FontWatcher.prototype.getDefaultFontSize_ = function(fontDescription) {
+  var defaultFont = this.createHiddenElementWithFont_(
+      webfont.FontWatcher.DEFAULT_FONT, fontDescription);
+  var size = this.fontSizer_.getWidth(defaultFont);
+
+  this.domHelper_.removeElement(defaultFont);
+  return size;
+};
+
+webfont.FontWatcher.prototype.createHiddenElementWithFont_ = function(
+    fontFamily, fontDescription) {
+  var variationCss = this.fvd_.expand(fontDescription);
+  var styleString = "position:absolute;top:-999px;font-size:300px;font-family:" +
+      fontFamily + "," + webfont.FontWatcher.DEFAULT_FONT + ";" + variationCss;
+  var span = this.domHelper_.createElement('span', { 'style': styleString }, 'Mm');
+
+  this.domHelper_.insertInto('body', span);
+  return span;
+};

data/src/core/initialize.js

@@ -0,0 +1,26 @@
+// Name of the global object.
+var globalName = 'WebFont';
+
+// Provide an instance of WebFont in the global namespace.
+window[globalName] = (function() {
+  var userAgentParser = new webfont.UserAgentParser(navigator.userAgent);
+  var userAgent = userAgentParser.parse();
+  var domHelper = new webfont.DomHelper(document, userAgent);
+  var asyncCall = function(func, timeout) { setTimeout(func, timeout); };
+
+  return new webfont.WebFont(domHelper, new webfont.FontModuleLoader(),
+      document.documentElement, asyncCall, userAgent);
+})();
+
+// Export the public API.
+window[globalName]['load'] = window[globalName].load;
+window[globalName]['addModule'] = window[globalName].addModule;
+
+// Export the UserAgent API because we pass this object to external modules.
+webfont.UserAgent.prototype['getName'] = webfont.UserAgent.prototype.getName;
+webfont.UserAgent.prototype['getVersion'] = webfont.UserAgent.prototype.getVersion;
+webfont.UserAgent.prototype['getEngine'] = webfont.UserAgent.prototype.getEngine;
+webfont.UserAgent.prototype['getEngineVersion'] = webfont.UserAgent.prototype.getEngineVersion;
+webfont.UserAgent.prototype['getPlatform'] = webfont.UserAgent.prototype.getPlatform;
+webfont.UserAgent.prototype['getPlatformVersion'] = webfont.UserAgent.prototype.getPlatformVersion;
+webfont.UserAgent.prototype['isSupportingWebFont'] = webfont.UserAgent.prototype.isSupportingWebFont;

data/src/core/namespace.js

@@ -0,0 +1,11 @@
+var webfont = {};
+
+webfont.bind = function(context, func, opt_args) {
+  var args = arguments.length > 2 ?
+      Array.prototype.slice.call(arguments, 2) : [];
+
+  return function() {
+    args.push.apply(args, arguments);
+    return func.apply(context, args);
+  };
+};

data/src/core/useragent.js

@@ -0,0 +1,41 @@
+/**
+ * @constructor
+ */
+webfont.UserAgent = function(name, version, engine, engineVersion, platform,
+    platformVersion, webFontSupport) {
+  this.name_ = name;
+  this.version_ = version;
+  this.engine_ = engine;
+  this.engineVersion_ = engineVersion;
+  this.platform_ = platform;
+  this.platformVersion_ = platformVersion;
+  this.webFontSupport_ = webFontSupport;
+};
+
+webfont.UserAgent.prototype.getName = function() {
+  return this.name_;
+};
+
+webfont.UserAgent.prototype.getVersion = function() {
+  return this.version_;
+};
+
+webfont.UserAgent.prototype.getEngine = function() {
+  return this.engine_;
+};
+
+webfont.UserAgent.prototype.getEngineVersion = function() {
+  return this.engineVersion_;
+};
+
+webfont.UserAgent.prototype.getPlatform = function() {
+  return this.platform_;
+};
+
+webfont.UserAgent.prototype.getPlatformVersion = function() {
+  return this.platformVersion_;
+};
+
+webfont.UserAgent.prototype.isSupportingWebFont = function() {
+  return this.webFontSupport_;
+};

data/src/core/useragentparser.js

@@ -0,0 +1,234 @@
+/**
+ * @constructor
+ */
+webfont.UserAgentParser = function(userAgent) {
+  this.userAgent_ = userAgent;
+};
+
+webfont.UserAgentParser.UNKNOWN = "Unknown";
+
+webfont.UserAgentParser.UNKNOWN_USER_AGENT = new webfont.UserAgent(webfont.UserAgentParser.UNKNOWN,
+    webfont.UserAgentParser.UNKNOWN, webfont.UserAgentParser.UNKNOWN, webfont.UserAgentParser.UNKNOWN, false);
+
+webfont.UserAgentParser.prototype.parse = function() {
+  if (this.isIe_()) {
+    return this.parseIeUserAgentString_();
+  } else if (this.isOpera_()) {
+    return this.parseOperaUserAgentString_();
+  } else if (this.isWebKit_()) {
+    return this.parseWebKitUserAgentString_();
+  } else if (this.isGecko_()) {
+    return this.parseGeckoUserAgentString_();
+  } else {
+    return webfont.UserAgentParser.UNKNOWN_USER_AGENT;
+  }
+};
+
+webfont.UserAgentParser.prototype.getPlatform_ = function() {
+  var mobileOs = this.getMatchingGroup_(this.userAgent_,
+      /(iPod|iPad|iPhone|Android)/, 1);
+
+  if (mobileOs != "") {
+    return mobileOs;
+  }
+  var os = this.getMatchingGroup_(this.userAgent_,
+      /(Linux|Mac_PowerPC|Macintosh|Windows)/, 1);
+
+  if (os != "") {
+    if (os == "Mac_PowerPC") {
+      os = "Macintosh";
+    }
+    return os;
+  }
+  return webfont.UserAgentParser.UNKNOWN;
+};
+
+webfont.UserAgentParser.prototype.getPlatformVersion_ = function() {
+  var macVersion = this.getMatchingGroup_(this.userAgent_,
+      /(OS X|Windows NT|Android) ([^;]+)/, 2);
+  if (macVersion) {
+    return macVersion;
+  }
+  var iVersion = this.getMatchingGroup_(this.userAgent_,
+      /(iPhone )?OS ([\d_]+)/, 2);
+  if (iVersion) {
+    return iVersion;
+  }
+  var linuxVersion = this.getMatchingGroup_(this.userAgent_,
+      /Linux ([i\d]+)/, 1);
+  if (linuxVersion) {
+    return linuxVersion;
+  }
+
+  return webfont.UserAgentParser.UNKNOWN;
+};
+
+webfont.UserAgentParser.prototype.isIe_ = function() {
+  return this.userAgent_.indexOf("MSIE") != -1;
+};
+
+webfont.UserAgentParser.prototype.parseIeUserAgentString_ = function() {
+  var browser = this.getMatchingGroup_(this.userAgent_, /(MSIE [\d\w\.]+)/, 1);
+  var engineName = webfont.UserAgentParser.UNKNOWN;
+  var engineVersion = webfont.UserAgentParser.UNKNOWN;
+
+  if (browser != "") {
+    var pair = browser.split(' ');
+    var name = pair[0];
+    var version = pair[1];
+
+    // For IE we give MSIE as the engine name and the version of IE
+    // instead of the specific Trident engine name and version
+    return new webfont.UserAgent(name, version, name, version,
+        this.getPlatform_(), this.getPlatformVersion_(), this.getMajorVersion_(version) >= 6);
+  }
+  return new webfont.UserAgent("MSIE", webfont.UserAgentParser.UNKNOWN,
+      "MSIE", webfont.UserAgentParser.UNKNOWN,
+      this.getPlatform_(), this.getPlatformVersion_(), false);
+};
+
+webfont.UserAgentParser.prototype.isOpera_ = function() {
+  return this.userAgent_.indexOf("Opera") != -1;
+};
+
+webfont.UserAgentParser.prototype.parseOperaUserAgentString_ = function() {
+  var engineName = webfont.UserAgentParser.UNKNOWN;
+  var engineVersion = webfont.UserAgentParser.UNKNOWN;
+  var enginePair = this.getMatchingGroup_(this.userAgent_,
+      /(Presto\/[\d\w\.]+)/, 1);
+
+  if (enginePair != "") {
+    var splittedEnginePair = enginePair.split('/');
+
+    engineName = splittedEnginePair[0];
+    engineVersion = splittedEnginePair[1];
+  } else {
+    if (this.userAgent_.indexOf("Gecko") != -1) {
+      engineName = "Gecko";
+    }
+    var geckoVersion = this.getMatchingGroup_(this.userAgent_, /rv:([^\)]+)/, 1);
+
+    if (geckoVersion != "") {
+      engineVersion = geckoVersion;
+    }
+  }
+  if (this.userAgent_.indexOf("Version/") != -1) {
+    var version = this.getMatchingGroup_(this.userAgent_, /Version\/([\d\.]+)/, 1);
+
+    if (version != "") {
+      return new webfont.UserAgent("Opera", version, engineName, engineVersion,
+          this.getPlatform_(), this.getPlatformVersion_(),
+          this.getMajorVersion_(version) >= 10);
+    }
+  }
+  var version = this.getMatchingGroup_(this.userAgent_, /Opera[\/ ]([\d\.]+)/, 1);
+
+  if (version != "") {
+    return new webfont.UserAgent("Opera", version, engineName, engineVersion,
+        this.getPlatform_(), this.getPlatformVersion_(), 
+        this.getMajorVersion_(version) >= 10);
+  }
+  return new webfont.UserAgent("Opera", webfont.UserAgentParser.UNKNOWN,
+      engineName, engineVersion, 
+      this.getPlatform_(), this.getPlatformVersion_(), false);
+};
+
+webfont.UserAgentParser.prototype.isWebKit_ = function() {
+  return this.userAgent_.indexOf("AppleWebKit") != -1;
+};
+
+webfont.UserAgentParser.prototype.parseWebKitUserAgentString_ = function() {
+  var platform = this.getPlatform_();
+  var platformVersion = this.getPlatformVersion_();
+  var webKitVersion = this.getMatchingGroup_(this.userAgent_,
+      /AppleWebKit\/([\d\.\+]+)/, 1);
+
+  if (webKitVersion == "") {
+    webKitVersion = webfont.UserAgentParser.UNKNOWN;
+  }
+  var name = webfont.UserAgentParser.UNKNOWN;
+
+  if (this.userAgent_.indexOf("Chrome") != -1) {
+    name = "Chrome";
+  } else if (this.userAgent_.indexOf("Safari") != -1) {
+    name = "Safari";
+  }
+  var version = webfont.UserAgentParser.UNKNOWN;
+
+  if (this.userAgent_.indexOf("Version/") != -1) {
+    version = this.getMatchingGroup_(this.userAgent_,
+        /Version\/([\d\.\w]+)/, 1);
+  } else if (name == "Chrome") {
+    version = this.getMatchingGroup_(this.userAgent_,
+        /Chrome\/([\d\.]+)/, 1);
+  }
+  var minor = this.getMatchingGroup_(webKitVersion, /\d+\.(\d+)/, 1);
+
+  return new webfont.UserAgent(name, version, "AppleWebKit", webKitVersion,
+      platform, platformVersion, this.getMajorVersion_(webKitVersion) >= 526 ||
+      this.getMajorVersion_(webKitVersion) >= 525 && parseInt(minor) >= 13);
+};
+
+webfont.UserAgentParser.prototype.isGecko_ = function() {
+  return this.userAgent_.indexOf("Gecko") != -1;
+};
+
+webfont.UserAgentParser.prototype.parseGeckoUserAgentString_ = function() {
+  var name = webfont.UserAgentParser.UNKNOWN;
+  var version = webfont.UserAgentParser.UNKNOWN;
+  var supportWebFont = false;
+
+  if (this.userAgent_.indexOf("Firefox") != -1) {
+    name = "Firefox";
+    var versionNum = this.getMatchingGroup_(this.userAgent_,
+        /Firefox\/([\d\w\.]+)/, 1);
+
+    if (versionNum != "") {
+      var minor = this.getMatchingGroup_(versionNum, /\d+\.(\d+)/, 1);
+
+      version = versionNum;
+      supportWebFont = versionNum != "" && this.getMajorVersion_(versionNum) >= 3 &&
+          parseInt(minor) >= 5;
+    }
+  } else if (this.userAgent_.indexOf("Mozilla") != -1) {
+    name = "Mozilla";
+  }
+  var geckoVersion = this.getMatchingGroup_(this.userAgent_, /rv:([^\)]+)/, 1);
+
+  if (geckoVersion == "") {
+    geckoVersion = webfont.UserAgentParser.UNKNOWN;
+  } else {
+    if (!supportWebFont) {
+      var majorVersion = this.getMajorVersion_(geckoVersion);
+      var intMinorVersion = parseInt(this.getMatchingGroup_(geckoVersion, /\d+\.(\d+)/, 1));
+      var subVersion = parseInt(this.getMatchingGroup_(geckoVersion, /\d+\.\d+\.(\d+)/, 1));
+
+      supportWebFont = majorVersion > 1 ||
+          majorVersion == 1 && intMinorVersion > 9 ||
+          majorVersion == 1 && intMinorVersion == 9 && subVersion >= 2 ||
+          geckoVersion.match(/1\.9\.1b[123]/) != null ||
+          geckoVersion.match(/1\.9\.1\.[\d\.]+/) != null;
+    }
+  }
+  return new webfont.UserAgent(name, version, "Gecko", geckoVersion,
+      this.getPlatform_(), this.getPlatformVersion_(), supportWebFont);
+};
+
+webfont.UserAgentParser.prototype.getMajorVersion_ = function(version) {
+  var majorVersion = this.getMatchingGroup_(version, /(\d+)/, 1);
+
+  if (majorVersion != "") {
+    return parseInt(majorVersion);
+  }
+  return -1;
+};
+
+webfont.UserAgentParser.prototype.getMatchingGroup_ = function(str,
+    regexp, index) {
+  var groups = str.match(regexp);
+
+  if (groups && groups[index]) {
+    return groups[index];
+  }
+  return "";
+};

data/src/custom/customcss.js

@@ -0,0 +1,37 @@
+/**
+ *
+ * WebFont.load({
+ *   custom: {
+ *     families: ['Font1', 'Font2'],
+ *    urls: [ 'http://moo', 'http://meuh' ] }
+ * });
+ *
+ * @constructor
+ */
+webfont.CustomCss = function(domHelper, configuration) {
+  this.domHelper_ = domHelper;
+  this.configuration_ = configuration;
+};
+
+webfont.CustomCss.NAME = 'custom';
+
+webfont.CustomCss.prototype.load = function(onReady) {
+  var urls = this.configuration_['urls'] || [];
+  var families = this.configuration_['families'] || [];
+
+  for (var i = 0, len = urls.length; i < len; i++) {
+    var url = urls[i];
+
+    this.domHelper_.insertInto('head', this.domHelper_.createCssLink(url));
+  }
+  onReady(families);
+};
+
+webfont.CustomCss.prototype.supportUserAgent = function(userAgent, support) {
+  return support(userAgent.isSupportingWebFont());
+};
+
+WebFont.addModule(webfont.CustomCss.NAME, function(configuration) {
+  return new webfont.CustomCss(new webfont.DomHelper(document),
+      configuration);
+});