pdfjs-dist 2.0.550 → 2.3.200

package/lib/display/pattern_helper.js

@@ -2,7 +2,7 @@
  * @licstart The following is the entire license notice for the
  * Javascript code in this page
  *
- * Copyright 2017 Mozilla Foundation
+ * Copyright 2019 Mozilla Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,42 +19,62 @@
  * @licend The above is the entire license notice for the
  * Javascript code in this page
  */
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.TilingPattern = exports.getShadingPatternFromIR = undefined;
+exports.getShadingPatternFromIR = getShadingPatternFromIR;
+exports.TilingPattern = void 0;
 
-var _util = require('../shared/util');
+var _util = require("../shared/util");
 
 var ShadingIRs = {};
+
+function applyBoundingBox(ctx, bbox) {
+  if (!bbox || typeof Path2D === 'undefined') {
+    return;
+  }
+
+  var width = bbox[2] - bbox[0];
+  var height = bbox[3] - bbox[1];
+  var region = new Path2D();
+  region.rect(bbox[0], bbox[1], width, height);
+  ctx.clip(region);
+}
+
 ShadingIRs.RadialAxial = {
   fromIR: function RadialAxial_fromIR(raw) {
     var type = raw[1];
-    var colorStops = raw[2];
-    var p0 = raw[3];
-    var p1 = raw[4];
-    var r0 = raw[5];
-    var r1 = raw[6];
+    var bbox = raw[2];
+    var colorStops = raw[3];
+    var p0 = raw[4];
+    var p1 = raw[5];
+    var r0 = raw[6];
+    var r1 = raw[7];
     return {
       type: 'Pattern',
       getPattern: function RadialAxial_getPattern(ctx) {
+        applyBoundingBox(ctx, bbox);
         var grad;
+
         if (type === 'axial') {
           grad = ctx.createLinearGradient(p0[0], p0[1], p1[0], p1[1]);
         } else if (type === 'radial') {
           grad = ctx.createRadialGradient(p0[0], p0[1], r0, p1[0], p1[1], r1);
         }
+
         for (var i = 0, ii = colorStops.length; i < ii; ++i) {
           var c = colorStops[i];
           grad.addColorStop(c[0], c[1]);
         }
+
         return grad;
       }
     };
   }
 };
+
 var createMeshCanvas = function createMeshCanvasClosure() {
   function drawTriangle(data, context, p1, p2, p3, c1, c2, c3) {
     var coords = context.coords,
@@ -62,6 +82,7 @@ var createMeshCanvas = function createMeshCanvasClosure() {
     var bytes = data.data,
         rowSize = data.width * 4;
     var tmp;
+
     if (coords[p1 + 1] > coords[p2 + 1]) {
       tmp = p1;
       p1 = p2;
@@ -70,6 +91,7 @@ var createMeshCanvas = function createMeshCanvasClosure() {
       c1 = c2;
       c2 = tmp;
     }
+
     if (coords[p2 + 1] > coords[p3 + 1]) {
       tmp = p2;
       p2 = p3;
@@ -78,6 +100,7 @@ var createMeshCanvas = function createMeshCanvasClosure() {
       c2 = c3;
       c3 = tmp;
     }
+
     if (coords[p1 + 1] > coords[p2 + 1]) {
       tmp = p1;
       p1 = p2;
@@ -86,15 +109,18 @@ var createMeshCanvas = function createMeshCanvasClosure() {
       c1 = c2;
       c2 = tmp;
     }
+
     var x1 = (coords[p1] + context.offsetX) * context.scaleX;
     var y1 = (coords[p1 + 1] + context.offsetY) * context.scaleY;
     var x2 = (coords[p2] + context.offsetX) * context.scaleX;
     var y2 = (coords[p2 + 1] + context.offsetY) * context.scaleY;
     var x3 = (coords[p3] + context.offsetX) * context.scaleX;
     var y3 = (coords[p3 + 1] + context.offsetY) * context.scaleY;
+
     if (y1 >= y3) {
       return;
     }
+
     var c1r = colors[c1],
         c1g = colors[c1 + 1],
         c1b = colors[c1 + 2];
@@ -109,6 +135,7 @@ var createMeshCanvas = function createMeshCanvasClosure() {
     var xa, car, cag, cab;
     var xb, cbr, cbg, cbb;
     var k;
+
     for (var y = minY; y <= maxY; y++) {
       if (y < y2) {
         k = y < y1 ? 0 : y1 === y2 ? 1 : (y1 - y) / (y1 - y2);
@@ -123,6 +150,7 @@ var createMeshCanvas = function createMeshCanvasClosure() {
         cag = c2g - (c2g - c3g) * k;
         cab = c2b - (c2b - c3b) * k;
       }
+
       k = y < y1 ? 0 : y > y3 ? 1 : (y1 - y) / (y1 - y3);
       xb = x1 - (x1 - x3) * k;
       cbr = c1r - (c1r - c3r) * k;
@@ -131,6 +159,7 @@ var createMeshCanvas = function createMeshCanvasClosure() {
       var x1_ = Math.round(Math.min(xa, xb));
       var x2_ = Math.round(Math.max(xa, xb));
       var j = rowSize * y + x1_ * 4;
+
       for (var x = x1_; x <= x2_; x++) {
         k = (xa - x) / (xa - xb);
         k = k < 0 ? 0 : k > 1 ? 1 : k;
@@ -141,32 +170,41 @@ var createMeshCanvas = function createMeshCanvasClosure() {
       }
     }
   }
+
   function drawFigure(data, figure, context) {
     var ps = figure.coords;
     var cs = figure.colors;
     var i, ii;
+
     switch (figure.type) {
       case 'lattice':
         var verticesPerRow = figure.verticesPerRow;
         var rows = Math.floor(ps.length / verticesPerRow) - 1;
         var cols = verticesPerRow - 1;
+
         for (i = 0; i < rows; i++) {
           var q = i * verticesPerRow;
+
           for (var j = 0; j < cols; j++, q++) {
             drawTriangle(data, context, ps[q], ps[q + 1], ps[q + verticesPerRow], cs[q], cs[q + 1], cs[q + verticesPerRow]);
             drawTriangle(data, context, ps[q + verticesPerRow + 1], ps[q + 1], ps[q + verticesPerRow], cs[q + verticesPerRow + 1], cs[q + 1], cs[q + verticesPerRow]);
           }
         }
+
         break;
+
       case 'triangles':
         for (i = 0, ii = ps.length; i < ii; i += 3) {
           drawTriangle(data, context, ps[i], ps[i + 1], ps[i + 2], cs[i], cs[i + 1], cs[i + 2]);
         }
+
         break;
+
       default:
         throw new Error('illegal figure');
     }
   }
+
   function createMeshCanvas(bounds, combinesScale, coords, colors, figures, backgroundColor, cachedCanvases, webGLContext) {
     var EXPECTED_SCALE = 1.1;
     var MAX_PATTERN_SIZE = 3000;
@@ -190,6 +228,7 @@ var createMeshCanvas = function createMeshCanvasClosure() {
     var paddedWidth = width + BORDER_SIZE * 2;
     var paddedHeight = height + BORDER_SIZE * 2;
     var canvas, tmpCanvas, i, ii;
+
     if (webGLContext.isEnabled) {
       canvas = webGLContext.drawFigures({
         width: width,
@@ -205,8 +244,10 @@ var createMeshCanvas = function createMeshCanvasClosure() {
       tmpCanvas = cachedCanvases.getCanvas('mesh', paddedWidth, paddedHeight, false);
       var tmpCtx = tmpCanvas.context;
       var data = tmpCtx.createImageData(width, height);
+
       if (backgroundColor) {
         var bytes = data.data;
+
         for (i = 0, ii = bytes.length; i < ii; i += 4) {
           bytes[i] = backgroundColor[0];
           bytes[i + 1] = backgroundColor[1];
@@ -214,12 +255,15 @@ var createMeshCanvas = function createMeshCanvasClosure() {
           bytes[i + 3] = 255;
         }
       }
+
       for (i = 0; i < figures.length; i++) {
         drawFigure(data, figures[i], context);
       }
+
       tmpCtx.putImageData(data, BORDER_SIZE, BORDER_SIZE);
       canvas = tmpCanvas.canvas;
     }
+
     return {
       canvas: canvas,
       offsetX: offsetX - BORDER_SIZE * scaleX,
@@ -228,8 +272,10 @@ var createMeshCanvas = function createMeshCanvasClosure() {
       scaleY: scaleY
     };
   }
+
   return createMeshCanvas;
 }();
+
 ShadingIRs.Mesh = {
   fromIR: function Mesh_fromIR(raw) {
     var coords = raw[2];
@@ -237,27 +283,36 @@ ShadingIRs.Mesh = {
     var figures = raw[4];
     var bounds = raw[5];
     var matrix = raw[6];
+    var bbox = raw[7];
     var background = raw[8];
     return {
       type: 'Pattern',
       getPattern: function Mesh_getPattern(ctx, owner, shadingFill) {
+        applyBoundingBox(ctx, bbox);
         var scale;
+
         if (shadingFill) {
           scale = _util.Util.singularValueDecompose2dScale(ctx.mozCurrentTransform);
         } else {
           scale = _util.Util.singularValueDecompose2dScale(owner.baseTransform);
+
           if (matrix) {
             var matrixScale = _util.Util.singularValueDecompose2dScale(matrix);
+
             scale = [scale[0] * matrixScale[0], scale[1] * matrixScale[1]];
           }
         }
+
         var temporaryPatternCanvas = createMeshCanvas(bounds, scale, coords, colors, figures, shadingFill ? null : background, owner.cachedCanvases, owner.webGLContext);
+
         if (!shadingFill) {
           ctx.setTransform.apply(ctx, owner.baseTransform);
+
           if (matrix) {
             ctx.transform.apply(ctx, matrix);
           }
         }
+
         ctx.translate(temporaryPatternCanvas.offsetX, temporaryPatternCanvas.offsetY);
         ctx.scale(temporaryPatternCanvas.scaleX, temporaryPatternCanvas.scaleY);
         return ctx.createPattern(temporaryPatternCanvas.canvas, 'no-repeat');
@@ -275,19 +330,24 @@ ShadingIRs.Dummy = {
     };
   }
 };
+
 function getShadingPatternFromIR(raw) {
   var shadingIR = ShadingIRs[raw[0]];
+
   if (!shadingIR) {
-    throw new Error('Unknown IR type: ' + raw[0]);
+    throw new Error("Unknown IR type: ".concat(raw[0]));
   }
+
   return shadingIR.fromIR(raw);
 }
+
 var TilingPattern = function TilingPatternClosure() {
   var PaintType = {
     COLORED: 1,
     UNCOLORED: 2
   };
   var MAX_PATTERN_SIZE = 3000;
+
   function TilingPattern(IR, color, ctx, canvasGraphicsFactory, baseTransform) {
     this.operatorList = IR[2];
     this.matrix = IR[3] || [1, 0, 0, 1, 0, 0];
@@ -302,6 +362,7 @@ var TilingPattern = function TilingPatternClosure() {
     this.type = 'Pattern';
     this.ctx = ctx;
   }
+
   TilingPattern.prototype = {
     createPatternCanvas: function TilinPattern_createPatternCanvas(owner) {
       var operatorList = this.operatorList;
@@ -317,39 +378,42 @@ var TilingPattern = function TilingPatternClosure() {
           y0 = bbox[1],
           x1 = bbox[2],
           y1 = bbox[3];
-      var topLeft = [x0, y0];
-      var botRight = [x0 + xstep, y0 + ystep];
-      var width = botRight[0] - topLeft[0];
-      var height = botRight[1] - topLeft[1];
+
       var matrixScale = _util.Util.singularValueDecompose2dScale(this.matrix);
+
       var curMatrixScale = _util.Util.singularValueDecompose2dScale(this.baseTransform);
+
       var combinedScale = [matrixScale[0] * curMatrixScale[0], matrixScale[1] * curMatrixScale[1]];
-      width = Math.min(Math.ceil(Math.abs(width * combinedScale[0])), MAX_PATTERN_SIZE);
-      height = Math.min(Math.ceil(Math.abs(height * combinedScale[1])), MAX_PATTERN_SIZE);
-      var tmpCanvas = owner.cachedCanvases.getCanvas('pattern', width, height, true);
+      var dimx = this.getSizeAndScale(xstep, this.ctx.canvas.width, combinedScale[0]);
+      var dimy = this.getSizeAndScale(ystep, this.ctx.canvas.height, combinedScale[1]);
+      var tmpCanvas = owner.cachedCanvases.getCanvas('pattern', dimx.size, dimy.size, true);
       var tmpCtx = tmpCanvas.context;
       var graphics = canvasGraphicsFactory.createCanvasGraphics(tmpCtx);
       graphics.groupLevel = owner.groupLevel;
       this.setFillAndStrokeStyleToContext(graphics, paintType, color);
-      this.setScale(width, height, xstep, ystep);
-      this.transformToScale(graphics);
-      var tmpTranslate = [1, 0, 0, 1, -topLeft[0], -topLeft[1]];
-      graphics.transform.apply(graphics, tmpTranslate);
+      graphics.transform(dimx.scale, 0, 0, dimy.scale, 0, 0);
+      graphics.transform(1, 0, 0, 1, -x0, -y0);
       this.clipBbox(graphics, bbox, x0, y0, x1, y1);
       graphics.executeOperatorList(operatorList);
+      this.ctx.transform(1, 0, 0, 1, x0, y0);
+      this.ctx.scale(1 / dimx.scale, 1 / dimy.scale);
       return tmpCanvas.canvas;
     },
-    setScale: function TilingPattern_setScale(width, height, xstep, ystep) {
-      this.scale = [width / xstep, height / ystep];
-    },
-    transformToScale: function TilingPattern_transformToScale(graphics) {
-      var scale = this.scale;
-      var tmpScale = [scale[0], 0, 0, scale[1], 0, 0];
-      graphics.transform.apply(graphics, tmpScale);
-    },
-    scaleToContext: function TilingPattern_scaleToContext() {
-      var scale = this.scale;
-      this.ctx.scale(1 / scale[0], 1 / scale[1]);
+    getSizeAndScale: function TilingPattern_getSizeAndScale(step, realOutputSize, scale) {
+      step = Math.abs(step);
+      var maxSize = Math.max(MAX_PATTERN_SIZE, realOutputSize);
+      var size = Math.ceil(step * scale);
+
+      if (size >= maxSize) {
+        size = maxSize;
+      } else {
+        scale = size / step;
+      }
+
+      return {
+        scale: scale,
+        size: size
+      };
     },
     clipBbox: function clipBbox(graphics, bbox, x0, y0, x1, y1) {
       if (Array.isArray(bbox) && bbox.length === 4) {
@@ -363,6 +427,7 @@ var TilingPattern = function TilingPatternClosure() {
     setFillAndStrokeStyleToContext: function setFillAndStrokeStyleToContext(graphics, paintType, color) {
       var context = graphics.ctx,
           current = graphics.current;
+
       switch (paintType) {
         case PaintType.COLORED:
           var ctx = this.ctx;
@@ -371,27 +436,29 @@ var TilingPattern = function TilingPatternClosure() {
           current.fillColor = ctx.fillStyle;
           current.strokeColor = ctx.strokeStyle;
           break;
+
         case PaintType.UNCOLORED:
           var cssColor = _util.Util.makeCssRgb(color[0], color[1], color[2]);
+
           context.fillStyle = cssColor;
           context.strokeStyle = cssColor;
           current.fillColor = cssColor;
           current.strokeColor = cssColor;
           break;
+
         default:
-          throw new _util.FormatError('Unsupported paint type: ' + paintType);
+          throw new _util.FormatError("Unsupported paint type: ".concat(paintType));
       }
     },
     getPattern: function TilingPattern_getPattern(ctx, owner) {
-      var temporaryPatternCanvas = this.createPatternCanvas(owner);
       ctx = this.ctx;
       ctx.setTransform.apply(ctx, this.baseTransform);
       ctx.transform.apply(ctx, this.matrix);
-      this.scaleToContext();
+      var temporaryPatternCanvas = this.createPatternCanvas(owner);
       return ctx.createPattern(temporaryPatternCanvas, 'repeat');
     }
   };
   return TilingPattern;
 }();
-exports.getShadingPatternFromIR = getShadingPatternFromIR;
+
 exports.TilingPattern = TilingPattern;