DevTools: rename WebInspector into modules.

third_party/WebKit/Source/devtools/front_end/ui/Popover.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.Popover = class extends WebInspector.Widget {
+UI.Popover = class extends UI.Widget {
   /**
-   * @param {!WebInspector.PopoverHelper=} popoverHelper
+   * @param {!UI.PopoverHelper=} popoverHelper
    */
   constructor(popoverHelper) {
     super();
     this.markAsRoot();
-    this.element.className = WebInspector.Popover._classNamePrefix;  // Override
+    this.element.className = UI.Popover._classNamePrefix;  // Override
     this._containerElement = createElementWithClass('div', 'fill popover-container');
 
     this._popupArrowElement = this.element.createChild('div', 'arrow');
     this._contentDiv = this.element.createChild('div', 'content');
 
     this._popoverHelper = popoverHelper;
     this._hideBound = this.hide.bind(this);
   }
 
   /**
    * @param {!Element} element
    * @param {!Element|!AnchorBox} anchor
    * @param {?number=} preferredWidth
    * @param {?number=} preferredHeight
-   * @param {?WebInspector.Popover.Orientation=} arrowDirection
+   * @param {?UI.Popover.Orientation=} arrowDirection
    */
   showForAnchor(element, anchor, preferredWidth, preferredHeight, arrowDirection) {
     this._innerShow(null, element, anchor, preferredWidth, preferredHeight, arrowDirection);
   }
 
   /**
-   * @param {!WebInspector.Widget} view
+   * @param {!UI.Widget} view
    * @param {!Element|!AnchorBox} anchor
    * @param {?number=} preferredWidth
    * @param {?number=} preferredHeight
    */
   showView(view, anchor, preferredWidth, preferredHeight) {
     this._innerShow(view, view.element, anchor, preferredWidth, preferredHeight);
   }
 
   /**
-   * @param {?WebInspector.Widget} view
+   * @param {?UI.Widget} view
    * @param {!Element} contentElement
    * @param {!Element|!AnchorBox} anchor
    * @param {?number=} preferredWidth
    * @param {?number=} preferredHeight
-   * @param {?WebInspector.Popover.Orientation=} arrowDirection
+   * @param {?UI.Popover.Orientation=} arrowDirection
    */
   _innerShow(view, contentElement, anchor, preferredWidth, preferredHeight, arrowDirection) {
     if (this._disposed)
       return;
     this._contentElement = contentElement;
 
     // This should not happen, but we hide previous popup to be on the safe side.
-    if (WebInspector.Popover._popover)
-      WebInspector.Popover._popover.hide();
-    WebInspector.Popover._popover = this;
+    if (UI.Popover._popover)
+      UI.Popover._popover.hide();
+    UI.Popover._popover = this;
 
     var document = anchor instanceof Element ? anchor.ownerDocument : contentElement.ownerDocument;
     var window = document.defaultView;
 
     // Temporarily attach in order to measure preferred dimensions.
-    var preferredSize = view ? view.measurePreferredSize() : WebInspector.measurePreferredSize(this._contentElement);
+    var preferredSize = view ? view.measurePreferredSize() : UI.measurePreferredSize(this._contentElement);
     this._preferredWidth = preferredWidth || preferredSize.width;
     this._preferredHeight = preferredHeight || preferredSize.height;
 
     window.addEventListener('resize', this._hideBound, false);
     document.body.appendChild(this._containerElement);
     super.show(this._containerElement);
 
     if (view)
       view.show(this._contentDiv);
     else
       this._contentDiv.appendChild(this._contentElement);
 
     this.positionElement(anchor, this._preferredWidth, this._preferredHeight, arrowDirection);
 
     if (this._popoverHelper) {
       this._contentDiv.addEventListener(
           'mousemove', this._popoverHelper._killHidePopoverTimer.bind(this._popoverHelper), true);
       this.element.addEventListener('mouseout', this._popoverHelper._popoverMouseOut.bind(this._popoverHelper), true);
     }
   }
 
   hide() {
     this._containerElement.ownerDocument.defaultView.removeEventListener('resize', this._hideBound, false);
     this.detach();
     this._containerElement.remove();
-    delete WebInspector.Popover._popover;
+    delete UI.Popover._popover;
   }
 
   get disposed() {
     return this._disposed;
   }
 
   dispose() {
     if (this.isShowing())
       this.hide();
     this._disposed = true;
@@ skipping 12 matching lines @@
    */
   setNoPadding(noPadding) {
     this._hasNoPadding = noPadding;
     this._contentDiv.classList.toggle('no-padding', this._hasNoPadding);
   }
 
   /**
    * @param {!Element|!AnchorBox} anchorElement
    * @param {number=} preferredWidth
    * @param {number=} preferredHeight
-   * @param {?WebInspector.Popover.Orientation=} arrowDirection
+   * @param {?UI.Popover.Orientation=} arrowDirection
    */
   positionElement(anchorElement, preferredWidth, preferredHeight, arrowDirection) {
     const borderWidth = this._hasNoPadding ? 0 : 8;
     const scrollerWidth = this._hasFixedHeight ? 0 : 14;
     const arrowHeight = this._hasNoPadding ? 8 : 15;
     const arrowOffset = 10;
     const borderRadius = 4;
     const arrowRadius = 6;
     preferredWidth = preferredWidth || this._preferredWidth;
     preferredHeight = preferredHeight || this._preferredHeight;
 
     // Skinny tooltips are not pretty, their arrow location is not nice.
     preferredWidth = Math.max(preferredWidth, 50);
     // Position relative to main DevTools element.
-    const container = WebInspector.Dialog.modalHostView().element;
+    const container = UI.Dialog.modalHostView().element;
     const totalWidth = container.offsetWidth;
     const totalHeight = container.offsetHeight;
 
     var anchorBox = anchorElement instanceof AnchorBox ? anchorElement : anchorElement.boxInWindow(window);
     anchorBox = anchorBox.relativeToElement(container);
     var newElementPosition = {x: 0, y: 0, width: preferredWidth + scrollerWidth, height: preferredHeight};
 
     var verticalAlignment;
     var roomAbove = anchorBox.y;
     var roomBelow = totalHeight - anchorBox.y - anchorBox.height;
     this._popupArrowElement.hidden = false;
 
-    if ((roomAbove > roomBelow) || (arrowDirection === WebInspector.Popover.Orientation.Bottom)) {
+    if ((roomAbove > roomBelow) || (arrowDirection === UI.Popover.Orientation.Bottom)) {
       // Positioning above the anchor.
       if ((anchorBox.y > newElementPosition.height + arrowHeight + borderRadius) ||
-          (arrowDirection === WebInspector.Popover.Orientation.Bottom))
+          (arrowDirection === UI.Popover.Orientation.Bottom))
         newElementPosition.y = anchorBox.y - newElementPosition.height - arrowHeight;
       else {
         this._popupArrowElement.hidden = true;
         newElementPosition.y = borderRadius;
         newElementPosition.height = anchorBox.y - borderRadius * 2 - arrowHeight;
         if (this._hasFixedHeight && newElementPosition.height < preferredHeight) {
           newElementPosition.y = borderRadius;
           newElementPosition.height = preferredHeight;
         }
       }
-      verticalAlignment = WebInspector.Popover.Orientation.Bottom;
+      verticalAlignment = UI.Popover.Orientation.Bottom;
     } else {
       // Positioning below the anchor.
       newElementPosition.y = anchorBox.y + anchorBox.height + arrowHeight;
       if ((newElementPosition.y + newElementPosition.height + borderRadius >= totalHeight) &&
-          (arrowDirection !== WebInspector.Popover.Orientation.Top)) {
+          (arrowDirection !== UI.Popover.Orientation.Top)) {
         this._popupArrowElement.hidden = true;
         newElementPosition.height = totalHeight - borderRadius - newElementPosition.y;
         if (this._hasFixedHeight && newElementPosition.height < preferredHeight) {
           newElementPosition.y = totalHeight - preferredHeight - borderRadius;
           newElementPosition.height = preferredHeight;
         }
       }
       // Align arrow.
-      verticalAlignment = WebInspector.Popover.Orientation.Top;
+      verticalAlignment = UI.Popover.Orientation.Top;
     }
 
     var horizontalAlignment;
     this._popupArrowElement.removeAttribute('style');
     if (anchorBox.x + newElementPosition.width < totalWidth) {
       newElementPosition.x = Math.max(borderRadius, anchorBox.x - borderRadius - arrowOffset);
       horizontalAlignment = 'left';
       this._popupArrowElement.style.left = arrowOffset + 'px';
     } else if (newElementPosition.width + borderRadius * 2 < totalWidth) {
       newElementPosition.x = totalWidth - newElementPosition.width - borderRadius - 2 * borderWidth;
       horizontalAlignment = 'right';
       // Position arrow accurately.
       var arrowRightPosition = Math.max(0, totalWidth - anchorBox.x - anchorBox.width - borderRadius - arrowOffset);
       arrowRightPosition += anchorBox.width / 2;
       arrowRightPosition = Math.min(arrowRightPosition, newElementPosition.width - borderRadius - arrowOffset);
       this._popupArrowElement.style.right = arrowRightPosition + 'px';
     } else {
       newElementPosition.x = borderRadius;
       newElementPosition.width = totalWidth - borderRadius * 2;
       newElementPosition.height += scrollerWidth;
       horizontalAlignment = 'left';
-      if (verticalAlignment === WebInspector.Popover.Orientation.Bottom)
+      if (verticalAlignment === UI.Popover.Orientation.Bottom)
         newElementPosition.y -= scrollerWidth;
       // Position arrow accurately.
       this._popupArrowElement.style.left =
           Math.max(0, anchorBox.x - newElementPosition.x - borderRadius - arrowRadius + anchorBox.width / 2) + 'px';
     }
 
     this.element.className =
-        WebInspector.Popover._classNamePrefix + ' ' + verticalAlignment + '-' + horizontalAlignment + '-arrow';
+        UI.Popover._classNamePrefix + ' ' + verticalAlignment + '-' + horizontalAlignment + '-arrow';
     this.element.positionAt(newElementPosition.x, newElementPosition.y - borderWidth, container);
     this.element.style.width = newElementPosition.width + borderWidth * 2 + 'px';
     this.element.style.height = newElementPosition.height + borderWidth * 2 + 'px';
   }
 };
 
-WebInspector.Popover._classNamePrefix = 'popover';
+UI.Popover._classNamePrefix = 'popover';
 
 /**
  * @unrestricted
  */
-WebInspector.PopoverHelper = class {
+UI.PopoverHelper = class {
   /**
    * @param {!Element} panelElement
    * @param {boolean=} disableOnClick
    */
   constructor(panelElement, disableOnClick) {
     this._disableOnClick = !!disableOnClick;
     panelElement.addEventListener('mousedown', this._mouseDown.bind(this), false);
     panelElement.addEventListener('mousemove', this._mouseMove.bind(this), false);
     panelElement.addEventListener('mouseout', this._mouseOut.bind(this), false);
     this.setTimeout(1000, 500);
   }
 
   /**
    * @param {function(!Element, !Event):(!Element|!AnchorBox|undefined)} getAnchor
-   * @param {function(!Element, !WebInspector.Popover):undefined} showPopover
+   * @param {function(!Element, !UI.Popover):undefined} showPopover
    * @param {function()=} onHide
    */
   initializeCallbacks(getAnchor, showPopover, onHide) {
     this._getAnchor = getAnchor;
     this._showPopover = showPopover;
     this._onHide = onHide;
   }
 
   /**
    * @param {number} timeout
@@ skipping 51 matching lines @@
     if (!this._eventInHoverElement(event))
       this._startHidePopoverTimer();
   }
 
   _startHidePopoverTimer() {
     // User has 500ms (this._hideTimeout) to reach the popup.
     if (!this._popover || this._hidePopoverTimer)
       return;
 
     /**
-     * @this {WebInspector.PopoverHelper}
+     * @this {UI.PopoverHelper}
      */
     function doHide() {
       this._hidePopover();
       delete this._hidePopoverTimer;
     }
     this._hidePopoverTimer = setTimeout(doHide.bind(this), this._hideTimeout);
   }
 
   _handleMouseAction(event, isMouseDown) {
     this._resetHoverTimer();
@@ skipping 34 matching lines @@
 
     this._popover.dispose();
     delete this._popover;
     this._hoverElement = null;
   }
 
   _mouseHover(element) {
     delete this._hoverTimer;
     this._hoverElement = element;
     this._hidePopover();
-    this._popover = new WebInspector.Popover(this);
+    this._popover = new UI.Popover(this);
     this._showPopover(element, this._popover);
   }
 
   _killHidePopoverTimer() {
     if (this._hidePopoverTimer) {
       clearTimeout(this._hidePopoverTimer);
       delete this._hidePopoverTimer;
 
       // We know that we reached the popup, but we might have moved over other elements.
       // Discard pending command.
       this._resetHoverTimer();
     }
   }
 };
 
 /** @enum {string} */
-WebInspector.Popover.Orientation = {
+UI.Popover.Orientation = {
   Top: 'top',
   Bottom: 'bottom'
 };