DevTools: rename WebInspector into modules.

third_party/WebKit/Source/devtools/front_end/ui/Toolbar.js

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 13 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 /**
  * @unrestricted
  */
-WebInspector.Toolbar = class {
+UI.Toolbar = class {
   /**
    * @param {string} className
    * @param {!Element=} parentElement
    */
   constructor(className, parentElement) {
-    /** @type {!Array.<!WebInspector.ToolbarItem>} */
+    /** @type {!Array.<!UI.ToolbarItem>} */
     this._items = [];
     this._reverse = false;
     this.element = parentElement ? parentElement.createChild('div') : createElement('div');
     this.element.className = className;
     this.element.classList.add('toolbar');
-    this._shadowRoot = WebInspector.createShadowRootWithCoreStyles(this.element, 'ui/toolbar.css');
+    this._shadowRoot = UI.createShadowRootWithCoreStyles(this.element, 'ui/toolbar.css');
     this._contentElement = this._shadowRoot.createChild('div', 'toolbar-shadow');
     this._insertionPoint = this._contentElement.createChild('content');
   }
 
   /**
-   * @param {!WebInspector.Action} action
-   * @param {!Array<!WebInspector.ToolbarButton>=} toggledOptions
-   * @param {!Array<!WebInspector.ToolbarButton>=} untoggledOptions
-   * @return {!WebInspector.ToolbarItem}
+   * @param {!UI.Action} action
+   * @param {!Array<!UI.ToolbarButton>=} toggledOptions
+   * @param {!Array<!UI.ToolbarButton>=} untoggledOptions
+   * @return {!UI.ToolbarItem}
    */
   static createActionButton(action, toggledOptions, untoggledOptions) {
-    var button = new WebInspector.ToolbarToggle(action.title(), action.icon(), action.toggledIcon());
+    var button = new UI.ToolbarToggle(action.title(), action.icon(), action.toggledIcon());
     button.setToggleWithRedColor(action.toggleWithRedColor());
     button.addEventListener('click', action.execute, action);
-    action.addEventListener(WebInspector.Action.Events.Enabled, enabledChanged);
-    action.addEventListener(WebInspector.Action.Events.Toggled, toggled);
-    /** @type {?WebInspector.LongClickController} */
+    action.addEventListener(UI.Action.Events.Enabled, enabledChanged);
+    action.addEventListener(UI.Action.Events.Toggled, toggled);
+    /** @type {?UI.LongClickController} */
     var longClickController = null;
-    /** @type {?Array<!WebInspector.ToolbarButton>} */
+    /** @type {?Array<!UI.ToolbarButton>} */
     var longClickButtons = null;
     /** @type {?Element} */
     var longClickGlyph = null;
     toggled();
     return button;
 
     /**
-     * @param {!WebInspector.Event} event
+     * @param {!Common.Event} event
      */
     function enabledChanged(event) {
       button.setEnabled(/** @type {boolean} */ (event.data));
     }
 
     function toggled() {
       button.setToggled(action.toggled());
       if (action.title())
-        WebInspector.Tooltip.install(button.element, action.title(), action.id());
+        UI.Tooltip.install(button.element, action.title(), action.id());
       updateOptions();
     }
 
     function updateOptions() {
       var buttons = action.toggled() ? (toggledOptions || null) : (untoggledOptions || null);
 
       if (buttons && buttons.length) {
         if (!longClickController) {
-          longClickController = new WebInspector.LongClickController(button.element, showOptions);
-          longClickGlyph = WebInspector.Icon.create('largeicon-longclick-triangle', 'long-click-glyph');
+          longClickController = new UI.LongClickController(button.element, showOptions);
+          longClickGlyph = UI.Icon.create('largeicon-longclick-triangle', 'long-click-glyph');
           button.element.appendChild(longClickGlyph);
           longClickButtons = buttons;
         }
       } else {
         if (longClickController) {
           longClickController.dispose();
           longClickController = null;
           longClickGlyph.remove();
           longClickGlyph = null;
           longClickButtons = null;
         }
       }
     }
 
     function showOptions() {
       var buttons = longClickButtons.slice();
-      var mainButtonClone = new WebInspector.ToolbarToggle(action.title(), action.icon(), action.toggledIcon());
+      var mainButtonClone = new UI.ToolbarToggle(action.title(), action.icon(), action.toggledIcon());
       mainButtonClone.addEventListener('click', clicked);
 
       /**
-       * @param {!WebInspector.Event} event
+       * @param {!Common.Event} event
        */
       function clicked(event) {
         button._clicked(/** @type {!Event} */ (event.data));
       }
 
       mainButtonClone.setToggled(action.toggled());
       buttons.push(mainButtonClone);
 
       var document = button.element.ownerDocument;
       document.documentElement.addEventListener('mouseup', mouseUp, false);
 
-      var optionsGlassPane = new WebInspector.GlassPane(document);
-      var optionsBar = new WebInspector.Toolbar('fill', optionsGlassPane.element);
+      var optionsGlassPane = new UI.GlassPane(document);
+      var optionsBar = new UI.Toolbar('fill', optionsGlassPane.element);
       optionsBar._contentElement.classList.add('floating');
       const buttonHeight = 26;
 
       var hostButtonPosition = button.element.totalOffset();
 
       var topNotBottom = hostButtonPosition.top + buttonHeight * buttons.length < document.documentElement.offsetHeight;
 
       if (topNotBottom)
         buttons = buttons.reverse();
 
@@ skipping 38 matching lines @@
             buttons[i]._clicked(e);
             break;
           }
         }
       }
     }
   }
 
   /**
    * @param {string} actionId
-   * @return {?WebInspector.ToolbarItem}
+   * @return {?UI.ToolbarItem}
    */
   static createActionButtonForId(actionId) {
-    var action = WebInspector.actionRegistry.action(actionId);
-    return /** @type {?WebInspector.ToolbarItem} */ (action ? WebInspector.Toolbar.createActionButton(action) : null);
+    var action = UI.actionRegistry.action(actionId);
+    return /** @type {?UI.ToolbarItem} */ (action ? UI.Toolbar.createActionButton(action) : null);
   }
 
   /**
    * @param {boolean=} reverse
    */
   makeWrappable(reverse) {
     this._contentElement.classList.add('wrappable');
     this._reverse = !!reverse;
     if (reverse)
       this._contentElement.classList.add('wrappable-reverse');
@@ skipping 17 matching lines @@
 
   /**
    * @param {boolean} enabled
    */
   setEnabled(enabled) {
     for (var item of this._items)
       item.setEnabled(enabled);
   }
 
   /**
-   * @param {!WebInspector.ToolbarItem} item
+   * @param {!UI.ToolbarItem} item
    */
   appendToolbarItem(item) {
     this._items.push(item);
     item._toolbar = this;
     if (this._reverse)
       this._contentElement.insertBefore(item.element, this._insertionPoint.nextSibling);
     else
       this._contentElement.insertBefore(item.element, this._insertionPoint);
     this._hideSeparatorDupes();
   }
 
   appendSeparator() {
-    this.appendToolbarItem(new WebInspector.ToolbarSeparator());
+    this.appendToolbarItem(new UI.ToolbarSeparator());
   }
 
   appendSpacer() {
-    this.appendToolbarItem(new WebInspector.ToolbarSeparator(true));
+    this.appendToolbarItem(new UI.ToolbarSeparator(true));
   }
 
   /**
    * @param {string} text
    */
   appendText(text) {
-    this.appendToolbarItem(new WebInspector.ToolbarText(text));
+    this.appendToolbarItem(new UI.ToolbarText(text));
   }
 
   removeToolbarItems() {
     for (var item of this._items)
       delete item._toolbar;
     this._items = [];
     this._contentElement.removeChildren();
     this._insertionPoint = this._contentElement.createChild('content');
   }
 
@@ skipping 17 matching lines @@
   }
 
   _hideSeparatorDupes() {
     if (!this._items.length)
       return;
     // Don't hide first and last separators if they were added explicitly.
     var previousIsSeparator = false;
     var lastSeparator;
     var nonSeparatorVisible = false;
     for (var i = 0; i < this._items.length; ++i) {
-      if (this._items[i] instanceof WebInspector.ToolbarSeparator) {
+      if (this._items[i] instanceof UI.ToolbarSeparator) {
         this._items[i].setVisible(!previousIsSeparator);
         previousIsSeparator = true;
         lastSeparator = this._items[i];
         continue;
       }
       if (this._items[i].visible()) {
         previousIsSeparator = false;
         lastSeparator = null;
         nonSeparatorVisible = true;
       }
     }
     if (lastSeparator && lastSeparator !== this._items.peekLast())
       lastSeparator.setVisible(false);
 
     this.element.classList.toggle('hidden', !!lastSeparator && lastSeparator.visible() && !nonSeparatorVisible);
   }
 
   /**
    * @param {string} location
    */
   appendLocationItems(location) {
-    var extensions = self.runtime.extensions(WebInspector.ToolbarItem.Provider);
+    var extensions = self.runtime.extensions(UI.ToolbarItem.Provider);
     var promises = [];
     for (var i = 0; i < extensions.length; ++i) {
       if (extensions[i].descriptor()['location'] === location)
         promises.push(resolveItem(extensions[i]));
     }
     Promise.all(promises).then(appendItemsInOrder.bind(this));
 
     /**
      * @param {!Runtime.Extension} extension
-     * @return {!Promise.<?WebInspector.ToolbarItem>}
+     * @return {!Promise.<?UI.ToolbarItem>}
      */
     function resolveItem(extension) {
       var descriptor = extension.descriptor();
       if (descriptor['separator'])
-        return Promise.resolve(/** @type {?WebInspector.ToolbarItem} */ (new WebInspector.ToolbarSeparator()));
+        return Promise.resolve(/** @type {?UI.ToolbarItem} */ (new UI.ToolbarSeparator()));
       if (descriptor['actionId'])
-        return Promise.resolve(WebInspector.Toolbar.createActionButtonForId(descriptor['actionId']));
+        return Promise.resolve(UI.Toolbar.createActionButtonForId(descriptor['actionId']));
       return extension.instance().then(fetchItemFromProvider);
 
       /**
        * @param {!Object} provider
        */
       function fetchItemFromProvider(provider) {
-        return /** @type {!WebInspector.ToolbarItem.Provider} */ (provider).item();
+        return /** @type {!UI.ToolbarItem.Provider} */ (provider).item();
       }
     }
 
     /**
-     * @param {!Array.<?WebInspector.ToolbarItem>} items
-     * @this {WebInspector.Toolbar}
+     * @param {!Array.<?UI.ToolbarItem>} items
+     * @this {UI.Toolbar}
      */
     function appendItemsInOrder(items) {
       for (var i = 0; i < items.length; ++i) {
         var item = items[i];
         if (item)
           this.appendToolbarItem(item);
       }
     }
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.ToolbarItem = class extends WebInspector.Object {
+UI.ToolbarItem = class extends Common.Object {
   /**
    * @param {!Element} element
    */
   constructor(element) {
     super();
     this.element = element;
     this.element.classList.add('toolbar-item');
     this._visible = true;
     this._enabled = true;
     this.element.addEventListener('mouseenter', this._mouseEnter.bind(this), false);
     this.element.addEventListener('mouseleave', this._mouseLeave.bind(this), false);
   }
 
   /**
    * @param {string} title
    */
   setTitle(title) {
     if (this._title === title)
       return;
     this._title = title;
-    WebInspector.Tooltip.install(this.element, title);
+    UI.Tooltip.install(this.element, title);
   }
 
   _mouseEnter() {
     this.element.classList.add('hover');
   }
 
   _mouseLeave() {
     this.element.classList.remove('hover');
   }
 
@@ skipping 19 matching lines @@
   }
 
   /**
    * @param {boolean} x
    */
   setVisible(x) {
     if (this._visible === x)
       return;
     this.element.classList.toggle('hidden', !x);
     this._visible = x;
-    if (this._toolbar && !(this instanceof WebInspector.ToolbarSeparator))
+    if (this._toolbar && !(this instanceof UI.ToolbarSeparator))
       this._toolbar._hideSeparatorDupes();
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.ToolbarText = class extends WebInspector.ToolbarItem {
+UI.ToolbarText = class extends UI.ToolbarItem {
   /**
    * @param {string=} text
    */
   constructor(text) {
     super(createElementWithClass('div', 'toolbar-text'));
     this.element.classList.add('toolbar-text');
     this.setText(text || '');
   }
 
   /**
    * @param {string} text
    */
   setText(text) {
     this.element.textContent = text;
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.ToolbarButton = class extends WebInspector.ToolbarItem {
+UI.ToolbarButton = class extends UI.ToolbarItem {
   /**
    * @param {string} title
    * @param {string=} glyph
    * @param {string=} text
    */
   constructor(title, glyph, text) {
     super(createElementWithClass('button', 'toolbar-button'));
     this.element.addEventListener('click', this._clicked.bind(this), false);
     this.element.addEventListener('mousedown', this._mouseDown.bind(this), false);
     this.element.addEventListener('mouseup', this._mouseUp.bind(this), false);
 
-    this._glyphElement = WebInspector.Icon.create('', 'toolbar-glyph hidden');
+    this._glyphElement = UI.Icon.create('', 'toolbar-glyph hidden');
     this.element.appendChild(this._glyphElement);
     this._textElement = this.element.createChild('div', 'toolbar-text hidden');
 
     this.setTitle(title);
     if (glyph)
       this.setGlyph(glyph);
     this.setText(text || '');
     this._title = '';
   }
 
@@ skipping 25 matching lines @@
    */
   setBackgroundImage(iconURL) {
     this.element.style.backgroundImage = 'url(' + iconURL + ')';
   }
 
   /**
    * @param {number=} width
    */
   turnIntoSelect(width) {
     this.element.classList.add('toolbar-has-dropdown');
-    var dropdownArrowIcon = WebInspector.Icon.create('smallicon-dropdown-arrow', 'toolbar-dropdown-arrow');
+    var dropdownArrowIcon = UI.Icon.create('smallicon-dropdown-arrow', 'toolbar-dropdown-arrow');
     this.element.appendChild(dropdownArrowIcon);
     if (width)
       this.element.style.width = width + 'px';
   }
 
   /**
    * @param {!Event} event
    */
   _clicked(event) {
     var defaultPrevented = this.dispatchEventToListeners('click', event);
@@ skipping 11 matching lines @@
    * @param {!Event} event
    */
   _mouseUp(event) {
     this.dispatchEventToListeners('mouseup', event);
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.ToolbarInput = class extends WebInspector.ToolbarItem {
+UI.ToolbarInput = class extends UI.ToolbarItem {
   /**
    * @param {string=} placeholder
    * @param {number=} growFactor
    */
   constructor(placeholder, growFactor) {
     super(createElementWithClass('input', 'toolbar-item'));
     this.element.addEventListener('input', this._onChangeCallback.bind(this), false);
     if (growFactor)
       this.element.style.flexGrow = growFactor;
     if (placeholder)
@@ skipping 10 matching lines @@
   }
 
   /**
    * @return {string}
    */
   value() {
     return this.element.value;
   }
 
   _onChangeCallback() {
-    this.dispatchEventToListeners(WebInspector.ToolbarInput.Event.TextChanged, this.element.value);
+    this.dispatchEventToListeners(UI.ToolbarInput.Event.TextChanged, this.element.value);
   }
 };
 
-WebInspector.ToolbarInput.Event = {
+UI.ToolbarInput.Event = {
   TextChanged: 'TextChanged'
 };
 
 /**
  * @unrestricted
  */
-WebInspector.ToolbarToggle = class extends WebInspector.ToolbarButton {
+UI.ToolbarToggle = class extends UI.ToolbarButton {
   /**
    * @param {string} title
    * @param {string=} glyph
    * @param {string=} toggledGlyph
    */
   constructor(title, glyph, toggledGlyph) {
     super(title, glyph, '');
     this._toggled = false;
     this._untoggledGlyph = glyph;
     this._toggledGlyph = toggledGlyph;
@@ skipping 25 matching lines @@
    */
   setToggleWithRedColor(toggleWithRedColor) {
     this.element.classList.toggle('toolbar-toggle-with-red-color', toggleWithRedColor);
   }
 };
 
 
 /**
  * @unrestricted
  */
-WebInspector.ToolbarMenuButton = class extends WebInspector.ToolbarButton {
+UI.ToolbarMenuButton = class extends UI.ToolbarButton {
   /**
-   * @param {function(!WebInspector.ContextMenu)} contextMenuHandler
+   * @param {function(!UI.ContextMenu)} contextMenuHandler
    * @param {boolean=} useSoftMenu
    */
   constructor(contextMenuHandler, useSoftMenu) {
     super('', 'largeicon-menu');
     this._contextMenuHandler = contextMenuHandler;
     this._useSoftMenu = !!useSoftMenu;
   }
 
   /**
    * @override
@@ skipping 12 matching lines @@
   /**
    * @param {!Event} event
    */
   _trigger(event) {
     delete this._triggerTimeout;
 
     // Throttling avoids entering a bad state on Macs when rapidly triggering context menus just
     // after the window gains focus. See crbug.com/655556
     if (this._lastTriggerTime && Date.now() - this._lastTriggerTime < 300)
       return;
-    var contextMenu = new WebInspector.ContextMenu(
+    var contextMenu = new UI.ContextMenu(
         event, this._useSoftMenu, this.element.totalOffsetLeft(),
         this.element.totalOffsetTop() + this.element.offsetHeight);
     this._contextMenuHandler(contextMenu);
     contextMenu.show();
     this._lastTriggerTime = Date.now();
   }
 
   /**
    * @override
    * @param {!Event} event
    */
   _clicked(event) {
     if (!this._triggerTimeout)
       return;
     clearTimeout(this._triggerTimeout);
     this._trigger(event);
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.ToolbarSettingToggle = class extends WebInspector.ToolbarToggle {
+UI.ToolbarSettingToggle = class extends UI.ToolbarToggle {
   /**
-   * @param {!WebInspector.Setting} setting
+   * @param {!Common.Setting} setting
    * @param {string} glyph
    * @param {string} title
    * @param {string=} toggledTitle
    */
   constructor(setting, glyph, title, toggledTitle) {
     super(title, glyph);
     this._defaultTitle = title;
     this._toggledTitle = toggledTitle || title;
     this._setting = setting;
     this._settingChanged();
@@ skipping 12 matching lines @@
    */
   _clicked(event) {
     this._setting.set(!this.toggled());
     super._clicked(event);
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.ToolbarSeparator = class extends WebInspector.ToolbarItem {
+UI.ToolbarSeparator = class extends UI.ToolbarItem {
   /**
    * @param {boolean=} spacer
    */
   constructor(spacer) {
     super(createElementWithClass('div', spacer ? 'toolbar-spacer' : 'toolbar-divider'));
   }
 };
 
 /**
  * @interface
  */
-WebInspector.ToolbarItem.Provider = function() {};
+UI.ToolbarItem.Provider = function() {};
 
-WebInspector.ToolbarItem.Provider.prototype = {
+UI.ToolbarItem.Provider.prototype = {
   /**
-   * @return {?WebInspector.ToolbarItem}
+   * @return {?UI.ToolbarItem}
    */
   item: function() {}
 };
 
 /**
  * @interface
  */
-WebInspector.ToolbarItem.ItemsProvider = function() {};
+UI.ToolbarItem.ItemsProvider = function() {};
 
-WebInspector.ToolbarItem.ItemsProvider.prototype = {
+UI.ToolbarItem.ItemsProvider.prototype = {
   /**
-   * @return {!Array<!WebInspector.ToolbarItem>}
+   * @return {!Array<!UI.ToolbarItem>}
    */
   toolbarItems: function() {}
 };
 
 /**
  * @unrestricted
  */
-WebInspector.ToolbarComboBox = class extends WebInspector.ToolbarItem {
+UI.ToolbarComboBox = class extends UI.ToolbarItem {
   /**
    * @param {?function(!Event)} changeHandler
    * @param {string=} className
    */
   constructor(changeHandler, className) {
     super(createElementWithClass('span', 'toolbar-select-container'));
 
     this._selectElement = this.element.createChild('select', 'toolbar-item');
-    var dropdownArrowIcon = WebInspector.Icon.create('smallicon-dropdown-arrow', 'toolbar-dropdown-arrow');
+    var dropdownArrowIcon = UI.Icon.create('smallicon-dropdown-arrow', 'toolbar-dropdown-arrow');
     this.element.appendChild(dropdownArrowIcon);
     if (changeHandler)
       this._selectElement.addEventListener('change', changeHandler, false);
     if (className)
       this._selectElement.classList.add(className);
   }
 
   /**
    * @return {!HTMLSelectElement}
    */
@@ skipping 90 matching lines @@
    * @param {number} width
    */
   setMaxWidth(width) {
     this._selectElement.style.maxWidth = width + 'px';
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.ToolbarCheckbox = class extends WebInspector.ToolbarItem {
+UI.ToolbarCheckbox = class extends UI.ToolbarItem {
   /**
    * @param {string} text
    * @param {string=} title
-   * @param {!WebInspector.Setting=} setting
+   * @param {!Common.Setting=} setting
    * @param {function()=} listener
    */
   constructor(text, title, setting, listener) {
     super(createCheckboxLabel(text));
     this.element.classList.add('checkbox');
     this.inputElement = this.element.checkboxElement;
     if (title)
       this.element.title = title;
     if (setting)
-      WebInspector.SettingsUI.bindCheckbox(this.inputElement, setting);
+      UI.SettingsUI.bindCheckbox(this.inputElement, setting);
     if (listener)
       this.inputElement.addEventListener('click', listener, false);
   }
 
   /**
    * @return {boolean}
    */
   checked() {
     return this.inputElement.checked;
   }
 
   /**
    * @param {boolean} value
    */
   setChecked(value) {
     this.inputElement.checked = value;
   }
 };