Synchronize functionality for all types of IEventData

Add AbstractRenderInfo for convenient work with GraphicsState.

DEVSIX-1406

Author: pavel-alay

kernel/src/main/java/com/itextpdf/kernel/pdf/canvas/parser/IXObjectDoHandler.java

@@ -43,11 +43,12 @@ This file is part of the iText (R) project.
  */
 package com.itextpdf.kernel.pdf.canvas.parser;
 
+import com.itextpdf.kernel.pdf.PdfName;
 import com.itextpdf.kernel.pdf.PdfStream;
+import com.itextpdf.kernel.pdf.canvas.CanvasTag;
+
+import java.util.Stack;
 
-/**
- * @author Kevin Day
- */
 public interface IXObjectDoHandler {
-    void handleXObject(PdfCanvasProcessor processor, PdfStream stream);
+    void handleXObject(PdfCanvasProcessor processor, Stack<CanvasTag> canvasTagHierarchy, PdfStream stream, PdfName xObjectName);
 }

kernel/src/main/java/com/itextpdf/kernel/pdf/canvas/parser/PdfCanvasProcessor.java

@@ -76,6 +76,7 @@ This file is part of the iText (R) project.
 import com.itextpdf.kernel.pdf.PdfString;
 import com.itextpdf.kernel.pdf.canvas.CanvasTag;
 import com.itextpdf.kernel.pdf.canvas.PdfCanvasConstants;
+import com.itextpdf.kernel.pdf.canvas.parser.data.AbstractRenderInfo;
 import com.itextpdf.kernel.pdf.canvas.parser.data.ClippingPathInfo;
 import com.itextpdf.kernel.pdf.canvas.parser.data.IEventData;
 import com.itextpdf.kernel.pdf.canvas.parser.data.ImageRenderInfo;
@@ -297,7 +298,7 @@ public void processContent(byte[] contentBytes, PdfResources resources) {
     public void processPageContent(PdfPage page) {
         initClippingPath(page);
         ParserGraphicsState gs = getGraphicsState();
-        eventOccurred(new ClippingPathInfo(gs.getClippingPath(), gs.getCtm()), EventType.CLIP_PATH_CHANGED);
+        eventOccurred(new ClippingPathInfo(gs, gs.getClippingPath(), gs.getCtm()), EventType.CLIP_PATH_CHANGED);
         processContent(page.getContentBytes(), page.getResources());
     }
 
@@ -425,14 +426,14 @@ protected void populateOperators() {
      *                  In case it isn't applicable pass any <CODE>byte</CODE> value.
      */
     protected void paintPath(int operation, int rule) {
-        PathRenderInfo renderInfo = new PathRenderInfo(currentPath, operation, rule, isClip, clippingRule, getGraphicsState());
+        ParserGraphicsState gs = getGraphicsState();
+        PathRenderInfo renderInfo = new PathRenderInfo(this.markedContentStack, gs, currentPath, operation, rule, isClip, clippingRule);
         eventOccurred(renderInfo, EventType.RENDER_PATH);
 
         if (isClip) {
             isClip = false;
-            ParserGraphicsState gs = getGraphicsState();
             gs.clip(currentPath, clippingRule);
-            eventOccurred(new ClippingPathInfo(gs.getClippingPath(), gs.getCtm()), EventType.CLIP_PATH_CHANGED);
+            eventOccurred(new ClippingPathInfo(gs, gs.getClippingPath(), gs.getCtm()), EventType.CLIP_PATH_CHANGED);
         }
 
         currentPath = new Path();
@@ -532,10 +533,8 @@ protected void eventOccurred(IEventData data, EventType type) {
         if (supportedEvents == null || supportedEvents.contains(type)) {
             eventListener.eventOccurred(data, type);
         }
-        if (data instanceof TextRenderInfo) {
-            ((TextRenderInfo) data).releaseGraphicsState();
-        } else if (data instanceof PathRenderInfo) {
-            ((PathRenderInfo) data).releaseGraphicsState();
+        if (data instanceof AbstractRenderInfo) {
+            ((AbstractRenderInfo) data).releaseGraphicsState();
         }
     }
 
@@ -553,23 +552,24 @@ private void displayPdfString(PdfString string) {
     /**
      * Displays an XObject using the registered handler for this XObject's subtype
      *
-     * @param xobjectName the name of the XObject to retrieve from the resource dictionary
+     * @param resourceName the name of the XObject to retrieve from the resource dictionary
      */
-    private void displayXObject(PdfName xobjectName) {
-        PdfStream xobjectStream = getXObjectStream(xobjectName);
+    private void displayXObject(PdfName resourceName) {
+        PdfStream xobjectStream = getXObjectStream(resourceName);
         PdfName subType = xobjectStream.getAsName(PdfName.Subtype);
         IXObjectDoHandler handler = xobjectDoHandlers.get(subType);
 
         if (handler == null) {
             handler = xobjectDoHandlers.get(PdfName.Default);
         }
 
-        handler.handleXObject(this, xobjectStream);
+        handler.handleXObject(this, this.markedContentStack, xobjectStream, resourceName);
     }
 
-    private void displayImage(PdfStream imageStream, boolean isInline) {
+    private void displayImage(Stack<CanvasTag> canvasTagHierarchy, PdfStream imageStream, PdfName resourceName, boolean isInline) {
         PdfDictionary colorSpaceDic = getResources().getResource(PdfName.ColorSpace);
-        ImageRenderInfo renderInfo = new ImageRenderInfo(getGraphicsState().getCtm(), imageStream, colorSpaceDic, isInline);
+        ImageRenderInfo renderInfo = new ImageRenderInfo(canvasTagHierarchy, getGraphicsState(), getGraphicsState().getCtm(),
+                imageStream, resourceName, colorSpaceDic, isInline);
         eventOccurred(renderInfo, EventType.RENDER_IMAGE);
     }
 
@@ -1054,7 +1054,7 @@ protected static class PopGraphicsStateOperator implements IContentOperator {
         public void invoke(PdfCanvasProcessor processor, PdfLiteral operator, List<PdfObject> operands) {
             processor.gsStack.pop();
             ParserGraphicsState gs = processor.getGraphicsState();
-            processor.eventOccurred(new ClippingPathInfo(gs.getClippingPath(), gs.getCtm()), EventType.CLIP_PATH_CHANGED);
+            processor.eventOccurred(new ClippingPathInfo(gs, gs.getClippingPath(), gs.getCtm()), EventType.CLIP_PATH_CHANGED);
         }
     }
 
@@ -1281,8 +1281,8 @@ private static class DoOperator implements IContentOperator {
          * {@inheritDoc}
          */
         public void invoke(PdfCanvasProcessor processor, PdfLiteral operator, List<PdfObject> operands) {
-            PdfName xobjectName = (PdfName) operands.get(0);
-            processor.displayXObject(xobjectName);
+            PdfName resourceName = (PdfName) operands.get(0);
+            processor.displayXObject(resourceName);
         }
     }
 
@@ -1298,7 +1298,7 @@ private static class EndImageOperator implements IContentOperator {
          */
         public void invoke(PdfCanvasProcessor processor, PdfLiteral operator, List<PdfObject> operands) {
             PdfStream imageStream = (PdfStream) operands.get(0);
-            processor.displayImage(imageStream, true);
+            processor.displayImage(processor.markedContentStack, imageStream, null, true);
         }
     }
 
@@ -1374,9 +1374,10 @@ public void invoke(PdfCanvasProcessor processor, PdfLiteral oper, List<PdfObject
      * An XObject subtype handler for FORM
      */
     private static class FormXObjectDoHandler implements IXObjectDoHandler {
-        public void handleXObject(PdfCanvasProcessor processor, PdfStream stream) {
 
-            PdfDictionary resourcesDic = stream.getAsDictionary(PdfName.Resources);
+        public void handleXObject(PdfCanvasProcessor processor, Stack<CanvasTag> canvasTagHierarchy, PdfStream xObjectStream, PdfName xObjectName) {
+
+            PdfDictionary resourcesDic = xObjectStream.getAsDictionary(PdfName.Resources);
             PdfResources resources;
             if (resourcesDic == null) {
                 resources = processor.getResources();
@@ -1388,8 +1389,8 @@ public void handleXObject(PdfCanvasProcessor processor, PdfStream stream) {
             // this is probably not necessary (if we fail on this, probably the entire content stream processing
             // operation should be rejected
             byte[] contentBytes;
-            contentBytes = stream.getBytes();
-            final PdfArray matrix = stream.getAsArray(PdfName.Matrix);
+            contentBytes = xObjectStream.getBytes();
+            final PdfArray matrix = xObjectStream.getAsArray(PdfName.Matrix);
 
             new PushGraphicsStateOperator().invoke(processor, null, null);
 
@@ -1407,26 +1408,24 @@ public void handleXObject(PdfCanvasProcessor processor, PdfStream stream) {
             processor.processContent(contentBytes, resources);
 
             new PopGraphicsStateOperator().invoke(processor, null, null);
-
         }
-
     }
 
     /**
      * An XObject subtype handler for IMAGE
      */
     private static class ImageXObjectDoHandler implements IXObjectDoHandler {
 
-        public void handleXObject(PdfCanvasProcessor processor, PdfStream xobjectStream) {
-            processor.displayImage(xobjectStream, false);
+        public void handleXObject(PdfCanvasProcessor processor, Stack<CanvasTag> canvasTagHierarchy, PdfStream xObjectStream, PdfName resourceName) {
+            processor.displayImage(canvasTagHierarchy, xObjectStream, resourceName,false);
         }
     }
 
     /**
      * An XObject subtype handler that does nothing
      */
     private static class IgnoreXObjectDoHandler implements IXObjectDoHandler {
-        public void handleXObject(PdfCanvasProcessor processor, PdfStream xobjectStream) {
+        public void handleXObject(PdfCanvasProcessor processor, Stack<CanvasTag> canvasTagHierarchy, PdfStream xObjectStream, PdfName xObjectName) {
             // ignore XObject subtype
         }
     }

kernel/src/main/java/com/itextpdf/kernel/pdf/canvas/parser/data/AbstractRenderInfo.java

@@ -0,0 +1,44 @@
+package com.itextpdf.kernel.pdf.canvas.parser.data;
+
+import com.itextpdf.io.LogMessageConstant;
+import com.itextpdf.kernel.pdf.canvas.CanvasGraphicsState;
+
+public class AbstractRenderInfo implements IEventData {
+
+    protected CanvasGraphicsState gs;
+    private boolean graphicsStateIsPreserved;
+
+    public AbstractRenderInfo(CanvasGraphicsState gs) {
+        this.gs = gs;
+    }
+
+    @Override
+    public CanvasGraphicsState getGraphicsState() {
+        checkGraphicsState();
+        return graphicsStateIsPreserved ? gs : new CanvasGraphicsState(gs);
+    }
+
+    public boolean isGraphicsStatePreserved() {
+        return graphicsStateIsPreserved;
+    }
+
+    public void preserveGraphicsState() {
+        checkGraphicsState();
+        this.graphicsStateIsPreserved = true;
+        gs = new CanvasGraphicsState(gs);
+    }
+
+    public void releaseGraphicsState() {
+        if (!graphicsStateIsPreserved) {
+            gs = null;
+        }
+    }
+
+
+    // check if graphics state was released
+    protected void checkGraphicsState() {
+        if (null == gs) {
+            throw new IllegalStateException(LogMessageConstant.GRAPHICS_STATE_WAS_DELETED);
+        }
+    }
+}

kernel/src/main/java/com/itextpdf/kernel/pdf/canvas/parser/data/ClippingPathInfo.java

@@ -45,16 +45,18 @@ This file is part of the iText (R) project.
 
 import com.itextpdf.kernel.geom.Matrix;
 import com.itextpdf.kernel.geom.Path;
+import com.itextpdf.kernel.pdf.canvas.CanvasGraphicsState;
 
-public class ClippingPathInfo implements IEventData {
+public class ClippingPathInfo extends AbstractRenderInfo {
     private Path path;
     private Matrix ctm;
 
     /**
      * @param path The path to be rendered.
      * @param ctm  The path to be rendered.
      */
-    public ClippingPathInfo(Path path, Matrix ctm) {
+    public ClippingPathInfo(CanvasGraphicsState gs, Path path, Matrix ctm) {
+        super(gs);
         this.path = path;
         this.ctm = ctm;
     }

kernel/src/main/java/com/itextpdf/kernel/pdf/canvas/parser/data/IEventData.java

@@ -43,9 +43,12 @@ This file is part of the iText (R) project.
  */
 package com.itextpdf.kernel.pdf.canvas.parser.data;
 
+import com.itextpdf.kernel.pdf.canvas.CanvasGraphicsState;
+
 /**
  * Marker interface for the set of classes used to combine
  * parameters required for different types of events.
  */
 public interface IEventData {
+    CanvasGraphicsState getGraphicsState();
 }