DevTools: polish the MQ ruler, move zoom controls to the top.

Source/devtools/front_end/toolbox/ResponsiveDesignView.js

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /**
  * @constructor
  * @extends {WebInspector.VBox}
  * @implements {WebInspector.OverridesSupport.PageResizer}
  * @implements {WebInspector.TargetManager.Observer}
  * @param {!WebInspector.InspectedPagePlaceholder} inspectedPagePlaceholder
  */
 WebInspector.ResponsiveDesignView = function(inspectedPagePlaceholder)
 {
     WebInspector.VBox.call(this);
     this.setMinimumSize(150, 150);
     this.element.classList.add("overflow-hidden");
 
     this._responsiveDesignContainer = new WebInspector.VBox();
     this._responsiveDesignContainer.registerRequiredCSS("responsiveDesignView.css");
 
     this._createToolbar();
 
     this._canvasContainer = new WebInspector.View();
     this._canvasContainer.element.classList.add("responsive-design");
     this._canvasContainer.show(this._responsiveDesignContainer.element);
 
+    this._canvas = this._canvasContainer.element.createChild("canvas", "fill responsive-design-canvas");
+
     this._mediaInspectorContainer = this._canvasContainer.element.createChild("div", "responsive-design-media-container");
     this._mediaInspector = new WebInspector.MediaQueryInspector();
     this._updateMediaQueryInspector();
 
-    this._canvas = this._canvasContainer.element.createChild("canvas", "fill responsive-design-canvas");
-
     this._warningMessage = this._canvasContainer.element.createChild("div", "responsive-design-warning hidden");
     this._warningMessage.createChild("div", "warning-icon-small");
     this._warningMessage.createChild("span");
     var warningDisableButton = this._warningMessage.createChild("div", "disable-warning");
     warningDisableButton.textContent = WebInspector.UIString("Never show");
     warningDisableButton.addEventListener("click", this._disableOverridesWarnings.bind(this), false);
     var warningCloseButton = this._warningMessage.createChild("div", "close-button");
     warningCloseButton.addEventListener("click", WebInspector.overridesSupport.clearWarningMessage.bind(WebInspector.overridesSupport), false);
     WebInspector.overridesSupport.addEventListener(WebInspector.OverridesSupport.Events.OverridesWarningUpdated, this._overridesWarningUpdated, this);
     WebInspector.settings.disableOverridesWarning.addChangeListener(this._overridesWarningUpdated, this);
 
     this._slidersContainer = this._canvasContainer.element.createChild("div", "vbox responsive-design-sliders-container");
     var genericDeviceOutline = this._slidersContainer.createChild("div", "responsive-design-generic-outline-container");
     genericDeviceOutline.createChild("div", "responsive-design-generic-outline");
     var widthSlider = this._slidersContainer.createChild("div", "responsive-design-slider-width");
     widthSlider.createChild("div", "responsive-design-thumb-handle");
     this._createResizer(widthSlider, false);
     var heightSlider = this._slidersContainer.createChild("div", "responsive-design-slider-height");
     heightSlider.createChild("div", "responsive-design-thumb-handle");
     this._createResizer(heightSlider, true);
     this._pageContainer = this._slidersContainer.createChild("div", "vbox flex-auto");
 
     // Page scale controls.
-    this._pageScaleContainer = this._canvasContainer.element.createChild("div", "vbox responsive-design-page-scale-container");
-    this._pageScaleContainer.style.width = WebInspector.ResponsiveDesignView.PageScaleContainerWidth + "px";
-    this._pageScaleContainer.style.height = WebInspector.ResponsiveDesignView.PageScaleContainerHeight + "px";
-    this._increasePageScaleButton = new WebInspector.StatusBarButton(WebInspector.UIString(""), "responsive-design-page-scale-button responsive-design-page-scale-increase");
-    this._increasePageScaleButton.element.tabIndex = -1;
-    this._increasePageScaleButton.addEventListener("click", this._pageScaleButtonClicked.bind(this, true), this);
-    this._pageScaleContainer.appendChild(this._increasePageScaleButton.element);
-    this._pageScaleLabel = this._pageScaleContainer.createChild("label", "responsive-design-page-scale-label");
-    this._pageScaleLabel.title = WebInspector.UIString("For a simpler way to change the current page scale, hold down Shift and drag with your mouse.");
+    this._pageScaleContainer = this._canvasContainer.element.createChild("div", "hbox responsive-design-page-scale-container");
     this._decreasePageScaleButton = new WebInspector.StatusBarButton(WebInspector.UIString(""), "responsive-design-page-scale-button responsive-design-page-scale-decrease");
     this._decreasePageScaleButton.element.tabIndex = -1;
     this._decreasePageScaleButton.addEventListener("click", this._pageScaleButtonClicked.bind(this, false), this);
     this._pageScaleContainer.appendChild(this._decreasePageScaleButton.element);
 
+    this._pageScaleLabel = this._pageScaleContainer.createChild("label", "responsive-design-page-scale-label");
+    this._pageScaleLabel.title = WebInspector.UIString("For a simpler way to change the current page scale, hold down Shift and drag with your mouse.");
+
+    this._increasePageScaleButton = new WebInspector.StatusBarButton(WebInspector.UIString(""), "responsive-design-page-scale-button responsive-design-page-scale-increase");
+    this._increasePageScaleButton.element.tabIndex = -1;
+    this._increasePageScaleButton.addEventListener("click", this._pageScaleButtonClicked.bind(this, true), this);
+    this._pageScaleContainer.appendChild(this._increasePageScaleButton.element);
+
     this._inspectedPagePlaceholder = inspectedPagePlaceholder;
     inspectedPagePlaceholder.show(this.element);
 
     this._enabled = false;
     this._viewport = { scrollX: 0, scrollY: 0, contentsWidth: 0, contentsHeight: 0, pageScaleFactor: 1, minimumPageScaleFactor: 1, maximumPageScaleFactor: 1 };
     this._drawContentsSize = true;
     this._viewportChangedThrottler = new WebInspector.Throttler(0);
     this._pageScaleFactorThrottler = new WebInspector.Throttler(50);
 
     WebInspector.zoomManager.addEventListener(WebInspector.ZoomManager.Events.ZoomChanged, this._onZoomChanged, this);
     WebInspector.overridesSupport.addEventListener(WebInspector.OverridesSupport.Events.EmulationStateChanged, this._emulationEnabledChanged, this);
     this._mediaInspector.addEventListener(WebInspector.MediaQueryInspector.Events.CountUpdated, this._updateMediaQueryInspectorButton, this);
     this._mediaInspector.addEventListener(WebInspector.MediaQueryInspector.Events.HeightUpdated, this.onResize, this);
     WebInspector.targetManager.observeTargets(this);
 
     this._emulationEnabledChanged();
     this._overridesWarningUpdated();
 };
 
 // Measured in DIP.
 WebInspector.ResponsiveDesignView.RulerWidth = 34;
 WebInspector.ResponsiveDesignView.RulerHeight = 22;
+WebInspector.ResponsiveDesignView.RulerTopHeight = 11;
 WebInspector.ResponsiveDesignView.RulerBottomHeight = 9;
-WebInspector.ResponsiveDesignView.PageScaleContainerWidth = 40;
-WebInspector.ResponsiveDesignView.PageScaleContainerHeight = 80;
 
 WebInspector.ResponsiveDesignView.prototype = {
 
     /**
      * @param {!WebInspector.Target} target
      */
     targetAdded: function(target)
     {
         // FIXME: adapt this to multiple targets.
         if (this._target)
@@ skipping 72 matching lines @@
     },
 
     /**
      * @return {!Size}
      */
     _availableDipSize: function()
     {
         if (typeof this._availableSize === "undefined") {
             var zoomFactor = WebInspector.zoomManager.zoomFactor();
             var rect = this._canvasContainer.element.getBoundingClientRect();
-            var mediaInspectorHeight = this._mediaInspector.element.offsetHeight;
-            if (mediaInspectorHeight)
-                mediaInspectorHeight += WebInspector.ResponsiveDesignView.RulerBottomHeight;
+            var rulerTotalHeight = this._rulerTotalHeightDIP();
             this._availableSize = new Size(Math.max(rect.width * zoomFactor - WebInspector.ResponsiveDesignView.RulerWidth, 1),
-                                           Math.max(rect.height * zoomFactor - mediaInspectorHeight - WebInspector.ResponsiveDesignView.RulerHeight, 1));
+                                           Math.max(rect.height * zoomFactor - rulerTotalHeight, 1));
         }
         return this._availableSize;
     },
 
     /**
      * @param {!Element} element
      * @param {boolean} vertical
      * @return {!WebInspector.ResizerWidget}
      */
     _createResizer: function(element, vertical)
@@ skipping 49 matching lines @@
         this.dispatchEventToListeners(WebInspector.OverridesSupport.PageResizer.Events.FixedScaleRequested, false);
         delete this._resizeStartSize;
         this._updateUI();
     },
 
     /**
      * Draws canvas of the specified css size in DevTools page space.
      * Canvas contains grid and rulers.
      * @param {number} cssCanvasWidth
      * @param {number} cssCanvasHeight
-     * @param {number} mediaInspectorHeight
+     * @param {number} rulerHeight
      */
-    _drawCanvas: function(cssCanvasWidth, cssCanvasHeight, mediaInspectorHeight)
+    _drawCanvas: function(cssCanvasWidth, cssCanvasHeight, rulerHeight)
     {
         if (!this._enabled)
             return;
 
         var canvas = this._canvas;
         var context = canvas.getContext("2d");
         canvas.style.width = cssCanvasWidth + "px";
         canvas.style.height = cssCanvasHeight + "px";
 
         var zoomFactor = WebInspector.zoomManager.zoomFactor();
         var dipCanvasWidth = cssCanvasWidth * zoomFactor;
         var dipCanvasHeight = cssCanvasHeight * zoomFactor;
-        var dipMediaInspectorHeight = mediaInspectorHeight * zoomFactor;
 
         var deviceScaleFactor = window.devicePixelRatio;
         canvas.width = deviceScaleFactor * cssCanvasWidth;
         canvas.height = deviceScaleFactor * cssCanvasHeight;
         context.scale(canvas.width / dipCanvasWidth, canvas.height / dipCanvasHeight);
         context.font = "11px " + WebInspector.fontFamily();
 
         const backgroundColor = "rgb(102, 102, 102)";
         const lightLineColor = "rgb(132, 132, 132)";
         const darkLineColor = "rgb(114, 114, 114)";
         const rulerColor = "rgb(125, 125, 125)";
-        const rulerOverlayColor = "rgba(255, 255, 255, 0.2)";
         const textColor = "rgb(186, 186, 186)";
         const contentsSizeColor = "rgba(0, 0, 0, 0.3)";
 
         var scale = (this._scale || 1) * this._viewport.pageScaleFactor;
         var rulerScale = 0.5;
         while (Math.abs(rulerScale * scale - 1) > Math.abs((rulerScale + 0.5) * scale - 1))
             rulerScale += 0.5;
 
         var gridStep = 50 * scale * rulerScale;
         var gridSubStep = 10 * scale * rulerScale;
 
         var rulerSubStep = 5 * scale * rulerScale;
         var rulerStepCount = 20;
 
         var rulerWidth = WebInspector.ResponsiveDesignView.RulerWidth;
-        var rulerHeight = WebInspector.ResponsiveDesignView.RulerHeight;
-        if (dipMediaInspectorHeight)
-            rulerHeight += WebInspector.ResponsiveDesignView.RulerBottomHeight + dipMediaInspectorHeight;
+
         var dipGridWidth = dipCanvasWidth - rulerWidth;
         var dipGridHeight = dipCanvasHeight - rulerHeight;
         var dipScrollX = this._viewport.scrollX * scale;
         var dipScrollY = this._viewport.scrollY * scale;
         context.translate(rulerWidth, rulerHeight);
 
         context.fillStyle = backgroundColor;
         context.fillRect(0, 0, dipGridWidth, dipGridHeight);
 
         context.translate(0.5, 0.5);
         context.strokeStyle = rulerColor;
         context.fillStyle = textColor;
         context.lineWidth = 1;
 
         // Draw horizontal ruler.
         context.save();
-        context.beginPath();
-        context.moveTo(0, -rulerHeight + WebInspector.ResponsiveDesignView.RulerHeight);
-        context.lineTo(dipGridWidth, -rulerHeight + WebInspector.ResponsiveDesignView.RulerHeight);
-        context.stroke();
 
         var minXIndex = Math.ceil(dipScrollX / rulerSubStep);
         var maxXIndex = Math.floor((dipScrollX + dipGridWidth) / rulerSubStep);
         if (minXIndex) {
             context.beginPath();
             context.moveTo(0, -rulerHeight);
             context.lineTo(0, 0);
             context.stroke();
         }
 
         context.translate(-dipScrollX, 0);
         for (var index = minXIndex; index <= maxXIndex; index++) {
             var x = index * rulerSubStep;
-            var y = -WebInspector.ResponsiveDesignView.RulerHeight * 0.25;
-            var copyHeight = WebInspector.ResponsiveDesignView.RulerHeight * 0.25;
+            var height = WebInspector.ResponsiveDesignView.RulerHeight * 0.25;
 
             if (!(index % (rulerStepCount / 4)))
-                copyHeight = WebInspector.ResponsiveDesignView.RulerHeight * 0.5;
-            if (!(index % (rulerStepCount / 2))) {
-                context.strokeStyle = rulerOverlayColor;
-                y = -rulerHeight + WebInspector.ResponsiveDesignView.RulerHeight * 0.25;
-                copyHeight = 0;
-            }
+                height = WebInspector.ResponsiveDesignView.RulerHeight * 0.5;
+
+            if (!(index % (rulerStepCount / 2)))
+                height = rulerHeight;
+
             if (!(index % rulerStepCount)) {
                 context.save();
                 context.translate(x, 0);
                 context.fillText(Math.round(x / scale), 2, -rulerHeight + 10);
                 context.restore();
-                y = -rulerHeight;
+                height = rulerHeight;
             }
 
             context.beginPath();
-            context.moveTo(x, y);
+            context.moveTo(x, - height);
             context.lineTo(x, 0);
             context.stroke();
-            if (copyHeight) {
-                context.beginPath();
-                context.moveTo(x, -rulerHeight + WebInspector.ResponsiveDesignView.RulerHeight - copyHeight);
-                context.lineTo(x, -rulerHeight + WebInspector.ResponsiveDesignView.RulerHeight);
-                context.stroke();
-            }
-
-            if (!(index % (rulerStepCount / 2)))
-                context.strokeStyle = rulerColor;
         }
         context.restore();
 
         // Draw vertical ruler.
         context.save();
         var minYIndex = Math.ceil(dipScrollY / rulerSubStep);
         var maxYIndex = Math.floor((dipScrollY + dipGridHeight) / rulerSubStep);
         context.translate(0, -dipScrollY);
         for (var index = minYIndex; index <= maxYIndex; index++) {
             var y = index * rulerSubStep;
@@ skipping 63 matching lines @@
         // Draw contents size.
         var pageScaleAvailable = WebInspector.overridesSupport.settings.emulateMobile.get() || WebInspector.overridesSupport.settings.emulateTouch.get();
         if (this._drawContentsSize && pageScaleAvailable) {
             context.fillStyle = contentsSizeColor;
             var visibleContentsWidth = Math.max(0, Math.min(dipGridWidth, this._viewport.contentsWidth * scale - dipScrollX));
             var visibleContentsHeight = Math.max(0, Math.min(dipGridHeight, this._viewport.contentsHeight * scale - dipScrollY));
             context.fillRect(0, 0, visibleContentsWidth, visibleContentsHeight);
         }
     },
 
+    /**
+     * @return {number}
+     */
+    _rulerTotalHeightDIP: function()
+    {
+        var mediaInspectorHeight = this._mediaInspector.isShowing() ? this._mediaInspector.element.offsetHeight : 0;
+        if (!mediaInspectorHeight)
+            return WebInspector.ResponsiveDesignView.RulerHeight;
+        return WebInspector.ResponsiveDesignView.RulerTopHeight + WebInspector.ResponsiveDesignView.RulerBottomHeight + mediaInspectorHeight * WebInspector.zoomManager.zoomFactor();
+    },
+
     _updateUI: function()
     {
         if (!this._enabled || !this.isShowing())
             return;
 
         var zoomFactor = WebInspector.zoomManager.zoomFactor();
         var rect = this._canvas.parentElement.getBoundingClientRect();
         var availableDip = this._availableDipSize();
         var cssCanvasWidth = rect.width;
         var cssCanvasHeight = rect.height;
         var mediaInspectorHeight = this._mediaInspector.isShowing() ? this._mediaInspector.element.offsetHeight : 0;
-        var rulerTotalHeight = WebInspector.ResponsiveDesignView.RulerHeight + (mediaInspectorHeight ? WebInspector.ResponsiveDesignView.RulerBottomHeight : 0);
+        var rulerTotalHeight = this._rulerTotalHeightDIP();
 
         this._mediaInspector.setAxisTransform(this._viewport.scrollX, this._scale * this._viewport.pageScaleFactor);
 
         if (this._cachedZoomFactor !== zoomFactor || this._cachedMediaInspectorHeight !== mediaInspectorHeight) {
             var cssRulerWidth = WebInspector.ResponsiveDesignView.RulerWidth / zoomFactor + "px";
-            var cssRulerHeight = WebInspector.ResponsiveDesignView.RulerHeight / zoomFactor + "px";
-            var cssCanvasOffset = rulerTotalHeight / zoomFactor + mediaInspectorHeight + "px";
+            var cssRulerHeight = (mediaInspectorHeight ? WebInspector.ResponsiveDesignView.RulerTopHeight : WebInspector.ResponsiveDesignView.RulerHeight) / zoomFactor + "px";
+            var cssCanvasOffset = rulerTotalHeight / zoomFactor + "px";
             this._slidersContainer.style.left = cssRulerWidth;
             this._slidersContainer.style.top = cssCanvasOffset;
-            this._warningMessage.style.height = cssRulerHeight;
+            this._warningMessage.style.height = cssCanvasOffset;
+            this._pageScaleContainer.style.top = cssCanvasOffset;
             this._mediaInspectorContainer.style.left = cssRulerWidth;
             this._mediaInspectorContainer.style.marginTop = cssRulerHeight;
         }
 
         var cssWidth = (this._dipWidth ? this._dipWidth : availableDip.width) / zoomFactor;
         var cssHeight = (this._dipHeight ? this._dipHeight : availableDip.height) / zoomFactor;
         if (this._cachedCssWidth !== cssWidth || this._cachedCssHeight !== cssHeight) {
             this._slidersContainer.style.width = cssWidth + "px";
             this._slidersContainer.style.height = cssHeight + "px";
             this._inspectedPagePlaceholder.onResize();
         }
 
-        var pageScaleVisible = cssWidth + WebInspector.ResponsiveDesignView.PageScaleContainerWidth + WebInspector.ResponsiveDesignView.RulerWidth / zoomFactor <= rect.width ||
-            cssHeight + WebInspector.ResponsiveDesignView.PageScaleContainerHeight + mediaInspectorHeight + rulerTotalHeight / zoomFactor  <= rect.height;
+        var pageScaleVisible = cssWidth + this._pageScaleContainerWidth + WebInspector.ResponsiveDesignView.RulerWidth / zoomFactor <= rect.width;
         this._pageScaleContainer.classList.toggle("hidden", !pageScaleVisible);
 
         var viewportChanged = !this._cachedViewport
             || this._cachedViewport.scrollX !== this._viewport.scrollX || this._cachedViewport.scrollY !== this._viewport.scrollY
             || this._cachedViewport.contentsWidth !== this._viewport.contentsWidth || this._cachedViewport.contentsHeight !== this._viewport.contentsHeight
             || this._cachedViewport.pageScaleFactor !== this._viewport.pageScaleFactor
             || this._cachedViewport.minimumPageScaleFactor !== this._viewport.minimumPageScaleFactor
             || this._cachedViewport.maximumPageScaleFactor !== this._viewport.maximumPageScaleFactor;
 
         var canvasInvalidated = viewportChanged || this._drawContentsSize !== this._cachedDrawContentsSize || this._cachedScale !== this._scale ||
             this._cachedCssCanvasWidth !== cssCanvasWidth || this._cachedCssCanvasHeight !== cssCanvasHeight || this._cachedZoomFactor !== zoomFactor ||
             this._cachedMediaInspectorHeight !== mediaInspectorHeight;
 
         if (canvasInvalidated)
-            this._drawCanvas(cssCanvasWidth, cssCanvasHeight, mediaInspectorHeight);
+            this._drawCanvas(cssCanvasWidth, cssCanvasHeight, rulerTotalHeight);
 
         if (viewportChanged) {
             this._pageScaleLabel.textContent = WebInspector.UIString("%.1f", this._viewport.pageScaleFactor);
             this._decreasePageScaleButton.title = WebInspector.UIString("Scale down (minimum %.1f)", this._viewport.minimumPageScaleFactor);
             this._decreasePageScaleButton.setEnabled(this._viewport.pageScaleFactor > this._viewport.minimumPageScaleFactor);
             this._increasePageScaleButton.title = WebInspector.UIString("Scale up (maximum %.1f)", this._viewport.maximumPageScaleFactor);
             this._increasePageScaleButton.setEnabled(this._viewport.pageScaleFactor < this._viewport.maximumPageScaleFactor);
         }
 
         this._cachedScale = this._scale;
         this._cachedCssCanvasWidth = cssCanvasWidth;
         this._cachedCssCanvasHeight = cssCanvasHeight;
         this._cachedCssHeight = cssHeight;
         this._cachedCssWidth = cssWidth;
         this._cachedZoomFactor = zoomFactor;
         this._cachedViewport = this._viewport;
         this._cachedDrawContentsSize = this._drawContentsSize;
         this._cachedMediaInspectorHeight = mediaInspectorHeight;
     },
 
     onResize: function()
     {
         if (!this._enabled || this._ignoreResize)
             return;
         var oldSize = this._availableSize;
+
+        this._pageScaleContainer.classList.remove("hidden");
+        this._pageScaleContainerWidth = this._pageScaleContainer.offsetWidth;
+
         delete this._availableSize;
         var newSize = this._availableDipSize();
         if (!newSize.isEqual(oldSize))
             this.dispatchEventToListeners(WebInspector.OverridesSupport.PageResizer.Events.AvailableSizeChanged, newSize);
         this._updateUI();
         this._inspectedPagePlaceholder.onResize();
     },
 
     _onZoomChanged: function()
     {
@@ skipping 204 matching lines @@
                 value = Math.min(this._viewport.maximumPageScaleFactor, value);
                 value = Math.max(this._viewport.minimumPageScaleFactor, value)
                 this._target.pageAgent().setPageScaleFactor(value);
             }
             finishCallback();
         }
     },
 
     __proto__: WebInspector.VBox.prototype
 };