Pre-scaling images to speed up feedback in Image Editor.

chrome/browser/resources/file_manager/js/image_editor/image_util.js

 // Copyright (c) 2011 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.
 
 
 // Namespace object for the utilities.
 function ImageUtil() {}
 
 // Performance trace.
 ImageUtil.trace = (function() {
   function PerformanceTrace() {
     this.lines_ = {};
     this.timers_ = {};
     this.container_ = null;
   }
 
   PerformanceTrace.prototype.bindToDOM = function(container) {
     this.container_ = container;
   };
 
-  PerformanceTrace.prototype.report_ = function(key, value) {
+  PerformanceTrace.prototype.report = function(key, value) {
     if (!this.container_) return;
     if (!(key in this.lines_)) {
       var div = this.lines_[key] = document.createElement('div');
       this.container_.appendChild(div);
     }
     this.lines_[key].textContent = key + ': ' + value;
   };
 
   PerformanceTrace.prototype.resetTimer = function(key) {
     this.timers_[key] = Date.now();
-  }
+  };
 
   PerformanceTrace.prototype.reportTimer = function(key) {
-    this.report_(key, (Date.now() - this.timers_[key]) + 'ms');
+    this.report(key, (Date.now() - this.timers_[key]) + 'ms');
   };
 
   return new PerformanceTrace();
 })();
 
 
-ImageUtil.clip = function(min, value, max) {
+ImageUtil.clamp = function(min, value, max) {
   return Math.max(min, Math.min(max, value));
 };
 
 ImageUtil.between = function(min, value, max) {
   return (value - min) * (value - max) <= 0;
 };
 
 /**
  * Computes the function for every integer value between 0 and max and stores
  * the results. Rounds and clips the results to fit the [0..255] range.
@@ skipping 109 matching lines @@
 };
 
 /**
  * @return {Boolean} True if the point lies inside the rectange.
  */
 Rect.prototype.inside = function(x, y) {
   return this.left <= x && x < this.left + this.width &&
          this.top <= y && y < this.top + this.height;
 };
 
+/**
+ * Clamp the rectangle to the bounds by moving it.
+ * Decrease the size only if necessary.
+ */
+Rect.prototype.clamp = function(bounds) {
+  var rect = new Rect(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;
+};
+
 /*
  * Useful shortcuts for drawing (static functions).
  */
 
 /**
  * Draws the image in context with appropriate scaling.
  */
-Rect.drawImage = function(context, image, dstRect, srcRect) {
+Rect.drawImage = function(context, image, opt_dstRect, opt_srcRect) {
+  opt_dstRect = opt_dstRect || new Rect(context.canvas);
+  opt_srcRect = opt_srcRect || new Rect(image);
   context.drawImage(image,
-      srcRect.left, srcRect.top, srcRect.width, srcRect.height,
-      dstRect.left, dstRect.top, dstRect.width, dstRect.height);
+      opt_srcRect.left, opt_srcRect.top, opt_srcRect.width, opt_srcRect.height,
+      opt_dstRect.left, opt_dstRect.top, opt_dstRect.width, opt_dstRect.height);
 };
 
 /**
  * Strokes the rectangle.
  */
 Rect.stroke = function(context, rect) {
   context.strokeRect(rect.left, rect.top, rect.width, rect.height);
 };
 
 /**
@@ skipping 23 matching lines @@
 };
 
 /**
  * Circle class.
  */
 
 function Circle(x, y, R) {
   this.x = x;
   this.y = y;
   this.squaredR = R * R;
-};
+}
 
 Circle.prototype.inside = function(x, y) {
   x -= this.x;
   y -= this.y;
   return x * x + y * y <= this.squaredR;
 };