[DevTools] Add minimum size to WebInspector.View.

Source/devtools/front_end/View.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
@@ skipping 211 matching lines @@
     },
 
     willHide: function()
     {
     },
 
     onResize: function()
     {
     },
 
+    onLayout: function()
+    {
+    },
+
     /**
      * @param {?Element} parentElement
      * @param {!Element=} insertBefore
      */
     show: function(parentElement, insertBefore)
     {
         WebInspector.View._assert(parentElement, "Attempt to attach view with no parent element");
 
         // Update view hierarchy
         if (this.element.parentElement !== parentElement) {
@@ skipping 27 matching lines @@
             if (insertBefore)
                 WebInspector.View._originalInsertBefore.call(parentElement, this.element, insertBefore);
             else
                 WebInspector.View._originalAppendChild.call(parentElement, this.element);
         }
 
         if (this._parentIsShowing()) {
             this._processWasShown();
             this._cacheSize();
         }
+
+        if (this._parentView && this._hasNonZeroMinimumSize())
+            this._parentView.invalidateMinimumSize();
     },
 
     /**
      * @param {boolean=} overrideHideOnDetach
      */
     detach: function(overrideHideOnDetach)
     {
         var parentElement = this.element.parentElement;
         if (!parentElement)
             return;
 
         if (this._parentIsShowing()) {
             this._processDiscardCachedSize();
             this._processWillHide();
         }
 
         if (this._hideOnDetach && !overrideHideOnDetach) {
             this.element.classList.remove("visible");
             this._visible = false;
             if (this._parentIsShowing())
                 this._processWasHidden();
+            if (this._parentView && this._hasNonZeroMinimumSize())
+                this._parentView.invalidateMinimumSize();
             return;
         }
 
         // Force legal removal
         WebInspector.View._decrementViewCounter(parentElement, this.element);
         WebInspector.View._originalRemoveChild.call(parentElement, this.element);
 
         this._visible = false;
         if (this._parentIsShowing())
             this._processWasHidden();
 
         // Update view hierarchy
         if (this._parentView) {
             var childIndex = this._parentView._children.indexOf(this);
             WebInspector.View._assert(childIndex >= 0, "Attempt to remove non-child view");
             this._parentView._children.splice(childIndex, 1);
+            var parent = this._parentView;
             this._parentView = null;
+            if (this._hasNonZeroMinimumSize())
+                parent.invalidateMinimumSize();
         } else
             WebInspector.View._assert(this._isRoot, "Removing non-root view from DOM");
     },
 
     detachChildViews: function()
     {
         var children = this._children.slice();
         for (var i = 0; i < children.length; ++i)
             children[i].detach();
     },
@@ skipping 32 matching lines @@
     {
         if (!this.isShowing())
             return;
         this._processDiscardCachedSize();
         // No matter what notification we are in, dispatching onResize is not needed.
         if (!this._inNotification())
             this._callOnVisibleChildren(this._processOnResize);
         this._cacheSize();
     },
 
+    doLayout: function()
+    {
+        if (!this.isShowing())
+            return;
+        this._notify(this.onLayout);
+        this.doResize();
+    },
+
     registerRequiredCSS: function(cssFile)
     {
         if (window.flattenImports)
             cssFile = cssFile.split("/").reverse()[0];
         this._cssFiles.push(cssFile);
     },
 
     _loadCSSIfNeeded: function()
     {
         for (var i = 0; i < this._cssFiles.length; ++i) {
@@ skipping 98 matching lines @@
         this._loadCSSIfNeeded();
         WebInspector.View._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);
         WebInspector.View._originalRemoveChild.call(document.body, this.element);
         this._disableCSSIfNeeded();
         return result;
     },
 
+    /**
+     * @return {!Size}
+     */
+    calculateMinimumSize: function()
+    {
+        return new Size(0, 0);
+    },
+
+    /**
+     * @return {!Size}
+     */
+    minimumSize: function()
+    {
+        if (typeof this._minimumSize !== "undefined")
+            return this._minimumSize;
+        if (typeof this._cachedMinimumSize === "undefined")
+            this._cachedMinimumSize = this.calculateMinimumSize();
+        return this._cachedMinimumSize;
+    },
+
+    /**
+     * @param {number} width
+     * @param {number} height
+     */
+    setMinimumSize: function(width, height)
+    {
+        this._minimumSize = new Size(width, height);
+        this.invalidateMinimumSize();
+    },
+
+    /**
+     * @return {boolean}
+     */
+    _hasNonZeroMinimumSize: function()
+    {
+        var size = this.minimumSize();
+        return size.width || size.height;
+    },
+
+    invalidateMinimumSize: function()
+    {
+        var cached = this._cachedMinimumSize;
+        delete this._cachedMinimumSize;
+        var actual = this.minimumSize();
+        if (!actual.isEqual(cached) && this._parentView)
+            this._parentView.invalidateMinimumSize();
+        else
+            this.doLayout();
+    },
+
     __proto__: WebInspector.Object.prototype
 }
 
 WebInspector.View._originalAppendChild = Element.prototype.appendChild;
 WebInspector.View._originalInsertBefore = Element.prototype.insertBefore;
 WebInspector.View._originalRemoveChild = Element.prototype.removeChild;
 WebInspector.View._originalRemoveChildren = Element.prototype.removeChildren;
 
 WebInspector.View._incrementViewCounter = function(parentElement, childElement)
 {
@@ skipping 31 matching lines @@
  * @constructor
  * @extends {WebInspector.View}
  */
 WebInspector.VBox = function()
 {
     WebInspector.View.call(this);
     this.element.classList.add("vbox");
 };
 
 WebInspector.VBox.prototype = {
+    /**
+     * @return {!Size}
+     */
+    calculateMinimumSize: function()
+    {
+        var width = 0;
+        var height = 0;
+
+        /**
+         * @this {!WebInspector.View}
+         * @suppressReceiverCheck
+         */
+        function updateForChild()
+        {
+            var size = this.minimumSize();
+            width = Math.max(width, size.width);
+            height += size.height;
+        }
+
+        this._callOnVisibleChildren(updateForChild);
+        return new Size(width, height);
+    },
+
     __proto__: WebInspector.View.prototype
 };
 
 /**
  * @constructor
  * @extends {WebInspector.View}
  */
 WebInspector.HBox = function()
 {
     WebInspector.View.call(this);
     this.element.classList.add("hbox");
 };
 
 WebInspector.HBox.prototype = {
+    /**
+     * @return {!Size}
+     */
+    calculateMinimumSize: function()
+    {
+        var width = 0;
+        var height = 0;
+
+        /**
+         * @this {!WebInspector.View}
+         * @suppressReceiverCheck
+         */
+        function updateForChild()
+        {
+            var size = this.minimumSize();
+            width += size.width;
+            height = Math.max(height, size.height);
+        }
+
+        this._callOnVisibleChildren(updateForChild);
+        return new Size(width, height);
+    },
+
     __proto__: WebInspector.View.prototype
 };
 
 /**
  * @constructor
  * @extends {WebInspector.VBox}
  * @param {function()} resizeCallback
  */
 WebInspector.VBoxWithResizeCallback = function(resizeCallback)
 {
@@ skipping 27 matching lines @@
 {
     WebInspector.View._assert(!child.__viewCounter && !child.__view, "Attempt to remove element containing view via regular DOM operation");
     return WebInspector.View._originalRemoveChild.call(this, child);
 }
 
 Element.prototype.removeChildren = function()
 {
     WebInspector.View._assert(!this.__viewCounter, "Attempt to remove element containing view via regular DOM operation");
     WebInspector.View._originalRemoveChildren.call(this);
 }