Files.app: Rename Rect used in Gallery with ImageRect.

ui/file_manager/gallery/js/image_editor/viewport.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.
 
 'use strict';
 
 /**
  * Viewport class controls the way the image is displayed (scale, offset etc).
  * @constructor
  */
 function Viewport() {
   /**
    * Size of the full resolution image.
-   * @type {Rect}
+   * @type {ImageRect}
    * @private
    */
-  this.imageBounds_ = new Rect();
+  this.imageBounds_ = new ImageRect();
 
   /**
    * Size of the application window.
-   * @type {Rect}
+   * @type {ImageRect}
    * @private
    */
-  this.screenBounds_ = new Rect();
+  this.screenBounds_ = new ImageRect();
 
   /**
    * Bounds of the image element on screen without zoom and offset.
-   * @type {Rect}
+   * @type {ImageRect}
    * @private
    */
   this.imageElementBoundsOnScreen_ = null;
 
   /**
    * Bounds of the image with zoom and offset.
-   * @type {Rect}
+   * @type {ImageRect}
    * @private
    */
   this.imageBoundsOnScreen_ = null;
 
   /**
    * Image bounds that is clipped with the screen bounds.
-   * @type {Rect}
+   * @type {ImageRect}
    * @private
    */
   this.imageBoundsOnScreenClipped_ = null;
 
   /**
    * Scale from the full resolution image to the screen displayed image. This is
    * not zoom operated by users.
    * @type {number}
    * @private
    */
@@ skipping 46 matching lines @@
  * @type {Array.<number>}
  * @const
  */
 Viewport.ZOOM_RATIOS = Object.freeze([1, 1.5, 2, 3]);
 
 /**
  * @param {number} width Image width.
  * @param {number} height Image height.
  */
 Viewport.prototype.setImageSize = function(width, height) {
-  this.imageBounds_ = new Rect(width, height);
+  this.imageBounds_ = new ImageRect(width, height);
   this.update_();
 };
 
 /**
  * @param {number} width Screen width.
  * @param {number} height Screen height.
  */
 Viewport.prototype.setScreenSize = function(width, height) {
-  this.screenBounds_ = new Rect(width, height);
+  this.screenBounds_ = new ImageRect(width, height);
   this.update_();
 };
 
 /**
  * Sets zoom value directly.
  * @param {number} zoom New zoom value.
  */
 Viewport.prototype.setZoom = function(zoom) {
   var zoomMin = Viewport.ZOOM_RATIOS[0];
   var zoomMax = Viewport.ZOOM_RATIOS[Viewport.ZOOM_RATIOS.length - 1];
@@ skipping 96 matching lines @@
  */
 Viewport.prototype.setOffset = function(x, y) {
   if (this.offsetX_ == x && this.offsetY_ == y)
     return;
   this.offsetX_ = x;
   this.offsetY_ = y;
   this.update_();
 };
 
 /**
- * @return {Rect} The image bounds in image coordinates.
+ * @return {ImageRect} The image bounds in image coordinates.
  */
 Viewport.prototype.getImageBounds = function() { return this.imageBounds_; };
 
 /**
-* @return {Rect} The screen bounds in screen coordinates.
+* @return {ImageRect} The screen bounds in screen coordinates.
 */
 Viewport.prototype.getScreenBounds = function() { return this.screenBounds_; };
 
 /**
- * @return {Rect} The size of screen cache canvas.
+ * @return {ImageRect} The size of screen cache canvas.
  */
 Viewport.prototype.getDeviceBounds = function() {
   var size = this.getImageElementBoundsOnScreen();
-  return new Rect(
+  return new ImageRect(
       size.width * window.devicePixelRatio,
       size.height * window.devicePixelRatio);
 };
 
 /**
  * A counter that is incremented with each viewport state change.
  * Clients that cache anything that depends on the viewport state should keep
  * track of this counter.
  * @return {number} counter.
  */
 Viewport.prototype.getCacheGeneration = function() { return this.generation_; };
 
 /**
- * @return {Rect} The image bounds in screen coordinates.
+ * @return {ImageRect} The image bounds in screen coordinates.
  */
 Viewport.prototype.getImageBoundsOnScreen = function() {
   return this.imageBoundsOnScreen_;
 };
 
 /**
  * The image bounds in screen coordinates.
  * This returns the bounds of element before applying zoom and offset.
- * @return {Rect}
+ * @return {ImageRect}
  */
 Viewport.prototype.getImageElementBoundsOnScreen = function() {
   return this.imageElementBoundsOnScreen_;
 };
 
 /**
  * The image bounds on screen, which is clipped with the screen size.
- * @return {Rect}
+ * @return {ImageRect}
  */
 Viewport.prototype.getImageBoundsOnScreenClipped = function() {
   return this.imageBoundsOnScreenClipped_;
 };
 
 /**
  * @param {number} size Size in screen coordinates.
  * @return {number} Size in image coordinates.
  */
 Viewport.prototype.screenToImageSize = function(size) {
@@ skipping 10 matching lines @@
 
 /**
  * @param {number} y Y in screen coordinates.
  * @return {number} Y in image coordinates.
  */
 Viewport.prototype.screenToImageY = function(y) {
   return Math.round((y - this.imageBoundsOnScreen_.top) / this.scale_);
 };
 
 /**
- * @param {Rect} rect Rectangle in screen coordinates.
- * @return {Rect} Rectangle in image coordinates.
+ * @param {ImageRect} rect Rectangle in screen coordinates.
+ * @return {ImageRect} Rectangle in image coordinates.
  */
 Viewport.prototype.screenToImageRect = function(rect) {
-  return new Rect(
+  return new ImageRect(
       this.screenToImageX(rect.left),
       this.screenToImageY(rect.top),
       this.screenToImageSize(rect.width),
       this.screenToImageSize(rect.height));
 };
 
 /**
  * @param {number} size Size in image coordinates.
  * @return {number} Size in screen coordinates.
  */
@@ skipping 11 matching lines @@
 
 /**
  * @param {number} y Y in image coordinates.
  * @return {number} Y in screen coordinates.
  */
 Viewport.prototype.imageToScreenY = function(y) {
   return Math.round(this.imageBoundsOnScreen_.top + y * this.scale_);
 };
 
 /**
- * @param {Rect} rect Rectangle in image coordinates.
- * @return {Rect} Rectangle in screen coordinates.
+ * @param {ImageRect} rect Rectangle in image coordinates.
+ * @return {ImageRect} Rectangle in screen coordinates.
  */
 Viewport.prototype.imageToScreenRect = function(rect) {
-  return new Rect(
+  return new ImageRect(
       this.imageToScreenX(rect.left),
       this.imageToScreenY(rect.top),
       Math.round(this.imageToScreenSize(rect.width)),
       Math.round(this.imageToScreenSize(rect.height)));
 };
 
 /**
  * @param {number} width Width of the rectangle.
  * @param {number} height Height of the rectangle.
  * @param {number} offsetX X-offset of center position of the rectangle.
  * @param {number} offsetY Y-offset of center position of the rectangle.
- * @return {Rect} Rectangle with given geometry.
+ * @return {ImageRect} Rectangle with given geometry.
  * @private
  */
 Viewport.prototype.getCenteredRect_ = function(
     width, height, offsetX, offsetY) {
-  return new Rect(
+  return new ImageRect(
       ~~((this.screenBounds_.width - width) / 2) + offsetX,
       ~~((this.screenBounds_.height - height) / 2) + offsetY,
       width,
       height);
 };
 
 /**
  * Resets zoom and offset.
  */
 Viewport.prototype.resetView = function() {
@@ skipping 47 matching lines @@
     this.generation_++;
   }
 
   // Image bounds on screen clipped with the screen bounds.
   var left = Math.max(this.imageBoundsOnScreen_.left, 0);
   var top = Math.max(this.imageBoundsOnScreen_.top, 0);
   var right = Math.min(
       this.imageBoundsOnScreen_.right, this.screenBounds_.width);
   var bottom = Math.min(
       this.imageBoundsOnScreen_.bottom, this.screenBounds_.height);
-  this.imageBoundsOnScreenClipped_ = new Rect(
+  this.imageBoundsOnScreenClipped_ = new ImageRect(
       left, top, right - left, bottom - top);
 };
 
 /**
  * Clones the viewport.
  * @return {Viewport} New instance.
  */
 Viewport.prototype.clone = function() {
   var viewport = new Viewport();
-  viewport.imageBounds_ = new Rect(this.imageBounds_);
-  viewport.screenBounds_ = new Rect(this.screenBounds_);
+  viewport.imageBounds_ = new ImageRect(this.imageBounds_);
+  viewport.screenBounds_ = new ImageRect(this.screenBounds_);
   viewport.scale_ = this.scale_;
   viewport.zoom_ = this.zoom_;
   viewport.offsetX_ = this.offsetX_;
   viewport.offsetY_ = this.offsetY_;
   viewport.rotation_ = this.rotation_;
   viewport.generation_ = this.generation_;
   viewport.update_();
   return viewport;
 };
 
@@ skipping 49 matching lines @@
   ].join(' ');
 };
 
 /**
  * Obtains CSS transformation that makes the cropped image fit the original
  * image. The new cropped image that the transformation is applied to fits to
  * the cropped rectangle in the original image.
  *
  * @param {number} imageWidth Width of the original image.
  * @param {number} imageHeight Height of the original image.
- * @param {Rect} imageCropRect Crop rectangle in the image's coordinate system.
+ * @param {ImageRect} imageCropRect Crop rectangle in the image's coordinate
+ *     system.
  * @return {string} Transformation description.
  */
 Viewport.prototype.getInverseTransformForCroppedImage =
     function(imageWidth, imageHeight, imageCropRect) {
   var wholeScale = this.getFittingScaleForImageSize_(
       imageWidth, imageHeight);
   var croppedScale = this.getFittingScaleForImageSize_(
       imageCropRect.width, imageCropRect.height);
   var dx =
       (imageCropRect.left + imageCropRect.width / 2 - imageWidth / 2) *
       wholeScale;
   var dy =
       (imageCropRect.top + imageCropRect.height / 2 - imageHeight / 2) *
       wholeScale;
   return [
     'translate(' + dx + 'px,' + dy + 'px)',
     'scale(' + wholeScale / croppedScale + ')',
     this.getTransformation()
   ].join(' ');
 };
 
 /**
  * Obtains CSS transformation that makes the image fit to the screen rectangle.
  *
- * @param {Rect} screenRect Screen rectangle.
+ * @param {ImageRect} screenRect Screen rectangle.
  * @return {string} Transformation description.
  */
 Viewport.prototype.getScreenRectTransformForImage = function(screenRect) {
   var imageBounds = this.getImageElementBoundsOnScreen();
   var scaleX = screenRect.width / imageBounds.width;
   var scaleY = screenRect.height / imageBounds.height;
   var screenWidth = this.screenBounds_.width;
   var screenHeight = this.screenBounds_.height;
   var dx = screenRect.left + screenRect.width / 2 - screenWidth / 2;
   var dy = screenRect.top + screenRect.height / 2 - screenHeight / 2;
   return [
     'translate(' + dx + 'px,' + dy + 'px)',
     'scale(' + scaleX + ',' + scaleY + ')',
     this.getTransformation()
   ].join(' ');
 };