Improved Pinch-Zoom for PDF

chrome/browser/resources/pdf/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.
 
 /**
  * Returns the height of the intersection of two rectangles.
  * @param {Object} rect1 the first rect
  * @param {Object} rect2 the second rect
  * @return {number} the height of the intersection of the rects
  */
@@ skipping 31 matching lines @@
   this.beforeZoomCallback_ = beforeZoomCallback;
   this.afterZoomCallback_ = afterZoomCallback;
   this.allowedToChangeZoom_ = false;
   this.zoom_ = 1;
   this.documentDimensions_ = null;
   this.pageDimensions_ = [];
   this.scrollbarWidth_ = scrollbarWidth;
   this.fittingType_ = Viewport.FittingType.NONE;
   this.defaultZoom_ = defaultZoom;
   this.topToolbarHeight_ = topToolbarHeight;
+  this.prevScale = 1;
+  this.doRender_ = true;
+  this.didPinch_ = false;
+  this.didPinchEnd_ = false;
 
   window.addEventListener('scroll', this.updateViewport_.bind(this));
   window.addEventListener('resize', this.resize_.bind(this));
 }
 
 /**
  * Enumeration of page fitting types.
  * @enum {string}
  */
 Viewport.FittingType = {
@@ skipping 101 matching lines @@
       this.sizer_.style.width = zoomedDimensions.width + 'px';
       this.sizer_.style.height = zoomedDimensions.height +
           this.topToolbarHeight_ + 'px';
     }
   },
 
   /**
    * @private
    * Called when the viewport should be updated.
    */
-  updateViewport_: function() {
-    this.viewportChangedCallback_();
-  },
+  updateViewport_: function() { this.viewportChangedCallback_(); },
 
   /**
    * @private
    * Called when the viewport size changes.
    */
   resize_: function() {
     if (this.fittingType_ == Viewport.FittingType.FIT_TO_PAGE)
       this.fitToPageInternal_(false);
     else if (this.fittingType_ == Viewport.FittingType.FIT_TO_WIDTH)
       this.fitToWidth();
@@ skipping 28 matching lines @@
     var scrollbarHeight = needsScrollbars.horizontal ? this.scrollbarWidth_ : 0;
     return {
       width: this.window_.innerWidth - scrollbarWidth,
       height: this.window_.innerHeight - scrollbarHeight
     };
   },
 
   /**
    * @type {number} the zoom level of the viewport.
    */
-  get zoom() {
-    return this.zoom_;
-  },
+  get zoom() { return this.zoom_; },
 
   /**
    * @private
    * Used to wrap a function that might perform zooming on the viewport. This is
    * required so that we can notify the plugin that zooming is in progress
    * so that while zooming is taking place it can stop reacting to scroll events
    * from the viewport. This is to avoid flickering.
    */
   mightZoom_: function(f) {
     this.beforeZoomCallback_();
     this.allowedToChangeZoom_ = true;
     f();
+    var needsScrollbars = this.documentNeedsScrollbars_(this.zoom_);
+    if (!needsScrollbars.horizontal) {
+      this.pinchCenter_ = {
+        x: this.window_.innerWidth / 2,
+        y: this.window_.innerHeight / 2
+      };
+    }
     this.allowedToChangeZoom_ = false;
     this.afterZoomCallback_();
   },
 
   /**
    * @private
    * Sets the zoom of the viewport.
    * @param {number} newZoom the zoom level to zoom to.
    */
   setZoomInternal_: function(newZoom) {
     if (!this.allowedToChangeZoom_) {
       throw 'Called Viewport.setZoomInternal_ without calling ' +
             'Viewport.mightZoom_.';
     }
     // Record the scroll position (relative to the top-left of the window).
     var currentScrollPos = {
       x: this.position.x / this.zoom_,
       y: this.position.y / this.zoom_
     };
     this.zoom_ = newZoom;
     this.contentSizeChanged_();
     // Scroll to the scaled scroll position.
     this.position = {
       x: currentScrollPos.x * newZoom,
       y: currentScrollPos.y * newZoom
     };
   },
 
   /**
+   * @private
+   * Sets the zoom of the viewport.
+   * Same function as below but for pinch zoom we have some more operations.
+   * @param {number} scaleDelta the zoom delta.
+   * @param {Object} center the pinch center in content coordinates
+   */
+  setPinchZoomInternal_: function(scaleDelta, center) {
+    if (!this.allowedToChangeZoom_) {
+      throw 'Called Viewport.setZoomInternal_ without calling ' +
+          'Viewport.mightZoom_.';
+    }
+    this.zoom_ = this.clampScale(this.zoom_ * scaleDelta);
+
+    var newCenterInContent = this.frameToContent(center);
+    var delta = {
+      x: (newCenterInContent.x - this.oldCenterInContent.x),
+      y: (newCenterInContent.y - this.oldCenterInContent.y)
+    };
+
+    // Record the scroll position (relative to the pinch center).
+    var currentScrollPos = {
+      x: this.position.x - delta.x * this.zoom_,
+      y: this.position.y - delta.y * this.zoom_
+    };
+
+    this.contentSizeChanged_();
+    // Scroll to the scaled scroll position.
+    this.position = {x: currentScrollPos.x, y: currentScrollPos.y};
+  },
+
+  /**
+   *  @private
+   *  Makes sure that the scale level doesn't get out of the limits.
+   *  @param {number} scale the new scale level
+   *  @return {number} the scale clamped in the limit
+   */
+  clampScale: function(scale) { return Math.min(5, Math.max(0.25, scale)); },
+
+  /**
+   *  @private
+   *  Gets the new center in content.
+   *  @param {Object} pinch center
+   *  @param {Object} zoom level
+   *  @return {Objet} the new center in content
+   */
+  frameToContent: function(framePoint) {
+    return {
+      x: (framePoint.x + this.position.x) / this.zoom_,
+      y: (framePoint.y + this.position.y) / this.zoom_
+    };
+  },
+
+  /**
    * Sets the zoom to the given zoom level.
    * @param {number} newZoom the zoom level to zoom to.
    */
   setZoom: function(newZoom) {
     this.fittingType_ = Viewport.FittingType.NONE;
     newZoom = Math.max(Viewport.ZOOM_FACTOR_RANGE.min,
                        Math.min(newZoom, Viewport.ZOOM_FACTOR_RANGE.max));
     this.mightZoom_(function() {
       this.setZoomInternal_(newZoom);
       this.updateViewport_();
     }.bind(this));
   },
 
   /**
    * @type {number} the width of scrollbars in the viewport in pixels.
    */
-  get scrollbarWidth() {
-    return this.scrollbarWidth_;
-  },
+  get scrollbarWidth() { return this.scrollbarWidth_; },
 
   /**
    * @type {Viewport.FittingType} the fitting type the viewport is currently in.
    */
-  get fittingType() {
-    return this.fittingType_;
-  },
+  get fittingType() { return this.fittingType_; },
 
   /**
    * @private
    * @param {integer} y the y-coordinate to get the page at.
    * @return {integer} the index of a page overlapping the given y-coordinate.
    */
   getPageAtY_: function(y) {
     var min = 0;
     var max = this.pageDimensions_.length - 1;
     while (max >= min) {
@@ skipping 145 matching lines @@
       this.setZoomInternal_(this.computeFittingZoom_(dimensions, false));
       if (scrollToTopOfPage) {
         this.position = {
           x: 0,
           y: this.pageDimensions_[page].y * this.zoom_
         };
       }
       this.updateViewport_();
     }.bind(this));
   },
+  /**
+   * @private
+   * Computes vector between two points.
+   * @param {Object} First Point
+   * @param {Object} Second Point
+   * @return {Object} The vector
+   */
+  vectorDelta: function(p1, p2) {
+    var vector = {
+      x: p2.x - p1.x,
+      y: p2.y - p1.y
+    };
+    return vector;
+  },
 
   /**
    * Zoom the viewport so that a page consumes the entire viewport. Also scrolls
    * the viewport to the top of the current page.
    */
-  fitToPage: function() {
-    this.fitToPageInternal_(true);
-  },
+  fitToPage: function() { this.fitToPageInternal_(true); },
 
   /**
    * Zoom out to the next predefined zoom level.
    */
   zoomOut: function() {
     this.mightZoom_(function() {
       this.fittingType_ = Viewport.FittingType.NONE;
       var nextZoom = Viewport.ZOOM_FACTORS[0];
       for (var i = 0; i < Viewport.ZOOM_FACTORS.length; i++) {
         if (Viewport.ZOOM_FACTORS[i] < this.zoom_)
@@ skipping 14 matching lines @@
       for (var i = Viewport.ZOOM_FACTORS.length - 1; i >= 0; i--) {
         if (Viewport.ZOOM_FACTORS[i] > this.zoom_)
           nextZoom = Viewport.ZOOM_FACTORS[i];
       }
       this.setZoomInternal_(nextZoom);
       this.updateViewport_();
     }.bind(this));
   },
 
   /**
+   * Pinch zoom event handler
+   * @param {ev} the pinch event
+   */
+  pinchZoom: function(ev) {
+    this.mightZoom_(function() {
+      // We render on pinchin in order to solve the invalid regions that appear
+      // after zooming out.
+      if (ev.additionalEvent == 'pinchin')
+        this.doRender_ = true;
+      else
+        this.doRender_ = false;
+
+      var scaleDelta = ev.scale / this.prevScale;
+      this.pinchPanVector_ = this.vectorDelta(ev.center, this.first_pinch_center_in_frame_);
+
+      var needsScrollbars = this.documentNeedsScrollbars_(
+          this.clampScale(this.zoom_ * scaleDelta));
+      // If there's no horizontal scrolling, keep the content centered so the
+      // user can't zoom in on the non-content area.
+      if (this.keepContentCentered_ && needsScrollbars.horizontal) {
+        this.oldCenterInContent =
+            this.frameToContent(this.frameToPluginCoordinate(ev.center));
+        this.keepContentCentered_ = false;
+      }
+
+      this.pinchCenter_ = ev.center;
+      this.setPinchZoomInternal_(scaleDelta, this.frameToPluginCoordinate(ev.center));
+      this.updateViewport_();
+      this.prevScale = ev.scale;
+    }.bind(this));
+  },
+
+  pinchZoomStart: function(ev) {
+    this.prevScale = 1;
+    this.oldCenterInContent =
+        this.frameToContent(this.frameToPluginCoordinate(ev.center));
+
+    var needsScrollbars = this.documentNeedsScrollbars_(this.zoom_);
+    if (!needsScrollbars.horizontal)
+      this.keepContentCentered_ = true;
+    else
+      this.keepContentCentered_ = false;
+    // We keep track of begining of the pinch.
+    // By doing so we will be able to compute the pan distance.
+    this.first_pinch_center_in_frame_ = ev.center;
+  },
+
+  pinchZoomEnd: function(ev) {
+    this.mightZoom_(function() {
+      // We want to render the document on pinch end
+      this.doRender_ = true;
+      var scaleDelta = ev.scale / this.prevScale;
+      this.pinchCenter_ = ev.center;
+
+      this.setPinchZoomInternal_(scaleDelta, this.frameToPluginCoordinate(ev.center));
+      this.updateViewport_();
+    }.bind(this));
+  },
+
+  frameToPluginCoordinate: function(coordinateInFrame) {
+    var container = $('plugin');
+    return {
+      x: coordinateInFrame.x - container.getBoundingClientRect().left,
+      y: coordinateInFrame.y - container.getBoundingClientRect().top
+    };
+  },
+
+  /**
    * Go to the given page index.
    * @param {number} page the index of the page to go to. zero-based.
    */
   goToPage: function(page) {
     this.mightZoom_(function() {
       if (this.pageDimensions_.length === 0)
         return;
       if (page < 0)
         page = 0;
       if (page >= this.pageDimensions_.length)
@@ skipping 78 matching lines @@
     spaceOnLeft = Math.max(spaceOnLeft, 0);
 
     return {
       x: x * this.zoom_ + spaceOnLeft - this.window_.pageXOffset,
       y: insetDimensions.y * this.zoom_ - this.window_.pageYOffset,
       width: insetDimensions.width * this.zoom_,
       height: insetDimensions.height * this.zoom_
     };
   }
 };