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

ui/file_manager/gallery/js/image_editor/image_util.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';
 
 
 // Namespace object for the utilities.
 function ImageUtil() {}
 
@@ skipping 64 matching lines @@
   return (value - min) * (value - max) <= 0;
 };
 
 /**
  * Rectangle class.
  */
 
 /**
  * Rectangle constructor takes 0, 1, 2 or 4 arguments.
  * Supports following variants:
- *   new Rect(left, top, width, height)
- *   new Rect(width, height)
- *   new Rect(rect)         // anything with left, top, width, height properties
- *   new Rect(bounds)       // anything with left, top, right, bottom properties
- *   new Rect(canvas|image) // anything with width and height properties.
- *   new Rect()             // empty rectangle.
+ *   new ImageRect(left, top, width, height)
+ *   new ImageRect(width, height)
+ *   new ImageRect(rect)         // anything with left, top, width, height.
+ *   new ImageRect(bounds)       // anything with left, top, right, bottom.
+ *   new ImageRect(canvas|image) // anything with width and height.
+ *   new ImageRect()             // empty rectangle.
  * @constructor
  */
-function Rect() {
+function ImageRect() {
   switch (arguments.length) {
     case 4:
       this.left = arguments[0];
       this.top = arguments[1];
       this.width = arguments[2];
       this.height = arguments[3];
       return;
 
     case 2:
       this.left = 0;
@@ skipping 24 matching lines @@
       break; // Fall through to the error message.
     }
 
     case 0:
       this.left = 0;
       this.top = 0;
       this.width = 0;
       this.height = 0;
       return;
   }
-  console.error('Invalid Rect constructor arguments:',
+  console.error('Invalid ImageRect constructor arguments:',
                 Array.apply(null, arguments));
 }
 
-Rect.prototype = {
+ImageRect.prototype = {
   /**
    * Obtains the x coordinate of right edge. The most right pixels in the
    * rectangle are (x = right - 1) and the pixels (x = right) are not included
    * in the rectangle.
    * @return {number}
    */
   get right() {
     return this.left + this.width;
   },
 
   /**
    * Obtains the y coordinate of bottom edge. The most bottom pixels in the
    * rectangle are (y = bottom - 1) and the pixels (y = bottom) are not included
    * in the rectangle.
    * @return {number}
    */
   get bottom() {
     return this.top + this.height;
   }
 };
 
 /**
  * @param {number} factor Factor to scale.
- * @return {Rect} A rectangle with every dimension scaled.
+ * @return {ImageRect} A rectangle with every dimension scaled.
  */
-Rect.prototype.scale = function(factor) {
-  return new Rect(
+ImageRect.prototype.scale = function(factor) {
+  return new ImageRect(
       this.left * factor,
       this.top * factor,
       this.width * factor,
       this.height * factor);
 };
 
 /**
  * @param {number} dx Difference in X.
  * @param {number} dy Difference in Y.
- * @return {Rect} A rectangle shifted by (dx,dy), same size.
+ * @return {ImageRect} A rectangle shifted by (dx,dy), same size.
  */
-Rect.prototype.shift = function(dx, dy) {
-  return new Rect(this.left + dx, this.top + dy, this.width, this.height);
+ImageRect.prototype.shift = function(dx, dy) {
+  return new ImageRect(this.left + dx, this.top + dy, this.width, this.height);
 };
 
 /**
  * @param {number} x Coordinate of the left top corner.
  * @param {number} y Coordinate of the left top corner.
- * @return {Rect} A rectangle with left==x and top==y, same size.
+ * @return {ImageRect} A rectangle with left==x and top==y, same size.
  */
-Rect.prototype.moveTo = function(x, y) {
-  return new Rect(x, y, this.width, this.height);
+ImageRect.prototype.moveTo = function(x, y) {
+  return new ImageRect(x, y, this.width, this.height);
 };
 
 /**
  * @param {number} dx Difference in X.
  * @param {number} dy Difference in Y.
- * @return {Rect} A rectangle inflated by (dx, dy), same center.
+ * @return {ImageRect} A rectangle inflated by (dx, dy), same center.
  */
-Rect.prototype.inflate = function(dx, dy) {
-  return new Rect(
+ImageRect.prototype.inflate = function(dx, dy) {
+  return new ImageRect(
       this.left - dx, this.top - dy, this.width + 2 * dx, this.height + 2 * dy);
 };
 
 /**
  * @param {number} x Coordinate of the point.
  * @param {number} y Coordinate of the point.
  * @return {boolean} True if the point lies inside the rectangle.
  */
-Rect.prototype.inside = function(x, y) {
+ImageRect.prototype.inside = function(x, y) {
   return this.left <= x && x < this.left + this.width &&
          this.top <= y && y < this.top + this.height;
 };
 
 /**
- * @param {Rect} rect Rectangle to check.
+ * @param {ImageRect} rect Rectangle to check.
  * @return {boolean} True if this rectangle intersects with the |rect|.
  */
-Rect.prototype.intersects = function(rect) {
+ImageRect.prototype.intersects = function(rect) {
   return (this.left + this.width) > rect.left &&
          (rect.left + rect.width) > this.left &&
          (this.top + this.height) > rect.top &&
          (rect.top + rect.height) > this.top;
 };
 
 /**
- * @param {Rect} rect Rectangle to check.
+ * @param {ImageRect} rect Rectangle to check.
  * @return {boolean} True if this rectangle containing the |rect|.
  */
-Rect.prototype.contains = function(rect) {
+ImageRect.prototype.contains = function(rect) {
   return (this.left <= rect.left) &&
          (rect.left + rect.width) <= (this.left + this.width) &&
          (this.top <= rect.top) &&
          (rect.top + rect.height) <= (this.top + this.height);
 };
 
 /**
  * @return {boolean} True if rectangle is empty.
  */
-Rect.prototype.isEmpty = function() {
+ImageRect.prototype.isEmpty = function() {
   return this.width === 0 || this.height === 0;
 };
 
 /**
  * Clamp the rectangle to the bounds by moving it.
  * Decrease the size only if necessary.
- * @param {Rect} bounds Bounds.
- * @return {Rect} Calculated rectangle.
+ * @param {ImageRect} bounds Bounds.
+ * @return {ImageRect} Calculated rectangle.
  */
-Rect.prototype.clamp = function(bounds) {
-  var rect = new Rect(this);
+ImageRect.prototype.clamp = function(bounds) {
+  var rect = new ImageRect(this);
 
   if (rect.width > bounds.width) {
     rect.left = bounds.left;
     rect.width = bounds.width;
   } else if (rect.left < bounds.left) {
     rect.left = bounds.left;
   } else if (rect.left + rect.width >
              bounds.left + bounds.width) {
     rect.left = bounds.left + bounds.width - rect.width;
   }
 
   if (rect.height > bounds.height) {
     rect.top = bounds.top;
     rect.height = bounds.height;
   } else if (rect.top < bounds.top) {
     rect.top = bounds.top;
   } else if (rect.top + rect.height >
              bounds.top + bounds.height) {
     rect.top = bounds.top + bounds.height - rect.height;
   }
 
   return rect;
 };
 
 /**
  * @return {string} String representation.
  */
-Rect.prototype.toString = function() {
+ImageRect.prototype.toString = function() {
   return '(' + this.left + ',' + this.top + '):' +
          '(' + (this.left + this.width) + ',' + (this.top + this.height) + ')';
 };
 /*
  * Useful shortcuts for drawing (static functions).
  */
 
 /**
  * Draw the image in context with appropriate scaling.
  * @param {CanvasRenderingContext2D} context Context to draw.
  * @param {Image} image Image to draw.
- * @param {Rect=} opt_dstRect Rectangle in the canvas (whole canvas by default).
- * @param {Rect=} opt_srcRect Rectangle in the image (whole image by default).
+ * @param {ImageRect=} opt_dstRect Rectangle in the canvas (whole canvas by
+ *     default).
+ * @param {ImageRect=} opt_srcRect Rectangle in the image (whole image by
+ *     default).
  */
-Rect.drawImage = function(context, image, opt_dstRect, opt_srcRect) {
-  opt_dstRect = opt_dstRect || new Rect(context.canvas);
-  opt_srcRect = opt_srcRect || new Rect(image);
+ImageRect.drawImage = function(context, image, opt_dstRect, opt_srcRect) {
+  opt_dstRect = opt_dstRect || new ImageRect(context.canvas);
+  opt_srcRect = opt_srcRect || new ImageRect(image);
   if (opt_dstRect.isEmpty() || opt_srcRect.isEmpty())
     return;
   context.drawImage(image,
       opt_srcRect.left, opt_srcRect.top, opt_srcRect.width, opt_srcRect.height,
       opt_dstRect.left, opt_dstRect.top, opt_dstRect.width, opt_dstRect.height);
 };
 
 /**
  * Draw a box around the rectangle.
  * @param {CanvasRenderingContext2D} context Context to draw.
- * @param {Rect} rect Rectangle.
+ * @param {ImageRect} rect Rectangle.
  */
-Rect.outline = function(context, rect) {
+ImageRect.outline = function(context, rect) {
   context.strokeRect(
       rect.left - 0.5, rect.top - 0.5, rect.width + 1, rect.height + 1);
 };
 
 /**
  * Fill the rectangle.
  * @param {CanvasRenderingContext2D} context Context to draw.
- * @param {Rect} rect Rectangle.
+ * @param {ImageRect} rect Rectangle.
  */
-Rect.fill = function(context, rect) {
+ImageRect.fill = function(context, rect) {
   context.fillRect(rect.left, rect.top, rect.width, rect.height);
 };
 
 /**
  * Fills the space between the two rectangles.
  * @param {CanvasRenderingContext2D} context Context to draw.
- * @param {Rect} inner Inner rectangle.
- * @param {Rect} outer Outer rectangle.
+ * @param {ImageRect} inner Inner rectangle.
+ * @param {ImageRect} outer Outer rectangle.
  */
-Rect.fillBetween = function(context, inner, outer) {
+ImageRect.fillBetween = function(context, inner, outer) {
   var innerRight = inner.left + inner.width;
   var innerBottom = inner.top + inner.height;
   var outerRight = outer.left + outer.width;
   var outerBottom = outer.top + outer.height;
   if (inner.top > outer.top) {
     context.fillRect(
         outer.left, outer.top, outer.width, inner.top - outer.top);
   }
   if (inner.left > outer.left) {
     context.fillRect(
@@ skipping 346 matching lines @@
  * @return {string} Full name.
  */
 ImageUtil.getMetricName = function(name) {
   return 'PhotoEditor.' + name;
 };
 
 /**
  * Used for metrics reporting, keep in sync with the histogram description.
  */
 ImageUtil.FILE_TYPES = ['jpg', 'png', 'gif', 'bmp', 'webp'];