DevTools: rename WebInspector into modules.

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

 /*
  * Copyright (C) 2008 Apple Inc. All Rights Reserved.
  * Copyright (C) 2011 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 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.
  */
 
 /**
  * @unrestricted
  */
-WebInspector.Widget = class extends WebInspector.Object {
+UI.Widget = class extends Common.Object {
   /**
    * @param {boolean=} isWebComponent
    */
   constructor(isWebComponent) {
     super();
     this.contentElement = createElementWithClass('div', 'widget');
     if (isWebComponent) {
       this.element = createElementWithClass('div', 'vbox flex-auto');
-      this._shadowRoot = WebInspector.createShadowRootWithCoreStyles(this.element);
+      this._shadowRoot = UI.createShadowRootWithCoreStyles(this.element);
       this._shadowRoot.appendChild(this.contentElement);
     } else {
       this.element = this.contentElement;
     }
     this._isWebComponent = isWebComponent;
     this.element.__widget = this;
     this._visible = false;
     this._isRoot = false;
     this._isShowing = false;
     this._children = [];
@@ skipping 45 matching lines @@
       return;
 
     var widget = node.__widget;
     while (widget._parentWidget) {
       widget._parentWidget._defaultFocusedChild = widget;
       widget = widget._parentWidget;
     }
   }
 
   markAsRoot() {
-    WebInspector.Widget.__assert(!this.element.parentElement, 'Attempt to mark as root attached node');
+    UI.Widget.__assert(!this.element.parentElement, 'Attempt to mark as root attached node');
     this._isRoot = true;
   }
 
   /**
-   * @return {?WebInspector.Widget}
+   * @return {?UI.Widget}
    */
   parentWidget() {
     return this._parentWidget;
   }
 
   /**
-   * @return {!Array.<!WebInspector.Widget>}
+   * @return {!Array.<!UI.Widget>}
    */
   children() {
     return this._children;
   }
 
   /**
-   * @param {!WebInspector.Widget} widget
+   * @param {!UI.Widget} widget
    * @protected
    */
   childWasDetached(widget) {
   }
 
   /**
    * @return {boolean}
    */
   isShowing() {
     return this._isShowing;
@@ skipping 25 matching lines @@
     return !!this._notificationDepth || (this._parentWidget && this._parentWidget._inNotification());
   }
 
   _parentIsShowing() {
     if (this._isRoot)
       return true;
     return !!this._parentWidget && this._parentWidget.isShowing();
   }
 
   /**
-   * @param {function(this:WebInspector.Widget)} method
+   * @param {function(this:UI.Widget)} method
    */
   _callOnVisibleChildren(method) {
     var copy = this._children.slice();
     for (var i = 0; i < copy.length; ++i) {
       if (copy[i]._parentWidget === this && copy[i]._visible)
         method.call(copy[i]);
     }
   }
 
   _processWillShow() {
@@ skipping 33 matching lines @@
   _processOnResize() {
     if (this._inNotification())
       return;
     if (!this.isShowing())
       return;
     this._notify(this.onResize);
     this._callOnVisibleChildren(this._processOnResize);
   }
 
   /**
-   * @param {function(this:WebInspector.Widget)} notification
+   * @param {function(this:UI.Widget)} notification
    */
   _notify(notification) {
     ++this._notificationDepth;
     try {
       notification.call(this);
     } finally {
       --this._notificationDepth;
     }
   }
 
@@ skipping 10 matching lines @@
   }
 
   onLayout() {
   }
 
   /**
    * @param {!Element} parentElement
    * @param {?Element=} insertBefore
    */
   show(parentElement, insertBefore) {
-    WebInspector.Widget.__assert(parentElement, 'Attempt to attach widget with no parent element');
+    UI.Widget.__assert(parentElement, 'Attempt to attach widget with no parent element');
 
     if (!this._isRoot) {
       // Update widget hierarchy.
       var currentParent = parentElement;
       while (currentParent && !currentParent.__widget)
         currentParent = currentParent.parentElementOrShadowHost();
-      WebInspector.Widget.__assert(currentParent, 'Attempt to attach widget to orphan node');
+      UI.Widget.__assert(currentParent, 'Attempt to attach widget to orphan node');
       this.attach(currentParent.__widget);
     }
 
     this.showWidget(parentElement, insertBefore);
   }
 
   /**
-   * @param {!WebInspector.Widget} parentWidget
+   * @param {!UI.Widget} parentWidget
    */
   attach(parentWidget) {
     if (parentWidget === this._parentWidget)
       return;
     if (this._parentWidget)
       this.detach();
     this._parentWidget = parentWidget;
     this._parentWidget._children.push(this);
     this._isRoot = false;
   }
 
   /**
    * @param {!Element} parentElement
    * @param {?Element=} insertBefore
    */
   showWidget(parentElement, insertBefore) {
     var currentParent = parentElement;
     while (currentParent && !currentParent.__widget)
       currentParent = currentParent.parentElementOrShadowHost();
 
     if (this._isRoot)
-      WebInspector.Widget.__assert(!currentParent, 'Attempt to show root widget under another widget');
+      UI.Widget.__assert(!currentParent, 'Attempt to show root widget under another widget');
     else
-      WebInspector.Widget.__assert(
+      UI.Widget.__assert(
           currentParent && currentParent.__widget === this._parentWidget,
           'Attempt to show under node belonging to alien widget');
 
     var wasVisible = this._visible;
     if (wasVisible && this.element.parentElement === parentElement)
       return;
 
     this._visible = true;
 
     if (!wasVisible && this._parentIsShowing())
       this._processWillShow();
 
     this.element.classList.remove('hidden');
 
     // Reparent
     if (this.element.parentElement !== parentElement) {
-      WebInspector.Widget._incrementWidgetCounter(parentElement, this.element);
+      UI.Widget._incrementWidgetCounter(parentElement, this.element);
       if (insertBefore)
-        WebInspector.Widget._originalInsertBefore.call(parentElement, this.element, insertBefore);
+        UI.Widget._originalInsertBefore.call(parentElement, this.element, insertBefore);
       else
-        WebInspector.Widget._originalAppendChild.call(parentElement, this.element);
+        UI.Widget._originalAppendChild.call(parentElement, this.element);
     }
 
     if (!wasVisible && this._parentIsShowing())
       this._processWasShown();
 
     if (this._parentWidget && this._hasNonZeroConstraints())
       this._parentWidget.invalidateConstraints();
     else
       this._processOnResize();
   }
@@ skipping 13 matching lines @@
     this._visible = false;
     var parentElement = this.element.parentElement;
 
     if (this._parentIsShowing())
       this._processWillHide();
 
     if (!overrideHideOnDetach && this.shouldHideOnDetach()) {
       this.element.classList.add('hidden');
     } else {
       // Force legal removal
-      WebInspector.Widget._decrementWidgetCounter(parentElement, this.element);
-      WebInspector.Widget._originalRemoveChild.call(parentElement, this.element);
+      UI.Widget._decrementWidgetCounter(parentElement, this.element);
+      UI.Widget._originalRemoveChild.call(parentElement, this.element);
     }
 
     if (this._parentIsShowing())
       this._processWasHidden();
     if (this._parentWidget && this._hasNonZeroConstraints())
       this._parentWidget.invalidateConstraints();
   }
 
   detach() {
     if (!this._parentWidget && !this._isRoot)
       return;
 
     if (this._visible)
       this._hideWidget(true);
 
     // Update widget hierarchy.
     if (this._parentWidget) {
       var childIndex = this._parentWidget._children.indexOf(this);
-      WebInspector.Widget.__assert(childIndex >= 0, 'Attempt to remove non-child widget');
+      UI.Widget.__assert(childIndex >= 0, 'Attempt to remove non-child widget');
       this._parentWidget._children.splice(childIndex, 1);
       if (this._parentWidget._defaultFocusedChild === this)
         this._parentWidget._defaultFocusedChild = null;
       this._parentWidget.childWasDetached(this);
       var parent = this._parentWidget;
       this._parentWidget = null;
       this._processWasDetachedFromHierarchy();
     } else {
-      WebInspector.Widget.__assert(this._isRoot, 'Removing non-root widget from DOM');
+      UI.Widget.__assert(this._isRoot, 'Removing non-root widget from DOM');
     }
   }
 
   detachChildWidgets() {
     var children = this._children.slice();
     for (var i = 0; i < children.length; ++i)
       children[i].detach();
   }
 
   /**
@@ skipping 35 matching lines @@
     if (!this.isShowing())
       return;
     this._notify(this.onLayout);
     this.doResize();
   }
 
   /**
    * @param {string} cssFile
    */
   registerRequiredCSS(cssFile) {
-    WebInspector.appendStyle(this._isWebComponent ? this._shadowRoot : this.element, cssFile);
+    UI.appendStyle(this._isWebComponent ? this._shadowRoot : this.element, cssFile);
   }
 
   printWidgetHierarchy() {
     var lines = [];
     this._collectWidgetHierarchy('', lines);
     console.log(lines.join('\n'));
   }
 
   _collectWidgetHierarchy(prefix, lines) {
     lines.push(prefix + '[' + this.element.className + ']' + (this._children.length ? ' {' : ''));
 
     for (var i = 0; i < this._children.length; ++i)
       this._children[i]._collectWidgetHierarchy(prefix + '    ', lines);
 
     if (this._children.length)
       lines.push(prefix + '}');
   }
 
   /**
    * @param {?Element} element
    */
   setDefaultFocusedElement(element) {
     this._defaultFocusedElement = element;
   }
 
   /**
-   * @param {!WebInspector.Widget} child
+   * @param {!UI.Widget} child
    */
   setDefaultFocusedChild(child) {
-    WebInspector.Widget.__assert(child._parentWidget === this, 'Attempt to set non-child widget as default focused.');
+    UI.Widget.__assert(child._parentWidget === this, 'Attempt to set non-child widget as default focused.');
     this._defaultFocusedChild = child;
   }
 
   focus() {
     if (!this.isShowing())
       return;
 
     var element = this._defaultFocusedElement;
     if (element) {
       if (!element.hasFocus())
@@ skipping 21 matching lines @@
   }
 
   /**
    * @return {!Size}
    */
   measurePreferredSize() {
     var document = this.element.ownerDocument;
     var oldParent = this.element.parentElement;
     var oldNextSibling = this.element.nextSibling;
 
-    WebInspector.Widget._originalAppendChild.call(document.body, this.element);
+    UI.Widget._originalAppendChild.call(document.body, this.element);
     this.element.positionAt(0, 0);
     var result = new Size(this.element.offsetWidth, this.element.offsetHeight);
 
     this.element.positionAt(undefined, undefined);
     if (oldParent)
-      WebInspector.Widget._originalInsertBefore.call(oldParent, this.element, oldNextSibling);
+      UI.Widget._originalInsertBefore.call(oldParent, this.element, oldNextSibling);
     else
-      WebInspector.Widget._originalRemoveChild.call(document.body, this.element);
+      UI.Widget._originalRemoveChild.call(document.body, this.element);
     return result;
   }
 
   /**
    * @return {!Constraints}
    */
   calculateConstraints() {
     return new Constraints();
   }
 
@@ skipping 62 matching lines @@
     else
       this.doLayout();
   }
 
   invalidateSize() {
     if (this._parentWidget)
       this._parentWidget.doLayout();
   }
 };
 
-WebInspector.Widget._originalAppendChild = Element.prototype.appendChild;
-WebInspector.Widget._originalInsertBefore = Element.prototype.insertBefore;
-WebInspector.Widget._originalRemoveChild = Element.prototype.removeChild;
-WebInspector.Widget._originalRemoveChildren = Element.prototype.removeChildren;
+UI.Widget._originalAppendChild = Element.prototype.appendChild;
+UI.Widget._originalInsertBefore = Element.prototype.insertBefore;
+UI.Widget._originalRemoveChild = Element.prototype.removeChild;
+UI.Widget._originalRemoveChildren = Element.prototype.removeChildren;
 
 
 /**
  * @unrestricted
  */
-WebInspector.VBox = class extends WebInspector.Widget {
+UI.VBox = class extends UI.Widget {
   /**
    * @param {boolean=} isWebComponent
    */
   constructor(isWebComponent) {
     super(isWebComponent);
     this.contentElement.classList.add('vbox');
   }
 
   /**
    * @override
    * @return {!Constraints}
    */
   calculateConstraints() {
     var constraints = new Constraints();
 
     /**
-     * @this {!WebInspector.Widget}
+     * @this {!UI.Widget}
      * @suppressReceiverCheck
      */
     function updateForChild() {
       var child = this.constraints();
       constraints = constraints.widthToMax(child);
       constraints = constraints.addHeight(child);
     }
 
     this._callOnVisibleChildren(updateForChild);
     return constraints;
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.HBox = class extends WebInspector.Widget {
+UI.HBox = class extends UI.Widget {
   /**
    * @param {boolean=} isWebComponent
    */
   constructor(isWebComponent) {
     super(isWebComponent);
     this.contentElement.classList.add('hbox');
   }
 
   /**
    * @override
    * @return {!Constraints}
    */
   calculateConstraints() {
     var constraints = new Constraints();
 
     /**
-     * @this {!WebInspector.Widget}
+     * @this {!UI.Widget}
      * @suppressReceiverCheck
      */
     function updateForChild() {
       var child = this.constraints();
       constraints = constraints.addWidth(child);
       constraints = constraints.heightToMax(child);
     }
 
     this._callOnVisibleChildren(updateForChild);
     return constraints;
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.VBoxWithResizeCallback = class extends WebInspector.VBox {
+UI.VBoxWithResizeCallback = class extends UI.VBox {
   /**
    * @param {function()} resizeCallback
    */
   constructor(resizeCallback) {
     super();
     this._resizeCallback = resizeCallback;
   }
 
   /**
    * @override
    */
   onResize() {
     this._resizeCallback();
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.WidgetFocusRestorer = class {
+UI.WidgetFocusRestorer = class {
   /**
-   * @param {!WebInspector.Widget} widget
+   * @param {!UI.Widget} widget
    */
   constructor(widget) {
     this._widget = widget;
     this._previous = widget.element.ownerDocument.deepActiveElement();
     widget.focus();
   }
 
   restore() {
     if (!this._widget)
       return;
     if (this._widget.hasFocus() && this._previous)
       this._previous.focus();
     this._previous = null;
     this._widget = null;
   }
 };
 
 /**
  * @override
  * @param {?Node} child
  * @return {?Node}
  * @suppress {duplicate}
  */
 Element.prototype.appendChild = function(child) {
-  WebInspector.Widget.__assert(
+  UI.Widget.__assert(
       !child.__widget || child.parentElement === this, 'Attempt to add widget via regular DOM operation.');
-  return WebInspector.Widget._originalAppendChild.call(this, child);
+  return UI.Widget._originalAppendChild.call(this, child);
 };
 
 /**
  * @override
  * @param {?Node} child
  * @param {?Node} anchor
  * @return {!Node}
  * @suppress {duplicate}
  */
 Element.prototype.insertBefore = function(child, anchor) {
-  WebInspector.Widget.__assert(
+  UI.Widget.__assert(
       !child.__widget || child.parentElement === this, 'Attempt to add widget via regular DOM operation.');
-  return WebInspector.Widget._originalInsertBefore.call(this, child, anchor);
+  return UI.Widget._originalInsertBefore.call(this, child, anchor);
 };
 
 /**
  * @override
  * @param {?Node} child
  * @return {!Node}
  * @suppress {duplicate}
  */
 Element.prototype.removeChild = function(child) {
-  WebInspector.Widget.__assert(
+  UI.Widget.__assert(
       !child.__widgetCounter && !child.__widget,
       'Attempt to remove element containing widget via regular DOM operation');
-  return WebInspector.Widget._originalRemoveChild.call(this, child);
+  return UI.Widget._originalRemoveChild.call(this, child);
 };
 
 Element.prototype.removeChildren = function() {
-  WebInspector.Widget.__assert(
+  UI.Widget.__assert(
       !this.__widgetCounter, 'Attempt to remove element containing widget via regular DOM operation');
-  WebInspector.Widget._originalRemoveChildren.call(this);
+  UI.Widget._originalRemoveChildren.call(this);
 };