DevTools: rename WebInspector into modules.

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

 /*
  * Copyright (C) 2010 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.TabbedPane = class extends WebInspector.VBox {
+UI.TabbedPane = class extends UI.VBox {
   constructor() {
     super(true);
     this.registerRequiredCSS('ui/tabbedPane.css');
     this.element.classList.add('tabbed-pane');
     this.contentElement.classList.add('tabbed-pane-shadow');
     this.contentElement.tabIndex = -1;
     this._headerElement = this.contentElement.createChild('div', 'tabbed-pane-header');
     this._headerContentsElement = this._headerElement.createChild('div', 'tabbed-pane-header-contents');
-    this._headerContentsElement.setAttribute('aria-label', WebInspector.UIString('Panels'));
+    this._headerContentsElement.setAttribute('aria-label', Common.UIString('Panels'));
     this._tabSlider = createElementWithClass('div', 'tabbed-pane-tab-slider');
     this._tabsElement = this._headerContentsElement.createChild('div', 'tabbed-pane-header-tabs');
     this._tabsElement.setAttribute('role', 'tablist');
     this._contentElement = this.contentElement.createChild('div', 'tabbed-pane-content');
     this._contentElement.setAttribute('role', 'tabpanel');
     this._contentElement.createChild('content');
-    /** @type {!Array.<!WebInspector.TabbedPaneTab>} */
+    /** @type {!Array.<!UI.TabbedPaneTab>} */
     this._tabs = [];
-    /** @type {!Array.<!WebInspector.TabbedPaneTab>} */
+    /** @type {!Array.<!UI.TabbedPaneTab>} */
     this._tabsHistory = [];
-    /** @type {!Object.<string, !WebInspector.TabbedPaneTab>} */
+    /** @type {!Object.<string, !UI.TabbedPaneTab>} */
     this._tabsById = {};
     this._currentTabLocked = false;
     this._autoSelectFirstItemOnShow = true;
 
     this._dropDownButton = this._createDropDownButton();
-    WebInspector.zoomManager.addEventListener(WebInspector.ZoomManager.Events.ZoomChanged, this._zoomChanged, this);
+    UI.zoomManager.addEventListener(UI.ZoomManager.Events.ZoomChanged, this._zoomChanged, this);
   }
 
   /**
    * @param {boolean} locked
    */
   setCurrentTabLocked(locked) {
     this._currentTabLocked = locked;
     this._headerElement.classList.toggle('locked', this._currentTabLocked);
   }
 
   /**
    * @param {boolean} autoSelect
    */
   setAutoSelectFirstItemOnShow(autoSelect) {
     this._autoSelectFirstItemOnShow = autoSelect;
   }
 
   /**
-   * @return {?WebInspector.Widget}
+   * @return {?UI.Widget}
    */
   get visibleView() {
     return this._currentTab ? this._currentTab.view : null;
   }
 
   /**
    * @return {!Array.<string>}
    */
   tabIds() {
     return this._tabs.map(tab => tab._id);
   }
 
   /**
    * @param {string} tabId
    * @return {number}
    */
   tabIndex(tabId) {
     return this._tabs.findIndex(tab => tab.id === tabId);
   }
 
   /**
-   * @return {!Array.<!WebInspector.Widget>}
+   * @return {!Array.<!UI.Widget>}
    */
   tabViews() {
     return this._tabs.map(tab => tab.view);
   }
 
   /**
    * @param {string} tabId
-   * @return {?WebInspector.Widget}
+   * @return {?UI.Widget}
    */
   tabView(tabId) {
     return this._tabsById[tabId] ? this._tabsById[tabId].view : null;
   }
 
   /**
    * @return {?string}
    */
   get selectedTabId() {
     return this._currentTab ? this._currentTab.id : null;
@@ skipping 42 matching lines @@
   /**
    * @param {string} id
    * @return {boolean}
    */
   isTabCloseable(id) {
     var tab = this._tabsById[id];
     return tab ? tab.isCloseable() : false;
   }
 
   /**
-   * @param {!WebInspector.TabbedPaneTabDelegate} delegate
+   * @param {!UI.TabbedPaneTabDelegate} delegate
    */
   setTabDelegate(delegate) {
     var tabs = this._tabs.slice();
     for (var i = 0; i < tabs.length; ++i)
       tabs[i].setDelegate(delegate);
     this._delegate = delegate;
   }
 
   /**
    * @param {string} id
    * @param {string} tabTitle
-   * @param {!WebInspector.Widget} view
+   * @param {!UI.Widget} view
    * @param {string=} tabTooltip
    * @param {boolean=} userGesture
    * @param {boolean=} isCloseable
    * @param {number=} index
    */
   appendTab(id, tabTitle, view, tabTooltip, userGesture, isCloseable, index) {
     isCloseable = typeof isCloseable === 'boolean' ? isCloseable : this._closeableTabs;
-    var tab = new WebInspector.TabbedPaneTab(this, id, tabTitle, isCloseable, view, tabTooltip);
+    var tab = new UI.TabbedPaneTab(this, id, tabTitle, isCloseable, view, tabTooltip);
     tab.setDelegate(this._delegate);
     this._tabsById[id] = tab;
     if (index !== undefined)
       this._tabs.splice(index, 0, tab);
     else
       this._tabs.push(tab);
     this._tabsHistory.push(tab);
     view.attach(this);
     if (this._tabsHistory[0] === tab && this.isShowing())
       this.selectTab(tab.id, userGesture);
@@ skipping 38 matching lines @@
     var tab = this._tabsById[id];
     delete this._tabsById[id];
 
     this._tabsHistory.splice(this._tabsHistory.indexOf(tab), 1);
     this._tabs.splice(this._tabs.indexOf(tab), 1);
     if (tab._shown)
       this._hideTabElement(tab);
     tab.view.detach();
 
     var eventData = {tabId: id, view: tab.view, isUserGesture: userGesture};
-    this.dispatchEventToListeners(WebInspector.TabbedPane.Events.TabClosed, eventData);
+    this.dispatchEventToListeners(UI.TabbedPane.Events.TabClosed, eventData);
     return true;
   }
 
   /**
    * @param {string} tabId
    * @return {boolean}
    */
   hasTab(tabId) {
     return !!this._tabsById[tabId];
   }
@@ skipping 61 matching lines @@
     this._currentTab = tab;
 
     this._tabsHistory.splice(this._tabsHistory.indexOf(tab), 1);
     this._tabsHistory.splice(0, 0, tab);
 
     this._updateTabElements();
     if (focused)
       this.focus();
 
     var eventData = {tabId: id, view: tab.view, isUserGesture: userGesture};
-    this.dispatchEventToListeners(WebInspector.TabbedPane.Events.TabSelected, eventData);
+    this.dispatchEventToListeners(UI.TabbedPane.Events.TabSelected, eventData);
     return true;
   }
 
   /**
    * @param {number} tabsCount
    * @return {!Array.<string>}
    */
   lastOpenedTabIds(tabsCount) {
     function tabToTabId(tab) {
       return tab.id;
@@ skipping 27 matching lines @@
    * @param {string} className
    * @param {boolean=} force
    */
   toggleTabClass(id, className, force) {
     var tab = this._tabsById[id];
     if (tab._toggleClass(className, force))
       this._updateTabElements();
   }
 
   /**
-   * @param {!WebInspector.Event} event
+   * @param {!Common.Event} event
    */
   _zoomChanged(event) {
     for (var i = 0; i < this._tabs.length; ++i)
       delete this._tabs[i]._measuredWidth;
     if (this.isShowing())
       this._updateTabElements();
   }
 
   /**
    * @param {string} id
    * @param {string} tabTitle
    * @param {string=} tabTooltip
    */
   changeTabTitle(id, tabTitle, tabTooltip) {
     var tab = this._tabsById[id];
     if (tabTooltip !== undefined)
       tab.tooltip = tabTooltip;
     if (tab.title !== tabTitle) {
       tab.title = tabTitle;
       this._updateTabElements();
     }
   }
 
   /**
    * @param {string} id
-   * @param {!WebInspector.Widget} view
+   * @param {!UI.Widget} view
    */
   changeTabView(id, view) {
     var tab = this._tabsById[id];
     if (tab.view === view)
       return;
 
     var shouldFocus = tab.view.hasFocus();
 
     this.suspendInvalidations();
 
@@ skipping 48 matching lines @@
     var minContentConstraints = new Constraints(new Size(0, 0), new Size(50, 50));
     constraints = constraints.widthToMax(minContentConstraints).heightToMax(minContentConstraints);
     if (this._verticalTabLayout)
       constraints = constraints.addWidth(new Constraints(new Size(120, 0)));
     else
       constraints = constraints.addHeight(new Constraints(new Size(0, 30)));
     return constraints;
   }
 
   _updateTabElements() {
-    WebInspector.invokeOnceAfterBatchUpdate(this, this._innerUpdateTabElements);
+    UI.invokeOnceAfterBatchUpdate(this, this._innerUpdateTabElements);
   }
 
   /**
    * @param {string} text
    */
   setPlaceholderText(text) {
     this._noTabsMessage = text;
   }
 
   _innerUpdateTabElements() {
@@ skipping 15 matching lines @@
     }
 
     this._measureDropDownButton();
     this._updateWidths();
     this._updateTabsDropDown();
     this._updateTabSlider();
   }
 
   /**
    * @param {number} index
-   * @param {!WebInspector.TabbedPaneTab} tab
+   * @param {!UI.TabbedPaneTab} tab
    */
   _showTabElement(index, tab) {
     if (index >= this._tabsElement.children.length)
       this._tabsElement.appendChild(tab.tabElement);
     else
       this._tabsElement.insertBefore(tab.tabElement, this._tabsElement.children[index]);
     tab._shown = true;
   }
 
   /**
-   * @param {!WebInspector.TabbedPaneTab} tab
+   * @param {!UI.TabbedPaneTab} tab
    */
   _hideTabElement(tab) {
     this._tabsElement.removeChild(tab.tabElement);
     tab._shown = false;
   }
 
   _createDropDownButton() {
     var dropDownContainer = createElementWithClass('div', 'tabbed-pane-header-tabs-drop-down-container');
     dropDownContainer.createChild('div', 'glyph');
-    this._dropDownMenu = new WebInspector.DropDownMenu(dropDownContainer);
+    this._dropDownMenu = new UI.DropDownMenu(dropDownContainer);
     this._dropDownMenu.addEventListener(
-        WebInspector.DropDownMenu.Events.ItemSelected, this._dropDownMenuItemSelected, this);
+        UI.DropDownMenu.Events.ItemSelected, this._dropDownMenuItemSelected, this);
 
     return dropDownContainer;
   }
 
   /**
-   * @param {!WebInspector.Event} event
+   * @param {!Common.Event} event
    */
   _dropDownMenuItemSelected(event) {
     var tabId = /** @type {string} */ (event.data);
     this._lastSelectedOverflowTab = this._tabsById[tabId];
     this.selectTab(tabId, true);
   }
 
   _totalWidth() {
     return this._headerContentsElement.getBoundingClientRect().width;
   }
@@ skipping 140 matching lines @@
 
       if (totalWidth + totalExtraWidth >= totalMeasuredWidth)
         return measuredWidths[i - 1] +
             (totalWidth + totalExtraWidth - totalMeasuredWidth) / (measuredWidths.length - i);
     }
 
     return totalWidth / measuredWidths.length;
   }
 
   /**
-   * @param {!Array.<!WebInspector.TabbedPaneTab>} tabsOrdered
-   * @param {!Array.<!WebInspector.TabbedPaneTab>} tabsHistory
+   * @param {!Array.<!UI.TabbedPaneTab>} tabsOrdered
+   * @param {!Array.<!UI.TabbedPaneTab>} tabsHistory
    * @param {number} totalWidth
    * @param {number} measuredDropDownButtonWidth
    * @return {!Array.<number>}
    */
   _tabsToShowIndexes(tabsOrdered, tabsHistory, totalWidth, measuredDropDownButtonWidth) {
     var tabsToShowIndexes = [];
 
     var totalTabsWidth = 0;
     var tabCount = tabsOrdered.length;
     var tabsToLookAt = tabsOrdered.slice(0);
@@ skipping 21 matching lines @@
 
   _hideCurrentTab() {
     if (!this._currentTab)
       return;
 
     this._hideTab(this._currentTab);
     delete this._currentTab;
   }
 
   /**
-   * @param {!WebInspector.TabbedPaneTab} tab
+   * @param {!UI.TabbedPaneTab} tab
    */
   _showTab(tab) {
     tab.tabElement.classList.add('selected');
     tab.tabElement.setAttribute('aria-selected', 'true');
     tab.view.showWidget(this.element);
     this._updateTabSlider();
   }
 
   _updateTabSlider() {
     if (!this._currentTab || !this._sliderEnabled)
       return;
     var left = 0;
     for (var i = 0; i < this._tabs.length && this._currentTab !== this._tabs[i] && this._tabs[i]._shown; i++)
       left += this._tabs[i]._measuredWidth;
     var sliderWidth = this._currentTab._shown ? this._currentTab._measuredWidth : this._dropDownButton.offsetWidth;
     var scaleFactor = window.devicePixelRatio >= 1.5 ? ' scaleY(0.75)' : '';
     this._tabSlider.style.transform = 'translateX(' + left + 'px)' + scaleFactor;
     this._tabSlider.style.width = sliderWidth + 'px';
 
     if (this._tabSlider.parentElement !== this._headerContentsElement)
       this._headerContentsElement.appendChild(this._tabSlider);
   }
 
   /**
-   * @param {!WebInspector.TabbedPaneTab} tab
+   * @param {!UI.TabbedPaneTab} tab
    */
   _hideTab(tab) {
     tab.tabElement.classList.remove('selected');
     tab.tabElement.setAttribute('aria-selected', 'false');
     tab.view.hideWidget();
   }
 
   /**
    * @override
    * @return {!Array.<!Element>}
    */
   elementsToRestoreScrollPositionsFor() {
     return [this._contentElement];
   }
 
   /**
-   * @param {!WebInspector.TabbedPaneTab} tab
+   * @param {!UI.TabbedPaneTab} tab
    * @param {number} index
    */
   _insertBefore(tab, index) {
     this._tabsElement.insertBefore(tab._tabElement || null, this._tabsElement.childNodes[index]);
     var oldIndex = this._tabs.indexOf(tab);
     this._tabs.splice(oldIndex, 1);
     if (oldIndex < index)
       --index;
     this._tabs.splice(index, 0, tab);
-    this.dispatchEventToListeners(WebInspector.TabbedPane.Events.TabOrderChanged, this._tabs);
+    this.dispatchEventToListeners(UI.TabbedPane.Events.TabOrderChanged, this._tabs);
   }
 
   /**
-   * @return {!WebInspector.Toolbar}
+   * @return {!UI.Toolbar}
    */
   leftToolbar() {
     if (!this._leftToolbar) {
-      this._leftToolbar = new WebInspector.Toolbar('tabbed-pane-left-toolbar');
+      this._leftToolbar = new UI.Toolbar('tabbed-pane-left-toolbar');
       this._headerElement.insertBefore(this._leftToolbar.element, this._headerElement.firstChild);
     }
     return this._leftToolbar;
   }
 
   /**
-   * @return {!WebInspector.Toolbar}
+   * @return {!UI.Toolbar}
    */
   rightToolbar() {
     if (!this._rightToolbar) {
-      this._rightToolbar = new WebInspector.Toolbar('tabbed-pane-right-toolbar');
+      this._rightToolbar = new UI.Toolbar('tabbed-pane-right-toolbar');
       this._headerElement.appendChild(this._rightToolbar.element);
     }
     return this._rightToolbar;
   }
 
   renderWithNoHeaderBackground() {
     this._headerElement.classList.add('tabbed-pane-no-header-background');
   }
 
   /**
    * @param {boolean} allow
    * @param {boolean=} automatic
    */
   setAllowTabReorder(allow, automatic) {
     this._allowTabReorder = allow;
     this._automaticReorder = automatic;
   }
 };
 
 /** @enum {symbol} */
-WebInspector.TabbedPane.Events = {
+UI.TabbedPane.Events = {
   TabSelected: Symbol('TabSelected'),
   TabClosed: Symbol('TabClosed'),
   TabOrderChanged: Symbol('TabOrderChanged')
 };
 
 /**
  * @unrestricted
  */
-WebInspector.TabbedPaneTab = class {
+UI.TabbedPaneTab = class {
   /**
-   * @param {!WebInspector.TabbedPane} tabbedPane
+   * @param {!UI.TabbedPane} tabbedPane
    * @param {string} id
    * @param {string} title
    * @param {boolean} closeable
-   * @param {!WebInspector.Widget} view
+   * @param {!UI.Widget} view
    * @param {string=} tooltip
    */
   constructor(tabbedPane, id, title, closeable, view, tooltip) {
     this._closeable = closeable;
     this._tabbedPane = tabbedPane;
     this._id = id;
     this._title = title;
     this._tooltip = tooltip;
     this._view = view;
     this._shown = false;
@@ skipping 59 matching lines @@
     var element = this.tabElement;
     var hasClass = element.classList.contains(className);
     if (hasClass === force)
       return false;
     element.classList.toggle(className, force);
     delete this._measuredWidth;
     return true;
   }
 
   /**
-   * @return {!WebInspector.Widget}
+   * @return {!UI.Widget}
    */
   get view() {
     return this._view;
   }
 
   /**
-   * @param {!WebInspector.Widget} view
+   * @param {!UI.Widget} view
    */
   set view(view) {
     this._view = view;
   }
 
   /**
    * @return {string|undefined}
    */
   get tooltip() {
     return this._tooltip;
@@ skipping 27 matching lines @@
 
   /**
    * @param {number} width
    */
   setWidth(width) {
     this.tabElement.style.width = width === -1 ? '' : (width + 'px');
     this._width = width;
   }
 
   /**
-   * @param {!WebInspector.TabbedPaneTabDelegate} delegate
+   * @param {!UI.TabbedPaneTabDelegate} delegate
    */
   setDelegate(delegate) {
     this._delegate = delegate;
   }
 
   /**
    * @param {!Element} tabElement
    * @param {!Element} titleElement
    */
   _createIconElement(tabElement, titleElement) {
@@ skipping 35 matching lines @@
     if (measuring) {
       tabElement.classList.add('measuring');
     } else {
       tabElement.addEventListener('click', this._tabClicked.bind(this), false);
       tabElement.addEventListener('auxclick', this._tabClicked.bind(this), false);
       tabElement.addEventListener('mousedown', this._tabMouseDown.bind(this), false);
       tabElement.addEventListener('mouseup', this._tabMouseUp.bind(this), false);
 
       tabElement.addEventListener('contextmenu', this._tabContextMenu.bind(this), false);
       if (this._tabbedPane._allowTabReorder)
-        WebInspector.installDragHandle(
+        UI.installDragHandle(
             tabElement, this._startTabDragging.bind(this), this._tabDragging.bind(this),
             this._endTabDragging.bind(this), '-webkit-grabbing', 'pointer', 200);
     }
 
     return tabElement;
   }
 
   /**
    * @param {!Event} event
    */
@@ skipping 32 matching lines @@
   _closeTabs(ids) {
     if (this._delegate) {
       this._delegate.closeTabs(this._tabbedPane, ids);
       return;
     }
     this._tabbedPane.closeTabs(ids, true);
   }
 
   _tabContextMenu(event) {
     /**
-     * @this {WebInspector.TabbedPaneTab}
+     * @this {UI.TabbedPaneTab}
      */
     function close() {
       this._closeTabs([this.id]);
     }
 
     /**
-     * @this {WebInspector.TabbedPaneTab}
+     * @this {UI.TabbedPaneTab}
      */
     function closeOthers() {
       this._closeTabs(this._tabbedPane.otherTabs(this.id));
     }
 
     /**
-     * @this {WebInspector.TabbedPaneTab}
+     * @this {UI.TabbedPaneTab}
      */
     function closeAll() {
       this._closeTabs(this._tabbedPane.allTabs());
     }
 
     /**
-     * @this {WebInspector.TabbedPaneTab}
+     * @this {UI.TabbedPaneTab}
      */
     function closeToTheRight() {
       this._closeTabs(this._tabbedPane._tabsToTheRight(this.id));
     }
 
-    var contextMenu = new WebInspector.ContextMenu(event);
+    var contextMenu = new UI.ContextMenu(event);
     if (this._closeable) {
-      contextMenu.appendItem(WebInspector.UIString.capitalize('Close'), close.bind(this));
-      contextMenu.appendItem(WebInspector.UIString.capitalize('Close ^others'), closeOthers.bind(this));
-      contextMenu.appendItem(WebInspector.UIString.capitalize('Close ^tabs to the ^right'), closeToTheRight.bind(this));
-      contextMenu.appendItem(WebInspector.UIString.capitalize('Close ^all'), closeAll.bind(this));
+      contextMenu.appendItem(Common.UIString.capitalize('Close'), close.bind(this));
+      contextMenu.appendItem(Common.UIString.capitalize('Close ^others'), closeOthers.bind(this));
+      contextMenu.appendItem(Common.UIString.capitalize('Close ^tabs to the ^right'), closeToTheRight.bind(this));
+      contextMenu.appendItem(Common.UIString.capitalize('Close ^all'), closeAll.bind(this));
     }
     if (this._delegate)
       this._delegate.onContextMenu(this.id, contextMenu);
     contextMenu.show();
   }
 
   /**
    * @param {!Event} event
    * @return {boolean}
    */
@@ skipping 54 matching lines @@
     this._tabElement.classList.remove('dragging');
     this._tabElement.style.removeProperty('left');
     delete this._dragStartX;
     this._tabbedPane._updateTabSlider();
   }
 };
 
 /**
  * @interface
  */
-WebInspector.TabbedPaneTabDelegate = function() {};
+UI.TabbedPaneTabDelegate = function() {};
 
-WebInspector.TabbedPaneTabDelegate.prototype = {
+UI.TabbedPaneTabDelegate.prototype = {
   /**
-   * @param {!WebInspector.TabbedPane} tabbedPane
+   * @param {!UI.TabbedPane} tabbedPane
    * @param {!Array.<string>} ids
    */
   closeTabs: function(tabbedPane, ids) {},
 
   /**
    * @param {string} tabId
-   * @param {!WebInspector.ContextMenu} contextMenu
+   * @param {!UI.ContextMenu} contextMenu
    */
   onContextMenu: function(tabId, contextMenu) {}
 };