DevTools: rename WebInspector into modules.

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

 /*
  * Copyright (C) 2013 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 12 matching lines @@
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * 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.
  */
 /**
  * @interface
  */
-WebInspector.SuggestBoxDelegate = function() {};
+UI.SuggestBoxDelegate = function() {};
 
-WebInspector.SuggestBoxDelegate.prototype = {
+UI.SuggestBoxDelegate.prototype = {
   /**
    * @param {string} suggestion
    * @param {boolean=} isIntermediateSuggestion
    */
   applySuggestion: function(suggestion, isIntermediateSuggestion) {},
 
   /**
    * acceptSuggestion will be always called after call to applySuggestion with isIntermediateSuggestion being equal to false.
    */
   acceptSuggestion: function() {},
 };
 
 /**
- * @implements {WebInspector.StaticViewportControl.Provider}
+ * @implements {UI.StaticViewportControl.Provider}
  * @unrestricted
  */
-WebInspector.SuggestBox = class {
+UI.SuggestBox = class {
   /**
-   * @param {!WebInspector.SuggestBoxDelegate} suggestBoxDelegate
+   * @param {!UI.SuggestBoxDelegate} suggestBoxDelegate
    * @param {number=} maxItemsHeight
    * @param {boolean=} captureEnter
    */
   constructor(suggestBoxDelegate, maxItemsHeight, captureEnter) {
     this._suggestBoxDelegate = suggestBoxDelegate;
     this._length = 0;
     this._selectedIndex = -1;
     this._selectedElement = null;
     this._maxItemsHeight = maxItemsHeight;
     this._maybeHideBound = this._maybeHide.bind(this);
     this._container = createElementWithClass('div', 'suggest-box-container');
-    this._viewport = new WebInspector.StaticViewportControl(this);
+    this._viewport = new UI.StaticViewportControl(this);
     this._element = this._viewport.element;
     this._element.classList.add('suggest-box');
     this._container.appendChild(this._element);
     this._element.addEventListener('mousedown', this._onBoxMouseDown.bind(this), true);
     this._detailsPopup = this._container.createChild('div', 'suggest-box details-popup monospace');
     this._detailsPopup.classList.add('hidden');
     this._asyncDetailsCallback = null;
     /** @type {!Map<number, !Promise<{detail: string, description: string}>>} */
     this._asyncDetailsPromises = new Map();
     this._userInteracted = false;
     this._captureEnter = captureEnter;
     /** @type {!Array<!Element>} */
     this._elementList = [];
     this._rowHeight = 17;
     this._viewportWidth = '100vw';
     this._hasVerticalScroll = false;
     this._userEnteredText = '';
-    /** @type {!WebInspector.SuggestBox.Suggestions} */
+    /** @type {!UI.SuggestBox.Suggestions} */
     this._items = [];
   }
 
   /**
    * @return {boolean}
    */
   visible() {
     return !!this._container.parentElement;
   }
 
   /**
    * @param {!AnchorBox} anchorBox
    */
   setPosition(anchorBox) {
     this._updateBoxPosition(anchorBox);
   }
 
   /**
    * @param {!AnchorBox} anchorBox
    */
   _updateBoxPosition(anchorBox) {
     console.assert(this._overlay);
     if (this._lastAnchorBox && this._lastAnchorBox.equals(anchorBox) && this._lastItemCount === this.itemCount())
       return;
     this._lastItemCount = this.itemCount();
     this._lastAnchorBox = anchorBox;
 
     // Position relative to main DevTools element.
-    var container = WebInspector.Dialog.modalHostView().element;
+    var container = UI.Dialog.modalHostView().element;
     anchorBox = anchorBox.relativeToElement(container);
     var totalHeight = container.offsetHeight;
     var aboveHeight = anchorBox.y;
     var underHeight = totalHeight - anchorBox.y - anchorBox.height;
 
     this._overlay.setLeftOffset(anchorBox.x);
 
     var under = underHeight >= aboveHeight;
     if (under)
       this._overlay.setVerticalOffset(anchorBox.y + anchorBox.height, true);
@@ skipping 13 matching lines @@
       this._element.style.width = '100vw';
       return;
     }
     // If there are no scrollbars, set the width to the width of the largest row.
     var maxIndex = 0;
     for (var i = 0; i < this._items.length; i++) {
       if (this._items[i].title.length > this._items[maxIndex].title.length)
         maxIndex = i;
     }
     var element = /** @type {!Element} */ (this.itemElement(maxIndex));
-    this._element.style.width = WebInspector.measurePreferredSize(element, this._element).width + 'px';
+    this._element.style.width = UI.measurePreferredSize(element, this._element).width + 'px';
   }
 
   /**
    * @param {!Event} event
    */
   _onBoxMouseDown(event) {
     if (this._hideTimeoutId) {
       window.clearTimeout(this._hideTimeoutId);
       delete this._hideTimeoutId;
     }
     event.preventDefault();
   }
 
   _maybeHide() {
     if (!this._hideTimeoutId)
       this._hideTimeoutId = window.setTimeout(this.hide.bind(this), 0);
   }
 
   /**
    * // FIXME: make SuggestBox work for multiple documents.
    * @suppressGlobalPropertiesCheck
    */
   _show() {
     if (this.visible())
       return;
     this._bodyElement = document.body;
     this._bodyElement.addEventListener('mousedown', this._maybeHideBound, true);
-    this._overlay = new WebInspector.SuggestBox.Overlay();
+    this._overlay = new UI.SuggestBox.Overlay();
     this._overlay.setContentElement(this._container);
     var measuringElement = this._createItemElement('1', '12');
     this._viewport.element.appendChild(measuringElement);
     this._rowHeight = measuringElement.getBoundingClientRect().height;
     measuringElement.remove();
   }
 
   hide() {
     if (!this.visible())
       return;
@@ skipping 99 matching lines @@
     if (index > -1)
       element.createChild('span', 'query').textContent = displayText.substring(index, index + query.length);
     element.createChild('span').textContent = displayText.substring(index > -1 ? index + query.length : 0);
     element.__fullValue = text;
     element.createChild('span', 'spacer');
     element.addEventListener('mousedown', this._onItemMouseDown.bind(this), false);
     return element;
   }
 
   /**
-   * @param {!WebInspector.SuggestBox.Suggestions} items
+   * @param {!UI.SuggestBox.Suggestions} items
    * @param {string} userEnteredText
    * @param {function(number): !Promise<{detail:string, description:string}>=} asyncDetails
    */
   _updateItems(items, userEnteredText, asyncDetails) {
     this._length = items.length;
     this._asyncDetailsPromises.clear();
     this._asyncDetailsCallback = asyncDetails;
     this._elementList = [];
     delete this._selectedElement;
 
@@ skipping 41 matching lines @@
     this._selectedElement.classList.add('selected');
     this._detailsPopup.classList.add('hidden');
     var elem = this._selectedElement;
     this._asyncDetails(index).then(showDetails.bind(this), function() {});
 
     if (scrollIntoView)
       this._viewport.scrollItemIntoView(index);
 
     /**
      * @param {?{detail: string, description: string}} details
-     * @this {WebInspector.SuggestBox}
+     * @this {UI.SuggestBox}
      */
     function showDetails(details) {
       if (elem === this._selectedElement)
         this._showDetailsPopup(details);
     }
   }
 
   /**
-   * @param {!WebInspector.SuggestBox.Suggestions} completions
+   * @param {!UI.SuggestBox.Suggestions} completions
    * @param {boolean} canShowForSingleItem
    * @param {string} userEnteredText
    * @return {boolean}
    */
   _canShowBox(completions, canShowForSingleItem, userEnteredText) {
     if (!completions || !completions.length)
       return false;
 
     if (completions.length > 1)
       return true;
 
     if (!completions[0].title.startsWith(userEnteredText))
       return true;
 
     // Do not show a single suggestion if it is the same as user-entered query, even if allowed to show single-item suggest boxes.
     return canShowForSingleItem && completions[0].title !== userEnteredText;
   }
 
   _ensureRowCountPerViewport() {
     if (this._rowCountPerViewport)
       return;
     if (!this._items.length)
       return;
 
     this._rowCountPerViewport = Math.floor(this._element.getBoundingClientRect().height / this._rowHeight);
   }
 
   /**
    * @param {!AnchorBox} anchorBox
-   * @param {!WebInspector.SuggestBox.Suggestions} completions
+   * @param {!UI.SuggestBox.Suggestions} completions
    * @param {number} selectedIndex
    * @param {boolean} canShowForSingleItem
    * @param {string} userEnteredText
    * @param {function(number): !Promise<{detail:string, description:string}>=} asyncDetails
    */
   updateSuggestions(anchorBox, completions, selectedIndex, canShowForSingleItem, userEnteredText, asyncDetails) {
     delete this._onlyCompletion;
     if (this._canShowBox(completions, canShowForSingleItem, userEnteredText)) {
       this._updateItems(completions, userEnteredText, asyncDetails);
       this._show();
@@ skipping 100 matching lines @@
     if (!this._elementList[index])
       this._elementList[index] =
           this._createItemElement(this._userEnteredText, this._items[index].title, this._items[index].className);
     return this._elementList[index];
   }
 };
 
 /**
  * @typedef {!Array.<{title: string, className: (string|undefined)}>}
  */
-WebInspector.SuggestBox.Suggestions;
+UI.SuggestBox.Suggestions;
 
 /**
  * @unrestricted
  */
-WebInspector.SuggestBox.Overlay = class {
+UI.SuggestBox.Overlay = class {
   /**
    * // FIXME: make SuggestBox work for multiple documents.
    * @suppressGlobalPropertiesCheck
    */
   constructor() {
     this.element = createElementWithClass('div', 'suggest-box-overlay');
-    var root = WebInspector.createShadowRootWithCoreStyles(this.element, 'ui/suggestBox.css');
+    var root = UI.createShadowRootWithCoreStyles(this.element, 'ui/suggestBox.css');
     this._leftSpacerElement = root.createChild('div', 'suggest-box-left-spacer');
     this._horizontalElement = root.createChild('div', 'suggest-box-horizontal');
     this._topSpacerElement = this._horizontalElement.createChild('div', 'suggest-box-top-spacer');
     this._bottomSpacerElement = this._horizontalElement.createChild('div', 'suggest-box-bottom-spacer');
     this._resize();
     document.body.appendChild(this.element);
   }
 
   /**
    * @param {number} offset
@@ skipping 19 matching lines @@
   }
 
   /**
    * @param {!Element} element
    */
   setContentElement(element) {
     this._horizontalElement.insertBefore(element, this._bottomSpacerElement);
   }
 
   _resize() {
-    var container = WebInspector.Dialog.modalHostView().element;
+    var container = UI.Dialog.modalHostView().element;
     var containerBox = container.boxInWindow(container.ownerDocument.defaultView);
 
     this.element.style.left = containerBox.x + 'px';
     this.element.style.top = containerBox.y + 'px';
     this.element.style.height = containerBox.height + 'px';
     this.element.style.width = containerBox.width + 'px';
   }
 
   dispose() {
     this.element.remove();
   }
 };