RubyGems - k4compiler - Versions diffs - 0.0.1 - Mend

k4compiler 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1898) hide show

data/third_party/closure-library/closure/goog/ui/editor/bubble_test.html ADDED Viewed

@@ -0,0 +1,264 @@
+<!DOCTYPE html>
+<!--
+  All Rights Reserved.
+  @author tildahl@google.com (Michael Tildahl)
+  @author robbyw@google.com (Robby Walker)
+-->
+<html>
+<!--
+Copyright 2008 The Closure Library Authors. All Rights Reserved.
+Use of this source code is governed by the Apache License, Version 2.0.
+See the COPYING file for details.
+-->
+<head>
+<meta http-equiv="X-UA-Compatible" content="IE=edge">
+<title>Closure Unit Tests - goog.ui.editor.Bubble</title>
+<script src="../../base.js"></script>
+<script>
+  goog.require('goog.dom');
+  goog.require('goog.dom.TagName');
+  goog.require('goog.events.BrowserEvent');
+  goog.require('goog.events.EventType');
+  goog.require('goog.events.KeyCodes');
+  goog.require('goog.string');
+  goog.require('goog.style');
+  goog.require('goog.testing.editor.TestHelper');
+  goog.require('goog.testing.editor.FieldMock');
+  goog.require('goog.testing.events');
+  goog.require('goog.testing.jsunit');
+  goog.require('goog.testing.LooseMock');
+  goog.require('goog.ui.editor.Bubble');
+  goog.require('goog.userAgent');
+</script>
+<link rel="stylesheet" type="text/css" href="../../css/editor/bubble.css">
+</head>
+<body>
+<div id="field"></div>
+<script>
+var testHelper;
+var fieldDiv = goog.dom.getElement('field');
+var bubble;
+var link;
+var link2;
+var panelId;
+function setUpPage() {
+  var viewportSize = goog.dom.getViewportSize();
+  // Some tests depends on enough size of viewport.
+  if (viewportSize.width < 600 || viewportSize.height < 440) {
+    window.moveTo(0, 0);
+    window.resizeTo(640, 480);
+  }
+};
+function setUp() {
+  testHelper = new goog.testing.editor.TestHelper(fieldDiv);
+  testHelper.setUpEditableElement();
+  bubble = new goog.ui.editor.Bubble(document.body, 999);
+  fieldDiv.innerHTML = '<a href="http://www.google.com">Google</a>' +
+      '<a href="http://www.google.com">Google2</a>';
+  link = fieldDiv.firstChild;
+  link2 = fieldDiv.lastChild;
+  window.scrollTo(0, 0);
+  goog.style.setStyle(document.body, 'direction', 'ltr');
+  goog.style.setStyle(document.getElementById('field'), 'position', 'static');
+}
+function tearDown() {
+  if (panelId) {
+    bubble.removePanel(panelId);
+  }
+  testHelper.tearDownEditableElement();
+}
+/**
+ * This is a helper function for setting up the target element with a
+ * given direction.
+ *
+ * @param {string} dir The direction of the target element, 'ltr' or 'rtl'.
+ * @param {boolean=} opt_preferTopPosition Whether to prefer placing the bubble
+ *     above the element instead of below it.  Defaults to preferring below.
+ */
+function prepareTargetWithGivenDirection(dir, opt_preferTopPosition) {
+  goog.style.setStyle(document.body, 'direction', dir);
+  fieldDiv.style.direction = dir;
+  fieldDiv.innerHTML = '<a href="http://www.google.com">Google</a>';
+  link = fieldDiv.firstChild;
+  panelId = bubble.addPanel('A', 'Link', link, function(el) {
+    el.innerHTML = '<div style="border:1px solid blue;">B</div>';
+  }, opt_preferTopPosition);
+}
+/**
+ * This is a helper function for getting the expected position of the bubble.
+ * (align to the right or the left of the target element).  Align left by
+ * default and align right if opt_alignRight is true. The expected Y is
+ * unaffected by alignment.
+ *
+ * @param {boolean=} opt_alignRight Sets the expected alignment to be right.
+ */
+function getExpectedBubblePositionWithGivenAlignment(opt_alignRight) {
+  var targetPosition = goog.style.getFramedPageOffset(link, window);
+  var targetWidth = link.offsetWidth;
+  var bubbleSize = goog.style.getSize(bubble.bubbleContainer_);
+  var expectedBubbleX = opt_alignRight ?
+      targetPosition.x + targetWidth - bubbleSize.width : targetPosition.x;
+  var expectedBubbleY = link.offsetHeight + targetPosition.y +
+      goog.ui.editor.Bubble.VERTICAL_CLEARANCE_;
+  return {
+    x: expectedBubbleX,
+    y: expectedBubbleY
+  };
+}
+function testCreateBubbleWithLinkPanel() {
+  var id = goog.string.createUniqueString();
+  panelId = bubble.addPanel("A", "Link", link, function(container) {
+    container.innerHTML = '<span id="' + id + '">Test</span>';
+  });
+  assertNotNull('Bubble should be created', bubble.bubbleContents_);
+  assertNotNull('Added element should be present', goog.dom.getElement(id));
+  assertTrue('Bubble should be visible', bubble.isVisible());
+}
+function testCloseBubble() {
+  testCreateBubbleWithLinkPanel();
+  var count = 0;
+  goog.events.listen(bubble, goog.ui.Component.EventType.HIDE, function() {
+    count++;
+  });
+  bubble.removePanel(panelId);
+  panelId = null;
+  assertFalse('Bubble should not be visible', bubble.isVisible());
+  assertEquals('Hide event should be dispatched', 1, count);
+}
+function testCloseBox() {
+  testCreateBubbleWithLinkPanel();
+  var count = 0;
+  goog.events.listen(bubble, goog.ui.Component.EventType.HIDE, function() {
+    count++;
+  });
+  var closeBox = goog.dom.getElementsByTagNameAndClass(
+      goog.dom.TagName.DIV, 'tr_bubble_closebox', bubble.bubbleContainer_)[0];
+  goog.testing.events.fireClickSequence(closeBox);
+  panelId = null;
+  assertFalse('Bubble should not be visible', bubble.isVisible());
+  assertEquals('Hide event should be dispatched', 1, count);
+}
+function testViewPortSizeMonitorEvent() {
+  testCreateBubbleWithLinkPanel();
+  var numCalled = 0;
+  bubble.reposition = function() {
+    numCalled++;
+  };
+  assertNotUndefined('viewPortSizeMonitor_ should not be undefined',
+      bubble.viewPortSizeMonitor_);
+  bubble.viewPortSizeMonitor_.dispatchEvent(goog.events.EventType.RESIZE);
+  assertEquals('reposition not called', 1, numCalled);
+}
+function testBubblePositionPreferTop() {
+  called = false;
+  bubble.positionAtAnchor_ = function(targetCorner, bubbleCorner, overflow) {
+    called = true;
+    // Assert that the bubble is positioned below the target.
+    assertEquals(goog.positioning.Corner.TOP_START, targetCorner);
+    assertEquals(goog.positioning.Corner.BOTTOM_START, bubbleCorner);
+    return goog.positioning.OverflowStatus.NONE;
+  };
+  prepareTargetWithGivenDirection('ltr', true);
+  assertTrue(called);
+}
+function testBubblePosition() {
+  panelId = bubble.addPanel('A', 'Link', link, goog.nullFunction);
+  var CLEARANCE = goog.ui.editor.Bubble.VERTICAL_CLEARANCE_;
+  var bubbleContainer = bubble.bubbleContainer_;
+  // The field is at a normal place, alomost the top of the viewport, and
+  // there is enough space at the bottom of the field.
+  var targetPos = goog.style.getFramedPageOffset(link, window);
+  var targetSize = goog.style.getSize(link);
+  var pos = goog.style.getFramedPageOffset(bubbleContainer);
+  assertEquals(targetPos.y + targetSize.height + CLEARANCE, pos.y);
+  assertEquals(targetPos.x, pos.x);
+  // Move the target to the bottom of the viewport.
+  var field = document.getElementById('field');
+  var fieldPos = goog.style.getFramedPageOffset(field, window);
+  fieldPos.y += bubble.dom_.getViewportSize().height -
+      (targetPos.y + targetSize.height);
+  goog.style.setStyle(field, 'position', 'absolute');
+  goog.style.setPosition(field, fieldPos);
+  bubble.reposition();
+  var bubbleSize = goog.style.getSize(bubbleContainer);
+  targetPosition = goog.style.getFramedPageOffset(link, window);
+  pos = goog.style.getFramedPageOffset(bubbleContainer);
+  assertEquals(targetPosition.y - CLEARANCE - bubbleSize.height, pos.y);
+}
+function testBubblePositionRightAligned() {
+  prepareTargetWithGivenDirection('rtl');
+  var expectedPos = getExpectedBubblePositionWithGivenAlignment(true);
+  var pos = goog.style.getFramedPageOffset(bubble.bubbleContainer_);
+  assertEquals(expectedPos.x, pos.x);
+  assertEquals(expectedPos.y, pos.y);
+}
+/**
+ * Test for bug 1955511, the bubble should align to the right side
+ * of the target element when the bubble is RTL, regardless of the
+ * target element's directionality.
+ */
+function testBubblePositionLeftToRight() {
+  goog.style.setStyle(bubble.bubbleContainer_, 'direction', 'ltr');
+  prepareTargetWithGivenDirection('rtl');
+  var expectedPos = getExpectedBubblePositionWithGivenAlignment();
+  var pos = goog.style.getFramedPageOffset(bubble.bubbleContainer_);
+  assertEquals(expectedPos.x, pos.x);
+  assertEquals(expectedPos.y, pos.y);
+}
+/**
+ * Test for bug 1955511, the bubble should align to the left side
+ * of the target element when the bubble is LTR, regardless of the
+ * target element's directionality.
+ */
+function testBubblePositionRightToLeft() {
+  goog.style.setStyle(bubble.bubbleContainer_, 'direction', 'rtl');
+  prepareTargetWithGivenDirection('ltr');
+  var expectedPos = getExpectedBubblePositionWithGivenAlignment(true);
+  var pos = goog.style.getFramedPageOffset(bubble.bubbleContainer_);
+  assertEquals(expectedPos.x, pos.x);
+  assertEquals(expectedPos.y, pos.y);
+}
+</script>
+</body>
+</html>

data/third_party/closure-library/closure/goog/ui/editor/defaulttoolbar.js ADDED Viewed

@@ -0,0 +1,1065 @@
+// Copyright 2008 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+/**
+ * @fileoverview Factory functions for creating a default editing toolbar.
+ *
+ * @author attila@google.com (Attila Bodis)
+ * @author jparent@google.com (Julie Parent)
+ * @see ../../demos/editor/editor.html
+ */
+goog.provide('goog.ui.editor.ButtonDescriptor');
+goog.provide('goog.ui.editor.DefaultToolbar');
+goog.require('goog.dom');
+goog.require('goog.dom.TagName');
+goog.require('goog.dom.classes');
+goog.require('goog.editor.Command');
+goog.require('goog.style');
+goog.require('goog.ui.editor.ToolbarFactory');
+goog.require('goog.ui.editor.messages');
+goog.require('goog.userAgent');
+// Font menu creation.
+/** @desc Font menu item caption for the default sans-serif font. */
+goog.ui.editor.DefaultToolbar.MSG_FONT_NORMAL = goog.getMsg('Normal');
+/** @desc Font menu item caption for the default serif font. */
+goog.ui.editor.DefaultToolbar.MSG_FONT_NORMAL_SERIF =
+    goog.getMsg('Normal / serif');
+/**
+ * Common font descriptors for all locales.  Each descriptor has the following
+ * attributes:
+ * <ul>
+ *   <li>{@code caption} - Caption to show in the font menu (e.g. 'Tahoma')
+ *   <li>{@code value} - Value for the corresponding 'font-family' CSS style
+ *       (e.g. 'Tahoma, Arial, sans-serif')
+ * </ul>
+ * @type {!Array.<{caption:string, value:string}>}
+ * @private
+ */
+goog.ui.editor.DefaultToolbar.FONTS_ = [
+  {
+    caption: goog.ui.editor.DefaultToolbar.MSG_FONT_NORMAL,
+    value: 'arial,sans-serif'
+  },
+  {
+    caption: goog.ui.editor.DefaultToolbar.MSG_FONT_NORMAL_SERIF,
+    value: 'times new roman,serif'
+  },
+  {caption: 'Courier New', value: 'courier new,monospace'},
+  {caption: 'Georgia', value: 'georgia,serif'},
+  {caption: 'Trebuchet', value: 'trebuchet ms,sans-serif'},
+  {caption: 'Verdana', value: 'verdana,sans-serif'}
+];
+/**
+ * Locale-specific font descriptors.  The object is a map of locale strings to
+ * arrays of font descriptors.
+ * @type {!Object.<!Array.<{caption:string, value:string}>>}
+ * @private
+ */
+goog.ui.editor.DefaultToolbar.I18N_FONTS_ = {
+  'ja': [{
+    caption: '\uff2d\uff33 \uff30\u30b4\u30b7\u30c3\u30af',
+    value: 'ms pgothic,sans-serif'
+  }, {
+    caption: '\uff2d\uff33 \uff30\u660e\u671d',
+    value: 'ms pmincho,serif'
+  }, {
+    caption: '\uff2d\uff33 \u30b4\u30b7\u30c3\u30af',
+    value: 'ms gothic,monospace'
+  }],
+  'ko': [{
+    caption: '\uad74\ub9bc',
+    value: 'gulim,sans-serif'
+  }, {
+    caption: '\ubc14\ud0d5',
+    value: 'batang,serif'
+  }, {
+    caption: '\uad74\ub9bc\uccb4',
+    value: 'gulimche,monospace'
+  }],
+  'zh-tw': [{
+    caption: '\u65b0\u7d30\u660e\u9ad4',
+    value: 'pmingliu,serif'
+  }, {
+    caption: '\u7d30\u660e\u9ad4',
+    value: 'mingliu,serif'
+  }],
+  'zh-cn': [{
+    caption: '\u5b8b\u4f53',
+    value: 'simsun,serif'
+  }, {
+    caption: '\u9ed1\u4f53',
+    value: 'simhei,sans-serif'
+  }, {
+    caption: 'MS Song',
+    value: 'ms song,monospace'
+  }]
+};
+/**
+ * Default locale for font names.
+ * @type {string}
+ * @private
+ */
+goog.ui.editor.DefaultToolbar.locale_ = 'en-us';
+/**
+ * Sets the locale for the font names.  If not set, defaults to 'en-us'.
+ * Used only for default creation of font names name.  Must be set
+ * before font name menu is created.
+ * @param {string} locale Locale to use for the toolbar font names.
+ */
+goog.ui.editor.DefaultToolbar.setLocale = function(locale) {
+  goog.ui.editor.DefaultToolbar.locale_ = locale;
+};
+/**
+ * Initializes the given font menu button by adding default fonts to the menu.
+ * If goog.ui.editor.DefaultToolbar.setLocale was called to specify a locale
+ * for which locale-specific default fonts exist, those are added before
+ * common fonts.
+ * @param {!goog.ui.Select} button Font menu button.
+ */
+goog.ui.editor.DefaultToolbar.addDefaultFonts = function(button) {
+  // Normalize locale to lowercase, with a hyphen (see bug 1036165).
+  var locale =
+      goog.ui.editor.DefaultToolbar.locale_.replace(/_/, '-').toLowerCase();
+  // Add locale-specific default fonts, if any.
+  var fontlist = [];
+  if (locale in goog.ui.editor.DefaultToolbar.I18N_FONTS_) {
+    fontlist = goog.ui.editor.DefaultToolbar.I18N_FONTS_[locale];
+  }
+  if (fontlist.length) {
+    goog.ui.editor.ToolbarFactory.addFonts(button, fontlist);
+  }
+  // Add locale-independent default fonts.
+  goog.ui.editor.ToolbarFactory.addFonts(button,
+      goog.ui.editor.DefaultToolbar.FONTS_);
+};
+// Font size menu creation.
+/** @desc Font size menu item caption for the 'Small' size. */
+goog.ui.editor.DefaultToolbar.MSG_FONT_SIZE_SMALL = goog.getMsg('Small');
+/** @desc Font size menu item caption for the 'Normal' size. */
+goog.ui.editor.DefaultToolbar.MSG_FONT_SIZE_NORMAL = goog.getMsg('Normal');
+/** @desc Font size menu item caption for the 'Large' size. */
+goog.ui.editor.DefaultToolbar.MSG_FONT_SIZE_LARGE = goog.getMsg('Large');
+/** @desc Font size menu item caption for the 'Huge' size. */
+goog.ui.editor.DefaultToolbar.MSG_FONT_SIZE_HUGE = goog.getMsg('Huge');
+/**
+ * Font size descriptors, each with the following attributes:
+ * <ul>
+ *   <li>{@code caption} - Caption to show in the font size menu (e.g. 'Huge')
+ *   <li>{@code value} - Value for the corresponding HTML font size (e.g. 6)
+ * </ul>
+ * @type {!Array.<{caption:string, value:number}>}
+ * @private
+ */
+goog.ui.editor.DefaultToolbar.FONT_SIZES_ = [
+  {caption: goog.ui.editor.DefaultToolbar.MSG_FONT_SIZE_SMALL, value: 1},
+  {caption: goog.ui.editor.DefaultToolbar.MSG_FONT_SIZE_NORMAL, value: 2},
+  {caption: goog.ui.editor.DefaultToolbar.MSG_FONT_SIZE_LARGE, value: 4},
+  {caption: goog.ui.editor.DefaultToolbar.MSG_FONT_SIZE_HUGE, value: 6}
+];
+/**
+ * Initializes the given font size menu button by adding default font sizes to
+ * it.
+ * @param {!goog.ui.Select} button Font size menu button.
+ */
+goog.ui.editor.DefaultToolbar.addDefaultFontSizes = function(button) {
+  goog.ui.editor.ToolbarFactory.addFontSizes(button,
+      goog.ui.editor.DefaultToolbar.FONT_SIZES_);
+};
+// Header format menu creation.
+/** @desc Caption for "Heading" block format option. */
+goog.ui.editor.DefaultToolbar.MSG_FORMAT_HEADING = goog.getMsg('Heading');
+/** @desc Caption for "Subheading" block format option. */
+goog.ui.editor.DefaultToolbar.MSG_FORMAT_SUBHEADING = goog.getMsg('Subheading');
+/** @desc Caption for "Minor heading" block format option. */
+goog.ui.editor.DefaultToolbar.MSG_FORMAT_MINOR_HEADING =
+    goog.getMsg('Minor heading');
+/** @desc Caption for "Normal" block format option. */
+goog.ui.editor.DefaultToolbar.MSG_FORMAT_NORMAL = goog.getMsg('Normal');
+/**
+ * Format option descriptors, each with the following attributes:
+ * <ul>
+ *   <li>{@code caption} - Caption to show in the menu (e.g. 'Minor heading')
+ *   <li>{@code command} - Corresponding {@link goog.dom.TagName} (e.g.
+ *       'H4')
+ * </ul>
+ * @type {!Array.<{caption: string, command: !goog.dom.TagName}>}
+ * @private
+ */
+goog.ui.editor.DefaultToolbar.FORMAT_OPTIONS_ = [
+  {
+    caption: goog.ui.editor.DefaultToolbar.MSG_FORMAT_HEADING,
+    command: goog.dom.TagName.H2
+  },
+  {
+    caption: goog.ui.editor.DefaultToolbar.MSG_FORMAT_SUBHEADING,
+    command: goog.dom.TagName.H3
+  },
+  {
+    caption: goog.ui.editor.DefaultToolbar.MSG_FORMAT_MINOR_HEADING,
+    command: goog.dom.TagName.H4
+  },
+  {
+    caption: goog.ui.editor.DefaultToolbar.MSG_FORMAT_NORMAL,
+    command: goog.dom.TagName.P
+  }
+];
+/**
+ * Initializes the given "Format block" menu button by adding default format
+ * options to the menu.
+ * @param {!goog.ui.Select} button "Format block" menu button.
+ */
+goog.ui.editor.DefaultToolbar.addDefaultFormatOptions = function(button) {
+  goog.ui.editor.ToolbarFactory.addFormatOptions(button,
+      goog.ui.editor.DefaultToolbar.FORMAT_OPTIONS_);
+};
+/**
+ * Creates a {@link goog.ui.Toolbar} containing a default set of editor
+ * toolbar buttons, and renders it into the given parent element.
+ * @param {!Element} elem Toolbar parent element.
+ * @param {boolean=} opt_isRightToLeft Whether the editor chrome is
+ *     right-to-left; defaults to the directionality of the toolbar parent
+ *     element.
+ * @return {!goog.ui.Toolbar} Default editor toolbar, rendered into the given
+ *     parent element.
+ * @see goog.ui.editor.DefaultToolbar.DEFAULT_BUTTONS
+ */
+goog.ui.editor.DefaultToolbar.makeDefaultToolbar = function(elem,
+    opt_isRightToLeft) {
+  var isRightToLeft = opt_isRightToLeft || goog.style.isRightToLeft(elem);
+  var buttons = isRightToLeft ?
+      goog.ui.editor.DefaultToolbar.DEFAULT_BUTTONS_RTL :
+      goog.ui.editor.DefaultToolbar.DEFAULT_BUTTONS;
+  return goog.ui.editor.DefaultToolbar.makeToolbar(buttons, elem,
+      opt_isRightToLeft);
+};
+/**
+ * Creates a {@link goog.ui.Toolbar} containing the specified set of
+ * toolbar buttons, and renders it into the given parent element.  Each
+ * item in the {@code items} array must either be a
+ * {@link goog.editor.Command} (to create a built-in button) or a subclass
+ * of {@link goog.ui.Control} (to create a custom control).
+ * @param {!Array.<string|goog.ui.Control>} items Toolbar items; each must
+ *     be a {@link goog.editor.Command} or a {@link goog.ui.Control}.
+ * @param {!Element} elem Toolbar parent element.
+ * @param {boolean=} opt_isRightToLeft Whether the editor chrome is
+ *     right-to-left; defaults to the directionality of the toolbar parent
+ *     element.
+ * @return {!goog.ui.Toolbar} Editor toolbar, rendered into the given parent
+ *     element.
+ */
+goog.ui.editor.DefaultToolbar.makeToolbar = function(items, elem,
+    opt_isRightToLeft) {
+  var domHelper = goog.dom.getDomHelper(elem);
+  var controls = [];
+  for (var i = 0, button; button = items[i]; i++) {
+    if (goog.isString(button)) {
+      button = goog.ui.editor.DefaultToolbar.makeBuiltInToolbarButton(button,
+          domHelper);
+    }
+    if (button) {
+      controls.push(button);
+    }
+  }
+  return goog.ui.editor.ToolbarFactory.makeToolbar(controls, elem,
+      opt_isRightToLeft);
+};
+/**
+ * Creates an instance of a subclass of {@link goog.ui.Button} for the given
+ * {@link goog.editor.Command}, or null if no built-in button exists for the
+ * command.  Note that this function is only intended to create built-in
+ * buttons; please don't try to hack it!
+ * @param {string} command Editor command ID.
+ * @param {goog.dom.DomHelper=} opt_domHelper DOM helper, used for DOM
+ *     creation; defaults to the current document if unspecified.
+ * @return {goog.ui.Button} Toolbar button (null if no built-in button exists
+ *     for the command).
+ */
+goog.ui.editor.DefaultToolbar.makeBuiltInToolbarButton = function(command,
+    opt_domHelper) {
+  var button;
+  var descriptor = goog.ui.editor.DefaultToolbar.buttons_[command];
+  if (descriptor) {
+    // Default the factory method to makeToggleButton, since most built-in
+    // toolbar buttons are toggle buttons. See also
+    // goog.ui.editor.DefaultToolbar.BUTTONS_.
+    var factory = descriptor.factory ||
+        goog.ui.editor.ToolbarFactory.makeToggleButton;
+    var id = descriptor.command;
+    var tooltip = descriptor.tooltip;
+    var caption = descriptor.caption;
+    var classNames = descriptor.classes;
+    // Default the DOM helper to the one for the current document.
+    var domHelper = opt_domHelper || goog.dom.getDomHelper();
+    // Instantiate the button based on the descriptor.
+    button = factory(id, tooltip, caption, classNames, null, domHelper);
+    // If this button's state should be queried when updating the toolbar,
+    // set the button object's queryable property to true.
+    if (descriptor.queryable) {
+      button.queryable = true;
+    }
+  }
+  return button;
+};
+/**
+ * A set of built-in buttons to display in the default editor toolbar.
+ * @type {!Array.<string>}
+ */
+goog.ui.editor.DefaultToolbar.DEFAULT_BUTTONS = [
+  goog.editor.Command.IMAGE,
+  goog.editor.Command.LINK,
+  goog.editor.Command.BOLD,
+  goog.editor.Command.ITALIC,
+  goog.editor.Command.UNORDERED_LIST,
+  goog.editor.Command.FONT_COLOR,
+  goog.editor.Command.FONT_FACE,
+  goog.editor.Command.FONT_SIZE,
+  goog.editor.Command.JUSTIFY_LEFT,
+  goog.editor.Command.JUSTIFY_CENTER,
+  goog.editor.Command.JUSTIFY_RIGHT,
+  goog.editor.Command.EDIT_HTML
+];
+/**
+ * A set of built-in buttons to display in the default editor toolbar when
+ * the editor chrome is right-to-left (BiDi mode only).
+ * @type {!Array.<string>}
+ */
+goog.ui.editor.DefaultToolbar.DEFAULT_BUTTONS_RTL = [
+  goog.editor.Command.IMAGE,
+  goog.editor.Command.LINK,
+  goog.editor.Command.BOLD,
+  goog.editor.Command.ITALIC,
+  goog.editor.Command.UNORDERED_LIST,
+  goog.editor.Command.FONT_COLOR,
+  goog.editor.Command.FONT_FACE,
+  goog.editor.Command.FONT_SIZE,
+  goog.editor.Command.JUSTIFY_RIGHT,
+  goog.editor.Command.JUSTIFY_CENTER,
+  goog.editor.Command.JUSTIFY_LEFT,
+  goog.editor.Command.DIR_RTL,
+  goog.editor.Command.DIR_LTR,
+  goog.editor.Command.EDIT_HTML
+];
+/**
+ * Creates a toolbar button with the given ID, tooltip, and caption.  Applies
+ * any custom CSS class names to the button's caption element.  This button
+ * is designed to be used as the RTL button.
+ * @param {string} id Button ID; must equal a {@link goog.editor.Command} for
+ *     built-in buttons, anything else for custom buttons.
+ * @param {string} tooltip Tooltip to be shown on hover.
+ * @param {goog.ui.ControlContent} caption Button caption.
+ * @param {string=} opt_classNames CSS class name(s) to apply to the caption
+ *     element.
+ * @param {goog.ui.ButtonRenderer=} opt_renderer Button renderer; defaults to
+ *     {@link goog.ui.ToolbarButtonRenderer} if unspecified.
+ * @param {goog.dom.DomHelper=} opt_domHelper DOM helper, used for DOM
+ *     creation; defaults to the current document if unspecified.
+ * @return {!goog.ui.Button} A toolbar button.
+ * @private
+ */
+goog.ui.editor.DefaultToolbar.rtlButtonFactory_ = function(id, tooltip,
+    caption, opt_classNames, opt_renderer, opt_domHelper) {
+  var button = goog.ui.editor.ToolbarFactory.makeToggleButton(id, tooltip,
+      caption, opt_classNames, opt_renderer, opt_domHelper);
+  button.updateFromValue = function(value) {
+    // Enable/disable right-to-left text editing mode in the toolbar.
+    var isRtl = !!value;
+    // Enable/disable a marker class on the toolbar's root element; the rest is
+    // done using CSS scoping in editortoolbar.css.  This changes
+    // direction-senitive toolbar icons (like indent/outdent)
+    goog.dom.classes.enable(
+        button.getParent().getElement(), goog.getCssName('tr-rtl-mode'), isRtl);
+    button.setChecked(isRtl);
+  };
+  return button;
+};
+/**
+ * Creates a toolbar button with the given ID, tooltip, and caption.  Applies
+ * any custom CSS class names to the button's caption element.  Designed to
+ * be used to create undo and redo buttons.
+ * @param {string} id Button ID; must equal a {@link goog.editor.Command} for
+ *     built-in buttons, anything else for custom buttons.
+ * @param {string} tooltip Tooltip to be shown on hover.
+ * @param {goog.ui.ControlContent} caption Button caption.
+ * @param {string=} opt_classNames CSS class name(s) to apply to the caption
+ *     element.
+ * @param {goog.ui.ButtonRenderer=} opt_renderer Button renderer; defaults to
+ *     {@link goog.ui.ToolbarButtonRenderer} if unspecified.
+ * @param {goog.dom.DomHelper=} opt_domHelper DOM helper, used for DOM
+ *     creation; defaults to the current document if unspecified.
+ * @return {!goog.ui.Button} A toolbar button.
+ * @private
+ */
+goog.ui.editor.DefaultToolbar.undoRedoButtonFactory_ = function(id, tooltip,
+    caption, opt_classNames, opt_renderer, opt_domHelper) {
+  var button = goog.ui.editor.ToolbarFactory.makeButton(id, tooltip,
+      caption, opt_classNames, opt_renderer, opt_domHelper);
+  button.updateFromValue = function(value) {
+    button.setEnabled(value);
+  };
+  return button;
+};
+/**
+ * Creates a toolbar button with the given ID, tooltip, and caption.  Applies
+ * any custom CSS class names to the button's caption element.  Used to create
+ * a font face button, filled with default fonts.
+ * @param {string} id Button ID; must equal a {@link goog.editor.Command} for
+ *     built-in buttons, anything else for custom buttons.
+ * @param {string} tooltip Tooltip to be shown on hover.
+ * @param {goog.ui.ControlContent} caption Button caption.
+ * @param {string=} opt_classNames CSS class name(s) to apply to the caption
+ *     element.
+ * @param {goog.ui.MenuButtonRenderer=} opt_renderer Button renderer; defaults
+ *     to {@link goog.ui.ToolbarMenuButtonRenderer} if unspecified.
+ * @param {goog.dom.DomHelper=} opt_domHelper DOM helper, used for DOM
+ *     creation; defaults to the current document if unspecified.
+ * @return {!goog.ui.Button} A toolbar button.
+ * @private
+ */
+goog.ui.editor.DefaultToolbar.fontFaceFactory_ = function(id, tooltip,
+    caption, opt_classNames, opt_renderer, opt_domHelper) {
+  var button = goog.ui.editor.ToolbarFactory.makeSelectButton(id, tooltip,
+      caption, opt_classNames, opt_renderer, opt_domHelper);
+  goog.ui.editor.DefaultToolbar.addDefaultFonts(button);
+  button.setDefaultCaption(goog.ui.editor.DefaultToolbar.MSG_FONT_NORMAL);
+  // Font options don't have keyboard accelerators.
+  goog.dom.classes.add(button.getMenu().getContentElement(),
+      goog.getCssName('goog-menu-noaccel'));
+  // How to update this button's state.
+  button.updateFromValue = function(value) {
+    // Normalize value to null or a non-empty string (sometimes we get
+    // the empty string, sometimes we get false...), extract the substring
+    // up to the first comma to get the primary font name, and normalize
+    // to lowercase.  This allows us to map a font spec like "Arial,
+    // Helvetica, sans-serif" to a font menu item.
+    // TODO (attila): Try to make this more robust.
+    var item = null;
+    if (value && value.length > 0) {
+      item = /** @type {goog.ui.MenuItem} */ (button.getMenu().getChild(
+          goog.ui.editor.ToolbarFactory.getPrimaryFont(value)));
+    }
+    var selectedItem = button.getSelectedItem();
+    if (item != selectedItem) {
+      button.setSelectedItem(item);
+    }
+  };
+  return button;
+};
+/**
+ * Creates a toolbar button with the given ID, tooltip, and caption.  Applies
+ * any custom CSS class names to the button's caption element. Use to create a
+ * font size button, filled with default font sizes.
+ * @param {string} id Button ID; must equal a {@link goog.editor.Command} for
+ *     built-in buttons, anything else for custom buttons.
+ * @param {string} tooltip Tooltip to be shown on hover.
+ * @param {goog.ui.ControlContent} caption Button caption.
+ * @param {string=} opt_classNames CSS class name(s) to apply to the caption
+ *     element.
+ * @param {goog.ui.MenuButtonRenderer=} opt_renderer Button renderer; defaults
+ *     to {@link goog.ui.ToolbarMebuButtonRenderer} if unspecified.
+ * @param {goog.dom.DomHelper=} opt_domHelper DOM helper, used for DOM
+ *     creation; defaults to the current document if unspecified.
+ * @return {!goog.ui.Button} A toolbar button.
+ * @private
+ */
+goog.ui.editor.DefaultToolbar.fontSizeFactory_ = function(id, tooltip,
+    caption, opt_classNames, opt_renderer, opt_domHelper) {
+  var button = goog.ui.editor.ToolbarFactory.makeSelectButton(id, tooltip,
+      caption, opt_classNames, opt_renderer, opt_domHelper);
+  goog.ui.editor.DefaultToolbar.addDefaultFontSizes(button);
+  button.setDefaultCaption(goog.ui.editor.DefaultToolbar.MSG_FONT_SIZE_NORMAL);
+  // Font size options don't have keyboard accelerators.
+  goog.dom.classes.add(button.getMenu().getContentElement(),
+      goog.getCssName('goog-menu-noaccel'));
+  // How to update this button's state.
+  button.updateFromValue = function(value) {
+    // Webkit pre-534.7 returns a string like '32px' instead of the equivalent
+    // integer, so normalize that first.
+    // NOTE(user): Gecko returns "6" so can't just normalize all
+    // strings, only ones ending in "px".
+    if (goog.isString(value) &&
+        goog.style.getLengthUnits(value) == 'px') {
+      value = goog.ui.editor.ToolbarFactory.getLegacySizeFromPx(
+          parseInt(value, 10));
+    }
+    // Normalize value to null or a positive integer (sometimes we get
+    // the empty string, sometimes we get false, or -1 if the above
+    // normalization didn't match to a particular 0-7 size)
+    value = value > 0 ? value : null;
+    if (value != button.getValue()) {
+      button.setValue(value);
+    }
+  };
+  return button;
+};
+/**
+ * Function to update the state of a color menu button.
+ * @param {goog.ui.ToolbarColorMenuButton} button The button to which the
+ *     color menu is attached.
+ * @param {number} color Color value to update to.
+ * @private
+ */
+goog.ui.editor.DefaultToolbar.colorUpdateFromValue_ = function(button, color) {
+  var value = color;
+  /** @preserveTry */
+  try {
+    if (goog.userAgent.IE) {
+      // IE returns a number that, converted to hex, is a BGR color.
+      // Convert from decimal to BGR to RGB.
+      var hex = '000000' + value.toString(16);
+      var bgr = hex.substr(hex.length - 6, 6);
+      value = '#' + bgr.substring(4, 6) + bgr.substring(2, 4) +
+          bgr.substring(0, 2);
+    }
+    if (value != button.getValue()) {
+      button.setValue(/** @type {string} */ (value));
+    }
+  } catch (ex) {
+    // TODO(attila): Find out when/why this happens.
+  }
+};
+/**
+ * Creates a toolbar button with the given ID, tooltip, and caption.  Applies
+ * any custom CSS class names to the button's caption element. Use to create
+ * a font color button.
+ * @param {string} id Button ID; must equal a {@link goog.editor.Command} for
+ *     built-in buttons, anything else for custom buttons.
+ * @param {string} tooltip Tooltip to be shown on hover.
+ * @param {goog.ui.ControlContent} caption Button caption.
+ * @param {string=} opt_classNames CSS class name(s) to apply to the caption
+ *     element.
+ * @param {goog.ui.ColorMenuButtonRenderer=} opt_renderer Button renderer;
+ *     defaults to {@link goog.ui.ToolbarColorMenuButtonRenderer} if
+ *     unspecified.
+ * @param {goog.dom.DomHelper=} opt_domHelper DOM helper, used for DOM
+ *     creation; defaults to the current document if unspecified.
+ * @return {!goog.ui.Button} A toolbar button.
+ * @private
+ */
+goog.ui.editor.DefaultToolbar.fontColorFactory_ = function(id, tooltip,
+    caption, opt_classNames, opt_renderer, opt_domHelper) {
+  var button = goog.ui.editor.ToolbarFactory.makeColorMenuButton(id, tooltip,
+      caption, opt_classNames, opt_renderer, opt_domHelper);
+  // Initialize default foreground color.
+  button.setSelectedColor('#000');
+  button.updateFromValue = goog.partial(
+      goog.ui.editor.DefaultToolbar.colorUpdateFromValue_, button);
+  return button;
+};
+/**
+ * Creates a toolbar button with the given ID, tooltip, and caption.  Applies
+ * any custom CSS class names to the button's caption element. Use to create
+ * a font background color button.
+ * @param {string} id Button ID; must equal a {@link goog.editor.Command} for
+ *     built-in buttons, anything else for custom buttons.
+ * @param {string} tooltip Tooltip to be shown on hover.
+ * @param {goog.ui.ControlContent} caption Button caption.
+ * @param {string=} opt_classNames CSS class name(s) to apply to the caption
+ *     element.
+ * @param {goog.ui.ColorMenuButtonRenderer=} opt_renderer Button renderer;
+ *     defaults to {@link goog.ui.ToolbarColorMenuButtonRenderer} if
+ *     unspecified.
+ * @param {goog.dom.DomHelper=} opt_domHelper DOM helper, used for DOM
+ *     creation; defaults to the current document if unspecified.
+ * @return {!goog.ui.Button} A toolbar button.
+ * @private
+ */
+goog.ui.editor.DefaultToolbar.backgroundColorFactory_ = function(id, tooltip,
+    caption, opt_classNames, opt_renderer, opt_domHelper) {
+  var button = goog.ui.editor.ToolbarFactory.makeColorMenuButton(id,
+      tooltip, caption, opt_classNames, opt_renderer, opt_domHelper);
+  // Initialize default background color.
+  button.setSelectedColor('#FFF');
+  button.updateFromValue = goog.partial(
+      goog.ui.editor.DefaultToolbar.colorUpdateFromValue_, button);
+  return button;
+};
+/**
+ * Creates a toolbar button with the given ID, tooltip, and caption.  Applies
+ * any custom CSS class names to the button's caption element. Use to create
+ * the format menu, prefilled with default formats.
+ * @param {string} id Button ID; must equal a {@link goog.editor.Command} for
+ *     built-in buttons, anything else for custom buttons.
+ * @param {string} tooltip Tooltip to be shown on hover.
+ * @param {goog.ui.ControlContent} caption Button caption.
+ * @param {string=} opt_classNames CSS class name(s) to apply to the caption
+ *     element.
+ * @param {goog.ui.MenuButtonRenderer=} opt_renderer Button renderer;
+ *     defaults to
+ *     {@link goog.ui.ToolbarMenuButtonRenderer} if unspecified.
+ * @param {goog.dom.DomHelper=} opt_domHelper DOM helper, used for DOM
+ *     creation; defaults to the current document if unspecified.
+ * @return {!goog.ui.Button} A toolbar button.
+ * @private
+ */
+goog.ui.editor.DefaultToolbar.formatBlockFactory_ = function(id, tooltip,
+    caption, opt_classNames, opt_renderer, opt_domHelper) {
+  var button = goog.ui.editor.ToolbarFactory.makeSelectButton(id, tooltip,
+      caption, opt_classNames, opt_renderer, opt_domHelper);
+  goog.ui.editor.DefaultToolbar.addDefaultFormatOptions(button);
+  button.setDefaultCaption(goog.ui.editor.DefaultToolbar.MSG_FORMAT_NORMAL);
+  // Format options don't have keyboard accelerators.
+  goog.dom.classes.add(button.getMenu().getContentElement(),
+      goog.getCssName('goog-menu-noaccel'));
+  // How to update this button.
+  button.updateFromValue = function(value) {
+    // Normalize value to null or a nonempty string (sometimes we get
+    // the empty string, sometimes we get false...)
+    value = value && value.length > 0 ? value : null;
+    if (value != button.getValue()) {
+      button.setValue(value);
+    }
+  };
+  return button;
+};
+// Messages used for tooltips and captions.
+/** @desc Format menu tooltip. */
+goog.ui.editor.DefaultToolbar.MSG_FORMAT_BLOCK_TITLE = goog.getMsg('Format');
+/** @desc Format menu caption. */
+goog.ui.editor.DefaultToolbar.MSG_FORMAT_BLOCK_CAPTION = goog.getMsg('Format');
+/** @desc Undo button tooltip. */
+goog.ui.editor.DefaultToolbar.MSG_UNDO_TITLE = goog.getMsg('Undo');
+/** @desc Redo button tooltip. */
+goog.ui.editor.DefaultToolbar.MSG_REDO_TITLE = goog.getMsg('Redo');
+/** @desc Font menu tooltip. */
+goog.ui.editor.DefaultToolbar.MSG_FONT_FACE_TITLE = goog.getMsg('Font');
+/** @desc Font size menu tooltip. */
+goog.ui.editor.DefaultToolbar.MSG_FONT_SIZE_TITLE = goog.getMsg('Font size');
+/** @desc Text foreground color menu tooltip. */
+goog.ui.editor.DefaultToolbar.MSG_FONT_COLOR_TITLE = goog.getMsg('Text color');
+/** @desc Bold button tooltip. */
+goog.ui.editor.DefaultToolbar.MSG_BOLD_TITLE = goog.getMsg('Bold');
+/** @desc Italic button tooltip. */
+goog.ui.editor.DefaultToolbar.MSG_ITALIC_TITLE = goog.getMsg('Italic');
+/** @desc Underline button tooltip. */
+goog.ui.editor.DefaultToolbar.MSG_UNDERLINE_TITLE = goog.getMsg('Underline');
+/** @desc Text background color menu tooltip. */
+goog.ui.editor.DefaultToolbar.MSG_BACKGROUND_COLOR_TITLE =
+    goog.getMsg('Text background color');
+/** @desc Link button tooltip. */
+goog.ui.editor.DefaultToolbar.MSG_LINK_TITLE =
+    goog.getMsg('Add or remove link');
+/** @desc Numbered list button tooltip. */
+goog.ui.editor.DefaultToolbar.MSG_ORDERED_LIST_TITLE =
+    goog.getMsg('Numbered list');
+/** @desc Bullet list button tooltip. */
+goog.ui.editor.DefaultToolbar.MSG_UNORDERED_LIST_TITLE =
+    goog.getMsg('Bullet list');
+/** @desc Outdent button tooltip. */
+goog.ui.editor.DefaultToolbar.MSG_OUTDENT_TITLE =
+    goog.getMsg('Decrease indent');
+/** @desc Indent button tooltip. */
+goog.ui.editor.DefaultToolbar.MSG_INDENT_TITLE = goog.getMsg('Increase indent');
+/** @desc Align left button tooltip. */
+goog.ui.editor.DefaultToolbar.MSG_ALIGN_LEFT_TITLE = goog.getMsg('Align left');
+/** @desc Align center button tooltip. */
+goog.ui.editor.DefaultToolbar.MSG_ALIGN_CENTER_TITLE =
+    goog.getMsg('Align center');
+/** @desc Align right button tooltip. */
+goog.ui.editor.DefaultToolbar.MSG_ALIGN_RIGHT_TITLE =
+    goog.getMsg('Align right');
+/** @desc Justify button tooltip. */
+goog.ui.editor.DefaultToolbar.MSG_JUSTIFY_TITLE = goog.getMsg('Justify');
+/** @desc Remove formatting button tooltip. */
+goog.ui.editor.DefaultToolbar.MSG_REMOVE_FORMAT_TITLE =
+    goog.getMsg('Remove formatting');
+/** @desc Insert image button tooltip. */
+goog.ui.editor.DefaultToolbar.MSG_IMAGE_TITLE = goog.getMsg('Insert image');
+/** @desc Strike through button tooltip. */
+goog.ui.editor.DefaultToolbar.MSG_STRIKE_THROUGH_TITLE =
+    goog.getMsg('Strikethrough');
+/** @desc Left-to-right button tooltip. */
+goog.ui.editor.DefaultToolbar.MSG_DIR_LTR_TITLE = goog.getMsg('Left-to-right');
+/** @desc Right-to-left button tooltip. */
+goog.ui.editor.DefaultToolbar.MSG_DIR_RTL_TITLE = goog.getMsg('Right-to-left');
+/** @desc Blockquote button tooltip. */
+goog.ui.editor.DefaultToolbar.MSG_BLOCKQUOTE_TITLE = goog.getMsg('Quote');
+/** @desc Edit HTML button tooltip. */
+goog.ui.editor.DefaultToolbar.MSG_EDIT_HTML_TITLE =
+    goog.getMsg('Edit HTML source');
+/** @desc Subscript button tooltip. */
+goog.ui.editor.DefaultToolbar.MSG_SUBSCRIPT = goog.getMsg('Subscript');
+/** @desc Superscript button tooltip. */
+goog.ui.editor.DefaultToolbar.MSG_SUPERSCRIPT = goog.getMsg('Superscript');
+/** @desc Edit HTML button caption. */
+goog.ui.editor.DefaultToolbar.MSG_EDIT_HTML_CAPTION = goog.getMsg('Edit HTML');
+/**
+ * Map of {@code goog.editor.Command}s to toolbar button descriptor objects,
+ * each of which has the following attributes:
+ * <ul>
+ *   <li>{@code command} - The command corresponding to the
+ *       button (mandatory)
+ *   <li>{@code tooltip} - Tooltip text (optional); if unspecified, the button
+ *       has no hover text
+ *   <li>{@code caption} - Caption to display on the button (optional); if
+ *       unspecified, the button has no text caption
+ *   <li>{@code classes} - CSS class name(s) to be applied to the button's
+ *       element when rendered (optional); if unspecified, defaults to
+ *       'tr-icon'
+ *       plus 'tr-' followed by the command ID, but without any leading '+'
+ *       character (e.g. if the command ID is '+undo', then {@code classes}
+ *       defaults to 'tr-icon tr-undo')
+ *   <li>{@code factory} - factory function used to create the button, which
+ *       must accept {@code id}, {@code tooltip}, {@code caption}, and
+ *       {@code classes} as arguments, and must return an instance of
+ *       {@link goog.ui.Button} or an appropriate subclass (optional); if
+ *       unspecified, defaults to
+ *       {@link goog.ui.editor.DefaultToolbar.makeToggleButton},
+ *       since most built-in toolbar buttons are toggle buttons
+ *   <li>(@code queryable} - Whether the button's state should be queried
+ *       when updating the toolbar (optional).
+ * </ul>
+ * Note that this object is only used for creating toolbar buttons for
+ * built-in editor commands; custom buttons aren't listed here.  Please don't
+ * try to hack this!
+ * @type {Object.<!goog.ui.editor.ButtonDescriptor>}.
+ * @private
+ */
+goog.ui.editor.DefaultToolbar.buttons_ = {};
+/**
+ * @typedef {{command: string, tooltip: ?string,
+ *   caption: ?goog.ui.ControlContent, classes: ?string,
+ *   factory: ?function(string, string, goog.ui.ControlContent, ?string,
+ *       goog.ui.ButtonRenderer, goog.dom.DomHelper):goog.ui.Button,
+ *   queryable:?boolean}}
+ */
+goog.ui.editor.ButtonDescriptor;
+/**
+ * Built-in toolbar button descriptors.  See
+ * {@link goog.ui.editor.DefaultToolbar.buttons_} for details on button
+ * descriptor objects.  This array is processed at JS parse time; each item is
+ * inserted into {@link goog.ui.editor.DefaultToolbar.buttons_}, and the array
+ * itself is deleted and (hopefully) garbage-collected.
+ * @type {Array.<!goog.ui.editor.ButtonDescriptor>}.
+ * @private
+ */
+goog.ui.editor.DefaultToolbar.BUTTONS_ = [{
+  command: goog.editor.Command.UNDO,
+  tooltip: goog.ui.editor.DefaultToolbar.MSG_UNDO_TITLE,
+  classes: goog.getCssName('tr-icon') + ' ' + goog.getCssName('tr-undo'),
+  factory: goog.ui.editor.DefaultToolbar.undoRedoButtonFactory_,
+  queryable: true
+}, {
+  command: goog.editor.Command.REDO,
+  tooltip: goog.ui.editor.DefaultToolbar.MSG_REDO_TITLE,
+  classes: goog.getCssName('tr-icon') + ' ' + goog.getCssName('tr-redo'),
+  factory: goog.ui.editor.DefaultToolbar.undoRedoButtonFactory_,
+  queryable: true
+}, {
+  command: goog.editor.Command.FONT_FACE,
+  tooltip: goog.ui.editor.DefaultToolbar.MSG_FONT_FACE_TITLE,
+  classes: goog.getCssName('tr-fontName'),
+  factory: goog.ui.editor.DefaultToolbar.fontFaceFactory_,
+  queryable: true
+}, {
+  command: goog.editor.Command.FONT_SIZE,
+  tooltip: goog.ui.editor.DefaultToolbar.MSG_FONT_SIZE_TITLE,
+  classes: goog.getCssName('tr-fontSize'),
+  factory: goog.ui.editor.DefaultToolbar.fontSizeFactory_,
+  queryable: true
+}, {
+  command: goog.editor.Command.BOLD,
+  tooltip: goog.ui.editor.DefaultToolbar.MSG_BOLD_TITLE,
+  classes: goog.getCssName('tr-icon') + ' ' + goog.getCssName('tr-bold'),
+  queryable: true
+}, {
+  command: goog.editor.Command.ITALIC,
+  tooltip: goog.ui.editor.DefaultToolbar.MSG_ITALIC_TITLE,
+  classes: goog.getCssName('tr-icon') + ' ' + goog.getCssName('tr-italic'),
+  queryable: true
+}, {
+  command: goog.editor.Command.UNDERLINE,
+  tooltip: goog.ui.editor.DefaultToolbar.MSG_UNDERLINE_TITLE,
+  classes: goog.getCssName('tr-icon') + ' ' + goog.getCssName('tr-underline'),
+  queryable: true
+}, {
+  command: goog.editor.Command.FONT_COLOR,
+  tooltip: goog.ui.editor.DefaultToolbar.MSG_FONT_COLOR_TITLE,
+  classes: goog.getCssName('tr-icon') + ' ' + goog.getCssName('tr-foreColor'),
+  factory: goog.ui.editor.DefaultToolbar.fontColorFactory_,
+  queryable: true
+}, {
+  command: goog.editor.Command.BACKGROUND_COLOR,
+  tooltip: goog.ui.editor.DefaultToolbar.MSG_BACKGROUND_COLOR_TITLE,
+  classes: goog.getCssName('tr-icon') + ' ' + goog.getCssName('tr-backColor'),
+  factory: goog.ui.editor.DefaultToolbar.backgroundColorFactory_,
+  queryable: true
+}, {
+  command: goog.editor.Command.LINK,
+  tooltip: goog.ui.editor.DefaultToolbar.MSG_LINK_TITLE,
+  caption: goog.ui.editor.messages.MSG_LINK_CAPTION,
+  classes: goog.getCssName('tr-link'),
+  queryable: true
+}, {
+  command: goog.editor.Command.ORDERED_LIST,
+  tooltip: goog.ui.editor.DefaultToolbar.MSG_ORDERED_LIST_TITLE,
+  classes: goog.getCssName('tr-icon') + ' ' +
+      goog.getCssName('tr-insertOrderedList'),
+  queryable: true
+}, {
+  command: goog.editor.Command.UNORDERED_LIST,
+  tooltip: goog.ui.editor.DefaultToolbar.MSG_UNORDERED_LIST_TITLE,
+  classes: goog.getCssName('tr-icon') + ' ' +
+      goog.getCssName('tr-insertUnorderedList'),
+  queryable: true
+}, {
+  command: goog.editor.Command.OUTDENT,
+  tooltip: goog.ui.editor.DefaultToolbar.MSG_OUTDENT_TITLE,
+  classes: goog.getCssName('tr-icon') + ' ' + goog.getCssName('tr-outdent'),
+  factory: goog.ui.editor.ToolbarFactory.makeButton
+}, {
+  command: goog.editor.Command.INDENT,
+  tooltip: goog.ui.editor.DefaultToolbar.MSG_INDENT_TITLE,
+  classes: goog.getCssName('tr-icon') + ' ' + goog.getCssName('tr-indent'),
+  factory: goog.ui.editor.ToolbarFactory.makeButton
+}, {
+  command: goog.editor.Command.JUSTIFY_LEFT,
+  tooltip: goog.ui.editor.DefaultToolbar.MSG_ALIGN_LEFT_TITLE,
+  classes: goog.getCssName('tr-icon') + ' ' +
+      goog.getCssName('tr-justifyLeft'),
+  queryable: true
+}, {
+  command: goog.editor.Command.JUSTIFY_CENTER,
+  tooltip: goog.ui.editor.DefaultToolbar.MSG_ALIGN_CENTER_TITLE,
+  classes: goog.getCssName('tr-icon') + ' ' +
+      goog.getCssName('tr-justifyCenter'),
+  queryable: true
+}, {
+  command: goog.editor.Command.JUSTIFY_RIGHT,
+  tooltip: goog.ui.editor.DefaultToolbar.MSG_ALIGN_RIGHT_TITLE,
+  classes: goog.getCssName('tr-icon') + ' ' +
+      goog.getCssName('tr-justifyRight'),
+  queryable: true
+}, {
+  command: goog.editor.Command.JUSTIFY_FULL,
+  tooltip: goog.ui.editor.DefaultToolbar.MSG_JUSTIFY_TITLE,
+  classes: goog.getCssName('tr-icon') + ' ' +
+      goog.getCssName('tr-justifyFull'),
+  queryable: true
+}, {
+  command: goog.editor.Command.REMOVE_FORMAT,
+  tooltip: goog.ui.editor.DefaultToolbar.MSG_REMOVE_FORMAT_TITLE,
+  classes: goog.getCssName('tr-icon') + ' ' +
+      goog.getCssName('tr-removeFormat'),
+  factory: goog.ui.editor.ToolbarFactory.makeButton
+}, {
+  command: goog.editor.Command.IMAGE,
+  tooltip: goog.ui.editor.DefaultToolbar.MSG_IMAGE_TITLE,
+  classes: goog.getCssName('tr-icon') + ' ' + goog.getCssName('tr-image'),
+  factory: goog.ui.editor.ToolbarFactory.makeButton
+}, {
+  command: goog.editor.Command.STRIKE_THROUGH,
+  tooltip: goog.ui.editor.DefaultToolbar.MSG_STRIKE_THROUGH_TITLE,
+  classes: goog.getCssName('tr-icon') + ' ' +
+      goog.getCssName('tr-strikeThrough'),
+  queryable: true
+}, {
+  command: goog.editor.Command.SUBSCRIPT,
+  tooltip: goog.ui.editor.DefaultToolbar.MSG_SUBSCRIPT,
+  classes: goog.getCssName('tr-icon') + ' ' + goog.getCssName('tr-subscript'),
+  queryable: true
+} , {
+  command: goog.editor.Command.SUPERSCRIPT,
+  tooltip: goog.ui.editor.DefaultToolbar.MSG_SUPERSCRIPT,
+  classes: goog.getCssName('tr-icon') + ' ' +
+      goog.getCssName('tr-superscript'),
+  queryable: true
+}, {
+  command: goog.editor.Command.DIR_LTR,
+  tooltip: goog.ui.editor.DefaultToolbar.MSG_DIR_LTR_TITLE,
+  classes: goog.getCssName('tr-icon') + ' ' + goog.getCssName('tr-ltr'),
+  queryable: true
+}, {
+  command: goog.editor.Command.DIR_RTL,
+  tooltip: goog.ui.editor.DefaultToolbar.MSG_DIR_RTL_TITLE,
+  classes: goog.getCssName('tr-icon') + ' ' + goog.getCssName('tr-rtl'),
+  factory: goog.ui.editor.DefaultToolbar.rtlButtonFactory_,
+  queryable: true
+}, {
+  command: goog.editor.Command.BLOCKQUOTE,
+  tooltip: goog.ui.editor.DefaultToolbar.MSG_BLOCKQUOTE_TITLE,
+  classes: goog.getCssName('tr-icon') + ' ' +
+      goog.getCssName('tr-BLOCKQUOTE'),
+  queryable: true
+}, {
+  command: goog.editor.Command.FORMAT_BLOCK,
+  tooltip: goog.ui.editor.DefaultToolbar.MSG_FORMAT_BLOCK_TITLE,
+  caption: goog.ui.editor.DefaultToolbar.MSG_FORMAT_BLOCK_CAPTION,
+  classes: goog.getCssName('tr-formatBlock'),
+  factory: goog.ui.editor.DefaultToolbar.formatBlockFactory_,
+  queryable: true
+}, {
+  command: goog.editor.Command.EDIT_HTML,
+  tooltip: goog.ui.editor.DefaultToolbar.MSG_EDIT_HTML_TITLE,
+  caption: goog.ui.editor.DefaultToolbar.MSG_EDIT_HTML_CAPTION,
+  classes: goog.getCssName('tr-editHtml'),
+  factory: goog.ui.editor.ToolbarFactory.makeButton
+}];
+(function() {
+  // Create the goog.ui.editor.DefaultToolbar.buttons_ map from
+  // goog.ui.editor.DefaultToolbar.BUTTONS_.
+  for (var i = 0, button;
+      button = goog.ui.editor.DefaultToolbar.BUTTONS_[i]; i++) {
+    goog.ui.editor.DefaultToolbar.buttons_[button.command] = button;
+  }
+  // goog.ui.editor.DefaultToolbar.BUTTONS_ is no longer needed
+  // once the map is ready.
+  delete goog.ui.editor.DefaultToolbar.BUTTONS_;
+})();