Compile Image Editor in gyp v2

ui/file_manager/gallery/js/image_editor/image_transform.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.
 
 /**
  * Crop mode.
  *
- * @extends {ImageEditor.Mode}
+ * @extends {ImageEditorMode}
  * @constructor
  * @struct
  */
-ImageEditor.Mode.Crop = function() {
-  ImageEditor.Mode.call(this, 'crop', 'GALLERY_CROP');
+ImageEditorMode.Crop = function() {
+  ImageEditorMode.call(this, 'crop', 'GALLERY_CROP');
 
-  this.paddingTop = ImageEditor.Mode.Crop.MOUSE_GRAB_RADIUS;
-  this.paddingBottom = ImageEditor.Mode.Crop.MOUSE_GRAB_RADIUS;
+  this.paddingTop = ImageEditorMode.Crop.MOUSE_GRAB_RADIUS;
+  this.paddingBottom = ImageEditorMode.Crop.MOUSE_GRAB_RADIUS;
 
   /**
    * @type {HTMLElement}
    * @private
    */
   this.domOverlay_ = null;
 
   /**
    * @type {HTMLElement}
    * @private
@@ skipping 36 matching lines @@
    */
   this.onViewportResizedBound_ = null;
 
   /**
    * @type {DraggableRect}
    * @private
    */
   this.cropRect_ = null;
 };
 
-ImageEditor.Mode.Crop.prototype = {__proto__: ImageEditor.Mode.prototype};
+ImageEditorMode.Crop.prototype = {
+  __proto__: ImageEditorMode.prototype
+};
 
 /**
  * Sets the mode up.
  * @override
  */
-ImageEditor.Mode.Crop.prototype.setUp = function() {
-  ImageEditor.Mode.prototype.setUp.apply(this, arguments);
+ImageEditorMode.Crop.prototype.setUp = function() {
+  ImageEditorMode.prototype.setUp.apply(this, arguments);
 
   var container = this.getImageView().container_;
   var doc = container.ownerDocument;
 
   this.domOverlay_ = /** @type {!HTMLElement} */ (doc.createElement('div'));
   this.domOverlay_.className = 'crop-overlay';
   container.appendChild(this.domOverlay_);
 
   this.shadowTop_ = /** @type {!HTMLElement} */ (doc.createElement('div'));
   this.shadowTop_.className = 'shadow';
@@ skipping 37 matching lines @@
 
   this.onViewportResizedBound_ = this.onViewportResized_.bind(this);
   this.getViewport().addEventListener('resize', this.onViewportResizedBound_);
 
   this.createDefaultCrop();
 };
 
 /**
  * @override
  */
-ImageEditor.Mode.Crop.prototype.createTools = function(toolbar) {
+ImageEditorMode.Crop.prototype.createTools = function(toolbar) {
   var aspects = {
     GALLERY_ASPECT_RATIO_1_1: 1 / 1,
     GALLERY_ASPECT_RATIO_6_4: 6 / 4,
     GALLERY_ASPECT_RATIO_7_5: 7 / 5,
     GALLERY_ASPECT_RATIO_16_9: 16 / 9
   };
 
   // TODO(fukino): The loop order is not guaranteed. Fix it!
   for (var name in aspects) {
     var button = toolbar.addButton(
-        name,
-        ImageEditor.Toolbar.ButtonType.LABEL,
+        name, ImageEditorToolbar.ButtonType.LABEL,
         this.onCropAspectRatioClicked_.bind(this, toolbar, aspects[name]),
         'crop-aspect-ratio');
 
     // Prevent from cropping by Enter key if the button is focused.
     button.addEventListener('keydown', function(event) {
       var key = util.getKeyModifiers(event) + event.key;
       if (key === 'Enter')
         event.stopPropagation();
     });
   }
 };
 
 /**
  * Handles click events of crop aspect ratio buttons.
- * @param {!ImageEditor.Toolbar} toolbar Toolbar.
+ * @param {!ImageEditorToolbar} toolbar Toolbar.
  * @param {number} aspect Aspect ratio.
  * @param {Event} event An event.
  * @private
  */
-ImageEditor.Mode.Crop.prototype.onCropAspectRatioClicked_ = function(
+ImageEditorMode.Crop.prototype.onCropAspectRatioClicked_ = function(
     toolbar, aspect, event) {
   var button = event.target;
 
   if (button.classList.contains('selected')) {
     button.classList.remove('selected');
     this.cropRect_.fixedAspectRatio = null;
   } else {
     var selectedButtons =
         toolbar.getElement().querySelectorAll('button.selected');
     for (var i = 0; i < selectedButtons.length; i++) {
       selectedButtons[i].classList.remove('selected');
     }
     button.classList.add('selected');
     var clipRect = this.viewport_.screenToImageRect(
         this.viewport_.getImageBoundsOnScreenClipped());
     this.cropRect_.fixedAspectRatio = aspect;
     this.cropRect_.forceAspectRatio(aspect, clipRect);
     this.markUpdated();
     this.positionDOM();
   }
 };
 
 /**
  * Handles resizing of the viewport and updates the crop rectangle.
  * @private
  */
-ImageEditor.Mode.Crop.prototype.onViewportResized_ = function() {
+ImageEditorMode.Crop.prototype.onViewportResized_ = function() {
   this.positionDOM();
 };
 
 /**
  * Resets the mode.
  */
-ImageEditor.Mode.Crop.prototype.reset = function() {
-  ImageEditor.Mode.prototype.reset.call(this);
+ImageEditorMode.Crop.prototype.reset = function() {
+  ImageEditorMode.prototype.reset.call(this);
   this.createDefaultCrop();
 };
 
 /**
  * Updates the position of DOM elements.
  */
-ImageEditor.Mode.Crop.prototype.positionDOM = function() {
+ImageEditorMode.Crop.prototype.positionDOM = function() {
   var screenCrop = this.viewport_.imageToScreenRect(this.cropRect_.getRect());
 
   this.shadowLeft_.style.width = screenCrop.left + 'px';
   this.shadowTop_.style.height = screenCrop.top + 'px';
   this.shadowRight_.style.width = window.innerWidth - screenCrop.right + 'px';
   this.shadowBottom_.style.height =
       window.innerHeight - screenCrop.bottom + 'px';
 };
 
 /**
  * Removes the overlay elements from the document.
  */
-ImageEditor.Mode.Crop.prototype.cleanUpUI = function() {
-  ImageEditor.Mode.prototype.cleanUpUI.apply(this, arguments);
+ImageEditorMode.Crop.prototype.cleanUpUI = function() {
+  ImageEditorMode.prototype.cleanUpUI.apply(this, arguments);
   this.domOverlay_.parentNode.removeChild(this.domOverlay_);
   this.domOverlay_ = null;
   this.getViewport().removeEventListener(
       'resize', this.onViewportResizedBound_);
   this.onViewportResizedBound_ = null;
 };
 
 /**
  * @const
  * @type {number}
  */
-ImageEditor.Mode.Crop.MOUSE_GRAB_RADIUS = 6;
+ImageEditorMode.Crop.MOUSE_GRAB_RADIUS = 6;
 
 /**
  * @const
  * @type {number}
  */
-ImageEditor.Mode.Crop.TOUCH_GRAB_RADIUS = 20;
+ImageEditorMode.Crop.TOUCH_GRAB_RADIUS = 20;
 
 /**
  * Gets command to do the crop depending on the current state.
  *
  * @return {!Command.Crop} Crop command.
  */
-ImageEditor.Mode.Crop.prototype.getCommand = function() {
+ImageEditorMode.Crop.prototype.getCommand = function() {
   var cropImageRect = this.cropRect_.getRect();
   return new Command.Crop(cropImageRect);
 };
 
 /**
  * Creates default (initial) crop.
  */
-ImageEditor.Mode.Crop.prototype.createDefaultCrop = function() {
+ImageEditorMode.Crop.prototype.createDefaultCrop = function() {
   var viewport = this.getViewport();
   assert(viewport);
 
   var rect = viewport.screenToImageRect(
       viewport.getImageBoundsOnScreenClipped());
   rect = rect.inflate(
       -Math.round(rect.width / 6), -Math.round(rect.height / 6));
 
   this.cropRect_ = new DraggableRect(rect, viewport);
 
   this.positionDOM();
 };
 
 /**
  * Obtains the cursor style depending on the mouse state.
  *
  * @param {number} x X coordinate for cursor.
  * @param {number} y Y coordinate for cursor.
  * @param {boolean} mouseDown If mouse button is down.
  * @return {string} A value for style.cursor CSS property.
  */
-ImageEditor.Mode.Crop.prototype.getCursorStyle = function(x, y, mouseDown) {
+ImageEditorMode.Crop.prototype.getCursorStyle = function(x, y, mouseDown) {
   return this.cropRect_.getCursorStyle(x, y, mouseDown);
 };
 
 /**
  * Obtains handler function depending on the mouse state.
  *
  * @param {number} x Event X coordinate.
  * @param {number} y Event Y coordinate.
  * @param {boolean} touch True if it's a touch event, false if mouse.
  * @return {?function(number,number,boolean)} A function to be called on mouse
  *     drag. It takes x coordinate value, y coordinate value, and shift key
  *     flag.
  */
-ImageEditor.Mode.Crop.prototype.getDragHandler = function(x, y, touch) {
+ImageEditorMode.Crop.prototype.getDragHandler = function(x, y, touch) {
   var cropDragHandler = this.cropRect_.getDragHandler(x, y, touch);
   if (!cropDragHandler)
     return null;
 
   return function(x, y, shiftKey) {
     cropDragHandler(x, y, shiftKey);
     this.markUpdated();
     this.positionDOM();
   }.bind(this);
 };
 
 /**
  * Obtains the double tap action depending on the coordinate.
  *
  * @param {number} x X coordinate of the event.
  * @param {number} y Y coordinate of the event.
  * @return {!ImageBuffer.DoubleTapAction} Action to perform as result.
  */
-ImageEditor.Mode.Crop.prototype.getDoubleTapAction = function(x, y) {
+ImageEditorMode.Crop.prototype.getDoubleTapAction = function(x, y) {
   return this.cropRect_.getDoubleTapAction(x, y);
 };
 
 /**
  * A draggable rectangle over the image.
  *
  * @param {!ImageRect} rect Initial size of the image.
  * @param {!Viewport} viewport Viewport.
  * @constructor
  * @struct
@@ skipping 123 matching lines @@
 
   var result = {
     xSide: DraggableRect.NONE,
     ySide: DraggableRect.NONE,
     whole: false,
     newCrop: false
   };
 
   var bounds = this.bounds_;
   var R = this.viewport_.screenToImageSize(
-      touch ? ImageEditor.Mode.Crop.TOUCH_GRAB_RADIUS :
-              ImageEditor.Mode.Crop.MOUSE_GRAB_RADIUS);
+      touch ? ImageEditorMode.Crop.TOUCH_GRAB_RADIUS :
+              ImageEditorMode.Crop.MOUSE_GRAB_RADIUS);
 
   var circle = new Circle(x, y, R);
 
   var xBetween = ImageUtil.between(bounds.left, x, bounds.right);
   var yBetween = ImageUtil.between(bounds.top, y, bounds.bottom);
 
   if (circle.inside(bounds.left, bounds.top)) {
     result.xSide = DraggableRect.LEFT;
     result.ySide = DraggableRect.TOP;
   } else if (circle.inside(bounds.left, bounds.bottom)) {
@@ skipping 64 matching lines @@
  * @param {number} initialScreenX X coordinate for cursor in the screen.
  * @param {number} initialScreenY Y coordinate for cursor in the screen.
  * @param {boolean} touch Whether the operation is done by touch or not.
  * @return {?function(number,number,boolean)} Drag handler that takes x
  *     coordinate value, y coordinate value, and shift key flag.
  */
 DraggableRect.prototype.getDragHandler = function(
     initialScreenX, initialScreenY, touch) {
   // Check if the initial coordinate is in the image rect.
   var boundsOnScreen = this.viewport_.getImageBoundsOnScreenClipped();
-  var handlerRadius = touch ? ImageEditor.Mode.Crop.TOUCH_GRAB_RADIUS :
-      ImageEditor.Mode.Crop.MOUSE_GRAB_RADIUS;
+  var handlerRadius = touch ? ImageEditorMode.Crop.TOUCH_GRAB_RADIUS :
+                              ImageEditorMode.Crop.MOUSE_GRAB_RADIUS;
   var draggableAreas = [
       boundsOnScreen,
       new Circle(boundsOnScreen.left, boundsOnScreen.top, handlerRadius),
       new Circle(boundsOnScreen.right, boundsOnScreen.top, handlerRadius),
       new Circle(boundsOnScreen.left, boundsOnScreen.bottom, handlerRadius),
       new Circle(boundsOnScreen.right, boundsOnScreen.bottom, handlerRadius)
   ];
 
   if (!draggableAreas.some(
       (area) => area.inside(initialScreenX, initialScreenY))) {
@@ skipping 182 matching lines @@
       break;
     case 'bottom':
       this.bounds_.bottom = this.bounds_.top + newHeight;
       break;
     case 'none':
       this.bounds_.top = middle - newHeight / 2;
       this.bounds_.bottom = middle + newHeight / 2;
       break;
   }
 };