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

ui/file_manager/gallery/js/image_editor/image_view.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';
 
 /**
  * The overlay displaying the image.
  *
  * @param {HTMLElement} container The container element.
@@ skipping 77 matching lines @@
 /**
  * @override
  */
 ImageView.prototype.draw = function() {
   if (!this.contentCanvas_)  // Do nothing if the image content is not set.
     return;
   if (this.setupDeviceBuffer(this.screenImage_) ||
       this.displayedContentGeneration_ !== this.contentGeneration_) {
     this.displayedContentGeneration_ = this.contentGeneration_;
     ImageUtil.trace.resetTimer('paint');
-    this.paintDeviceRect(this.contentCanvas_, new Rect(this.contentCanvas_));
+    this.paintDeviceRect(
+        this.contentCanvas_, new ImageRect(this.contentCanvas_));
     ImageUtil.trace.reportTimer('paint');
   }
 };
 
 /**
  * Applies the viewport change that does not affect the screen cache size (zoom
  * change or offset change) with animation.
  */
 ImageView.prototype.applyViewportChange = function() {
   if (this.screenImage_) {
@@ skipping 42 matching lines @@
 ImageView.prototype.getContentRevision = function() {
   return this.contentRevision_;
 };
 
 /**
  * Copies an image fragment from a full resolution canvas to a device resolution
  * canvas.
  *
  * @param {HTMLCanvasElement} canvas Canvas containing whole image. The canvas
  *     may not be full resolution (scaled).
- * @param {Rect} imageRect Rectangle region of the canvas to be rendered.
+ * @param {ImageRect} imageRect Rectangle region of the canvas to be rendered.
  */
 ImageView.prototype.paintDeviceRect = function(canvas, imageRect) {
   // Map the rectangle in full resolution image to the rectangle in the device
   // canvas.
   var deviceBounds = this.viewport_.getDeviceBounds();
   var scaleX = deviceBounds.width / canvas.width;
   var scaleY = deviceBounds.height / canvas.height;
-  var deviceRect = new Rect(
+  var deviceRect = new ImageRect(
       imageRect.left * scaleX,
       imageRect.top * scaleY,
       imageRect.width * scaleX,
       imageRect.height * scaleY);
 
-  Rect.drawImage(
+  ImageRect.drawImage(
       this.screenImage_.getContext('2d'), canvas, deviceRect, imageRect);
 };
 
 /**
  * Creates an overlay canvas with properties similar to the screen canvas.
  * Useful for showing quick feedback when editing.
  *
  * @return {HTMLCanvasElement} Overlay canvas.
  */
 ImageView.prototype.createOverlayCanvas = function() {
@@ skipping 211 matching lines @@
   if (item.contentImage)
     return;
   this.prefetchLoader_.load(item, function(canvas) {
     if (canvas.width && canvas.height && !item.contentImage)
       item.contentImage = canvas;
   }, delay);
 };
 
 /**
  * Unloads content.
- * @param {Rect} zoomToRect Target rectangle for zoom-out-effect.
+ * @param {ImageRect} zoomToRect Target rectangle for zoom-out-effect.
  */
 ImageView.prototype.unload = function(zoomToRect) {
   if (this.unloadTimer_) {
     clearTimeout(this.unloadTimer_);
     this.unloadTimer_ = null;
   }
   if (zoomToRect && this.screenImage_) {
     var effect = this.createZoomEffect(zoomToRect);
     this.setTransform_(this.screenImage_, this.viewport_, effect);
     this.screenImage_.setAttribute('fade', true);
@@ skipping 75 matching lines @@
  */
 ImageView.prototype.updateThumbnail_ = function(canvas) {
   ImageUtil.trace.resetTimer('thumb');
   var pixelCount = 10000;
   var downScale =
       Math.max(1, Math.sqrt(canvas.width * canvas.height / pixelCount));
 
   this.thumbnailCanvas_ = canvas.ownerDocument.createElement('canvas');
   this.thumbnailCanvas_.width = Math.round(canvas.width / downScale);
   this.thumbnailCanvas_.height = Math.round(canvas.height / downScale);
-  Rect.drawImage(this.thumbnailCanvas_.getContext('2d'), canvas);
+  ImageRect.drawImage(this.thumbnailCanvas_.getContext('2d'), canvas);
   ImageUtil.trace.reportTimer('thumb');
 };
 
 /**
  * Replaces the displayed image, possibly with slide-in animation.
  *
  * @param {HTMLCanvasElement} content The image element.
  * @param {Object=} opt_effect Transition effect object.
  * @param {number=} opt_width Image width.
  * @param {number=} opt_height Image height.
@@ skipping 52 matching lines @@
   if (!opt_effect)
     opt_effect = new ImageView.Effect.None();
   if (typeof opt_duration !== 'number')
     opt_duration = opt_effect.getDuration();
   element.style.webkitTransitionDuration = opt_duration + 'ms';
   element.style.webkitTransitionTimingFunction = opt_effect.getTiming();
   element.style.webkitTransform = opt_effect.transform(element, viewport);
 };
 
 /**
- * @param {Rect} screenRect Target rectangle in screen coordinates.
+ * @param {ImageRect} screenRect Target rectangle in screen coordinates.
  * @return {ImageView.Effect.Zoom} Zoom effect object.
  */
 ImageView.prototype.createZoomEffect = function(screenRect) {
   return new ImageView.Effect.ZoomToScreen(
       screenRect,
       ImageView.MODE_TRANSITION_DURATION);
 };
 
 /**
  * Visualizes crop or rotate operation. Hide the old image instantly, animate
  * the new image to visualize the operation.
  *
  * @param {HTMLCanvasElement} canvas New content canvas.
- * @param {Rect} imageCropRect The crop rectangle in image coordinates.
+ * @param {ImageRect} imageCropRect The crop rectangle in image coordinates.
  *                             Null for rotation operations.
  * @param {number} rotate90 Rotation angle in 90 degree increments.
  * @return {number} Animation duration.
  */
 ImageView.prototype.replaceAndAnimate = function(
     canvas, imageCropRect, rotate90) {
   var oldImageBounds = {
     width: this.viewport_.getImageBounds().width,
     height: this.viewport_.getImageBounds().height
   };
@@ skipping 17 matching lines @@
       0);
 
   return effect.getSafeInterval();
 };
 
 /**
  * Visualizes "undo crop". Shrink the current image to the given crop rectangle
  * while fading in the new image.
  *
  * @param {HTMLCanvasElement} canvas New content canvas.
- * @param {Rect} imageCropRect The crop rectangle in image coordinates.
+ * @param {ImageRect} imageCropRect The crop rectangle in image coordinates.
  * @return {number} Animation duration.
  */
 ImageView.prototype.animateAndReplace = function(canvas, imageCropRect) {
   var oldScreenImage = this.screenImage_;
   this.replaceContent_(canvas);
   var newScreenImage = this.screenImage_;
   var setFade = ImageUtil.setAttribute.bind(null, newScreenImage, 'fade');
   setFade(true);
   oldScreenImage.parentNode.insertBefore(newScreenImage, oldScreenImage);
   var effect = new ImageView.Effect.Zoom(
@@ skipping 123 matching lines @@
   return viewport.getShiftTransformation(this.shift_);
 };
 
 /**
  * Zoom effect.
  *
  * Animates the original rectangle to the target rectangle.
  *
  * @param {number} previousImageWidth Width of the full resolution image.
  * @param {number} previousImageHeight Height of the full resolution image.
- * @param {Rect} imageCropRect Crop rectangle in the full resolution image.
+ * @param {ImageRect} imageCropRect Crop rectangle in the full resolution image.
  * @param {number=} opt_duration Duration of the effect.
  * @constructor
  * @extends {ImageView.Effect}
  */
 ImageView.Effect.Zoom = function(
     previousImageWidth, previousImageHeight, imageCropRect, opt_duration) {
   ImageView.Effect.call(this,
       opt_duration || ImageView.Effect.DEFAULT_DURATION, 'ease-out');
   this.previousImageWidth_ = previousImageWidth;
   this.previousImageHeight_ = previousImageHeight;
   this.imageCropRect_ = imageCropRect;
 };
 
 ImageView.Effect.Zoom.prototype = { __proto__: ImageView.Effect.prototype };
 
 /**
  * @override
  */
 ImageView.Effect.Zoom.prototype.transform = function(element, viewport) {
   return viewport.getInverseTransformForCroppedImage(
       this.previousImageWidth_, this.previousImageHeight_, this.imageCropRect_);
 };
 
 /**
  * Effect to zoom to a screen rectangle.
  *
- * @param {Rect} screenRect Rectangle in the application window's coordinate.
+ * @param {ImageRect} screenRect Rectangle in the application window's
+ *     coordinate.
  * @param {number=} opt_duration Duration of effect.
  * @constructor
  * @extends {ImageView.Effect}
  */
 ImageView.Effect.ZoomToScreen = function(screenRect, opt_duration) {
   ImageView.Effect.call(this, opt_duration);
   this.screenRect_ = screenRect;
 };
 
 ImageView.Effect.ZoomToScreen.prototype = {
@@ skipping 22 matching lines @@
 };
 
 ImageView.Effect.Rotate.prototype = { __proto__: ImageView.Effect.prototype };
 
 /**
  * @override
  */
 ImageView.Effect.Rotate.prototype.transform = function(element, viewport) {
   return viewport.getInverseTransformForRotatedImage(this.orientation_);
 };