Bug 60656 - EMF image support in slideshows

git-svn-id: https://svn.apache.org/repos/asf/poi/trunk@1859159 13f79535-47bb-0310-9956-ffa450edef68

src/scratchpad/src/org/apache/poi/hemf/record/emfplus/HemfPlusBrush.java

@@ -0,0 +1,480 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+==================================================================== */
+
+package org.apache.poi.hemf.record.emfplus;
+
+import static org.apache.poi.hemf.record.emf.HemfFill.readXForm;
+import static org.apache.poi.hemf.record.emfplus.HemfPlusDraw.readARGB;
+import static org.apache.poi.hemf.record.emfplus.HemfPlusDraw.readPointF;
+import static org.apache.poi.hemf.record.emfplus.HemfPlusDraw.readRectF;
+
+import java.awt.Color;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.Point2D;
+import java.awt.geom.Rectangle2D;
+import java.io.IOException;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+import org.apache.poi.hemf.record.emfplus.HemfPlusHeader.EmfPlusGraphicsVersion;
+import org.apache.poi.hemf.record.emfplus.HemfPlusImage.EmfPlusImage;
+import org.apache.poi.hemf.record.emfplus.HemfPlusImage.EmfPlusWrapMode;
+import org.apache.poi.hemf.record.emfplus.HemfPlusObject.EmfPlusObjectData;
+import org.apache.poi.hemf.record.emfplus.HemfPlusObject.EmfPlusObjectType;
+import org.apache.poi.hemf.record.emfplus.HemfPlusPath.EmfPlusPath;
+import org.apache.poi.util.BitField;
+import org.apache.poi.util.BitFieldFactory;
+import org.apache.poi.util.LittleEndianConsts;
+import org.apache.poi.util.LittleEndianInputStream;
+
+public class HemfPlusBrush {
+    /** The BrushType enumeration defines types of graphics brushes, which are used to fill graphics regions. */
+    public enum EmfPlusBrushType {
+        SOLID_COLOR(0X00000000, EmfPlusSolidBrushData::new),
+        HATCH_FILL(0X00000001, EmfPlusHatchBrushData::new),
+        TEXTURE_FILL(0X00000002, EmfPlusTextureBrushData::new),
+        PATH_GRADIENT(0X00000003, EmfPlusPathGradientBrushData::new),
+        LINEAR_GRADIENT(0X00000004, EmfPlusLinearGradientBrushData::new)
+        ;
+
+        public final int id;
+        public final Supplier<? extends EmfPlusBrushData> constructor;
+
+        EmfPlusBrushType(int id, Supplier<? extends EmfPlusBrushData> constructor) {
+            this.id = id;
+            this.constructor = constructor;
+        }
+
+        public static EmfPlusBrushType valueOf(int id) {
+            for (EmfPlusBrushType wrt : values()) {
+                if (wrt.id == id) return wrt;
+            }
+            return null;
+        }
+    }
+
+    public enum EmfPlusHatchStyle {
+        HORIZONTAL(0X00000000),
+        VERTICAL(0X00000001),
+        FORWARD_DIAGONAL(0X00000002),
+        BACKWARD_DIAGONAL(0X00000003),
+        LARGE_GRID(0X00000004),
+        DIAGONAL_CROSS(0X00000005),
+        PERCENT_05(0X00000006),
+        PERCENT_10(0X00000007),
+        PERCENT_20(0X00000008),
+        PERCENT_25(0X00000009),
+        PERCENT_30(0X0000000A),
+        PERCENT_40(0X0000000B),
+        PERCENT_50(0X0000000C),
+        PERCENT_60(0X0000000D),
+        PERCENT_70(0X0000000E),
+        PERCENT_75(0X0000000F),
+        PERCENT_80(0X00000010),
+        PERCENT_90(0X00000011),
+        LIGHT_DOWNWARD_DIAGONAL(0X00000012),
+        LIGHT_UPWARD_DIAGONAL(0X00000013),
+        DARK_DOWNWARD_DIAGONAL(0X00000014),
+        DARK_UPWARD_DIAGONAL(0X00000015),
+        WIDE_DOWNWARD_DIAGONAL(0X00000016),
+        WIDE_UPWARD_DIAGONAL(0X00000017),
+        LIGHT_VERTICAL(0X00000018),
+        LIGHT_HORIZONTAL(0X00000019),
+        NARROW_VERTICAL(0X0000001A),
+        NARROW_HORIZONTAL(0X0000001B),
+        DARK_VERTICAL(0X0000001C),
+        DARK_HORIZONTAL(0X0000001D),
+        DASHED_DOWNWARD_DIAGONAL(0X0000001E),
+        DASHED_UPWARD_DIAGONAL(0X0000001F),
+        DASHED_HORIZONTAL(0X00000020),
+        DASHED_VERTICAL(0X00000021),
+        SMALL_CONFETTI(0X00000022),
+        LARGE_CONFETTI(0X00000023),
+        ZIGZAG(0X00000024),
+        WAVE(0X00000025),
+        DIAGONAL_BRICK(0X00000026),
+        HORIZONTAL_BRICK(0X00000027),
+        WEAVE(0X00000028),
+        PLAID(0X00000029),
+        DIVOT(0X0000002A),
+        DOTTED_GRID(0X0000002B),
+        DOTTED_DIAMOND(0X0000002C),
+        SHINGLE(0X0000002D),
+        TRELLIS(0X0000002E),
+        SPHERE(0X0000002F),
+        SMALL_GRID(0X00000030),
+        SMALL_CHECKER_BOARD(0X00000031),
+        LARGE_CHECKER_BOARD(0X00000032),
+        OUTLINED_DIAMOND(0X00000033),
+        SOLID_DIAMOND(0X00000034)
+        ;
+
+
+        public final int id;
+
+        EmfPlusHatchStyle(int id) {
+            this.id = id;
+        }
+
+        public static EmfPlusHatchStyle valueOf(int id) {
+            for (EmfPlusHatchStyle wrt : values()) {
+                if (wrt.id == id) return wrt;
+            }
+            return null;
+        }
+
+    }
+
+    public interface EmfPlusBrushData {
+        /**
+         * This flag is meaningful in EmfPlusPathGradientBrushData objects.
+         *
+         * If set, an EmfPlusBoundaryPathData object MUST be specified in the BoundaryData field of the brush data object.
+         * If clear, an EmfPlusBoundaryPointData object MUST be specified in the BoundaryData field of the brush data object.
+         */
+        BitField PATH = BitFieldFactory.getInstance(0x00000001);
+
+        /**
+         * This flag is meaningful in EmfPlusLinearGradientBrushData objects , EmfPlusPathGradientBrushData objects,
+         * and EmfPlusTextureBrushData objects.
+         *
+         * If set, a 2x3 world space to device space transform matrix MUST be specified in the OptionalData field of
+         * the brush data object.
+         */
+        BitField TRANSFORM = BitFieldFactory.getInstance(0x00000002);
+
+        /**
+         * This flag is meaningful in EmfPlusLinearGradientBrushData and EmfPlusPathGradientBrushData objects.
+         *
+         * If set, an EmfPlusBlendColors object MUST be specified in the OptionalData field of the brush data object.
+         */
+        BitField PRESET_COLORS = BitFieldFactory.getInstance(0x00000004);
+
+        /**
+         * This flag is meaningful in EmfPlusLinearGradientBrushData and EmfPlusPathGradientBrushData objects.
+         *
+         * If set, an EmfPlusBlendFactors object that specifies a blend pattern along a horizontal gradient MUST be
+         * specified in the OptionalData field of the brush data object.
+         */
+        BitField BLEND_FACTORS_H = BitFieldFactory.getInstance(0x00000008);
+
+        /**
+         * This flag is meaningful in EmfPlusLinearGradientBrushData objects.
+         *
+         * If set, an EmfPlusBlendFactors object that specifies a blend pattern along a vertical gradient MUST be
+         * specified in the OptionalData field of the brush data object.
+         */
+        BitField BLEND_FACTORS_V = BitFieldFactory.getInstance(0x00000010);
+
+        /**
+         * This flag is meaningful in EmfPlusPathGradientBrushData objects.
+         *
+         * If set, an EmfPlusFocusScaleData object MUST be specified in the OptionalData field of the brush data object.
+         */
+        BitField FOCUS_SCALES = BitFieldFactory.getInstance(0x00000040);
+
+        /**
+         * This flag is meaningful in EmfPlusLinearGradientBrushData, EmfPlusPathGradientBrushData, and
+         * EmfPlusTextureBrushData objects.
+         *
+         * If set, the brush MUST already be gamma corrected; that is, output brightness and intensity have been
+         * corrected to match the input image.
+         */
+        BitField IS_GAMMA_CORRECTED = BitFieldFactory.getInstance(0x00000080);
+
+        /**
+         * This flag is meaningful in EmfPlusTextureBrushData objects.
+         *
+         * If set, a world space to device space transform SHOULD NOT be applied to the texture brush.
+         */
+        BitField DO_NOT_TRANSFORM = BitFieldFactory.getInstance(0x00000100);
+
+        long init(LittleEndianInputStream leis, long dataSize) throws IOException;
+    }
+
+    /** The EmfPlusBrush object specifies a graphics brush for filling regions. */
+    public static class EmfPlusBrush implements EmfPlusObjectData {
+        private final EmfPlusGraphicsVersion version = new EmfPlusGraphicsVersion();
+        private EmfPlusBrushType brushType;
+        private EmfPlusBrushData brushData;
+
+        @Override
+        public long init(LittleEndianInputStream leis, long dataSize, EmfPlusObjectType objectType, int flags) throws IOException {
+            long size = version.init(leis);
+
+            brushType = EmfPlusBrushType.valueOf(leis.readInt());
+            size += LittleEndianConsts.INT_SIZE;
+            assert(brushType != null);
+
+            size += (brushData = brushType.constructor.get()).init(leis, dataSize-size);
+
+            return size;
+        }
+    }
+
+    /** The EmfPlusSolidBrushData object specifies a solid color for a graphics brush. */
+    public static class EmfPlusSolidBrushData implements EmfPlusBrushData {
+        private Color solidColor;
+        @Override
+        public long init(LittleEndianInputStream leis, long dataSize) throws IOException {
+            solidColor = readARGB(leis.readInt());
+            return LittleEndianConsts.INT_SIZE;
+        }
+    }
+
+
+    /** The EmfPlusHatchBrushData object specifies a hatch pattern for a graphics brush. */
+    public static class EmfPlusHatchBrushData implements EmfPlusBrushData {
+        private EmfPlusHatchStyle style;
+        private Color foreColor, backColor;
+        public long init(LittleEndianInputStream leis, long dataSize) {
+            style = EmfPlusHatchStyle.valueOf(leis.readInt());
+            foreColor = readARGB(leis.readInt());
+            backColor = readARGB(leis.readInt());
+            return 3*LittleEndianConsts.INT_SIZE;
+        }
+    }
+
+    /** The EmfPlusLinearGradientBrushData object specifies a linear gradient for a graphics brush. */
+    public static class EmfPlusLinearGradientBrushData implements EmfPlusBrushData {
+        private int dataFlags;
+        private EmfPlusWrapMode wrapMode;
+        private Rectangle2D rect = new Rectangle2D.Double();
+        private Color startColor, endColor;
+        private AffineTransform transform;
+        private double[] positions;
+        private Color[] blendColors;
+        private double[] positionsV;
+        private double[] blendFactorsV;
+        private double[] positionsH;
+        private double[] blendFactorsH;
+
+        @Override
+        public long init(LittleEndianInputStream leis, long dataSize) throws IOException {
+            // A 32-bit unsigned integer that specifies the data in the OptionalData field.
+            // This value MUST be composed of BrushData flags
+            dataFlags = leis.readInt();
+
+            // A 32-bit signed integer from the WrapMode enumeration that specifies whether to paint the area outside
+            // the boundary of the brush. When painting outside the boundary, the wrap mode specifies how the color
+            // gradient is repeated.
+            wrapMode = EmfPlusWrapMode.valueOf(leis.readInt());
+
+            int size = 2*LittleEndianConsts.INT_SIZE;
+            size += readRectF(leis, rect);
+
+            // An EmfPlusARGB object that specifies the color at the starting/ending boundary point of the linear gradient brush.
+            startColor = readARGB(leis.readInt());
+            endColor = readARGB(leis.readInt());
+
+            // skip reserved1/2 fields
+            leis.skipFully(2*LittleEndianConsts.INT_SIZE);
+
+            size += 4*LittleEndianConsts.INT_SIZE;
+
+            if (TRANSFORM.isSet(dataFlags)) {
+                size += readXForm(leis, (transform = new AffineTransform()));
+            }
+
+            final boolean isPreset = PRESET_COLORS.isSet(dataFlags);
+            final boolean blendH = BLEND_FACTORS_H.isSet(dataFlags);
+            final boolean blendV = BLEND_FACTORS_V.isSet(dataFlags);
+            if (isPreset && (blendH || blendV)) {
+                throw new RuntimeException("invalid combination of preset colors and blend factors v/h");
+            }
+
+            size += (isPreset) ? readColors(leis, d -> positions = d, c -> blendColors = c) : 0;
+            size += (blendV) ? readFactors(leis, d -> positionsV = d, f -> blendFactorsV = f) : 0;
+            size += (blendH) ? readFactors(leis, d -> positionsH = d, f -> blendFactorsH = f) : 0;
+
+            return size;
+        }
+    }
+
+    /** The EmfPlusPathGradientBrushData object specifies a path gradient for a graphics brush. */
+    public static class EmfPlusPathGradientBrushData implements EmfPlusBrushData {
+        private int dataFlags;
+        private EmfPlusWrapMode wrapMode;
+        private Color centerColor;
+        private final Point2D centerPoint = new Point2D.Double();
+        private Color[] surroundingColor;
+        private EmfPlusPath boundaryPath;
+        private Point2D[] boundaryPoints;
+        private AffineTransform transform;
+        private double[] positions;
+        private Color[] blendColors;
+        private double[] blendFactorsH;
+        private Double focusScaleX, focusScaleY;
+
+        @Override
+        public long init(LittleEndianInputStream leis, long dataSize) throws IOException {
+            // A 32-bit unsigned integer that specifies the data in the OptionalData field.
+            // This value MUST be composed of BrushData flags
+            dataFlags = leis.readInt();
+
+            // A 32-bit signed integer from the WrapMode enumeration that specifies whether to paint the area outside
+            // the boundary of the brush. When painting outside the boundary, the wrap mode specifies how the color
+            // gradient is repeated.
+            wrapMode = EmfPlusWrapMode.valueOf(leis.readInt());
+
+            // An EmfPlusARGB object that specifies the center color of the path gradient brush, which is the color
+            // that appears at the center point of the brush. The color of the brush changes gradually from the
+            // boundary color to the center color as it moves from the boundary to the center point.
+            centerColor = readARGB(leis.readInt());
+
+            int size = 3*LittleEndianConsts.INT_SIZE;
+            size += readPointF(leis, centerPoint);
+
+            // An unsigned 32-bit integer that specifies the number of colors specified in the SurroundingColor field.
+            // The surrounding colors are colors specified for discrete points on the boundary of the brush.
+            final int colorCount = leis.readInt();
+
+            // An array of SurroundingColorCount EmfPlusARGB objects that specify the colors for discrete points on the
+            // boundary of the brush.
+            surroundingColor = new Color[colorCount];
+            for (int i=0; i<colorCount; i++) {
+                surroundingColor[i] = readARGB(leis.readInt());
+            }
+            size += (colorCount+1) * LittleEndianConsts.INT_SIZE;
+
+            // The boundary of the path gradient brush, which is specified by either a path or a closed cardinal spline.
+            // If the BrushDataPath flag is set in the BrushDataFlags field, this field MUST contain an
+            // EmfPlusBoundaryPathData object; otherwise, this field MUST contain an EmfPlusBoundaryPointData object.
+            if (PATH.isSet(dataFlags)) {
+                // A 32-bit signed integer that specifies the size in bytes of the BoundaryPathData field.
+                int pathDataSize = leis.readInt();
+                size += LittleEndianConsts.INT_SIZE;
+
+                // An EmfPlusPath object that specifies the boundary of the brush.
+                size += (boundaryPath = new EmfPlusPath()).init(leis, pathDataSize, EmfPlusObjectType.PATH, 0);
+            } else {
+                // A 32-bit signed integer that specifies the number of points in the BoundaryPointData field.
+                int pointCount = leis.readInt();
+                size += LittleEndianConsts.INT_SIZE;
+
+                // An array of BoundaryPointCount EmfPlusPointF objects that specify the boundary of the brush.
+                boundaryPoints = new Point2D[pointCount];
+                for (int i=0; i<pointCount; i++) {
+                    size += readPointF(leis, boundaryPoints[i] = new Point2D.Double());
+                }
+            }
+
+            // An optional EmfPlusTransformMatrix object that specifies a world space to device space transform for
+            // the path gradient brush. This field MUST be present if the BrushDataTransform flag is set in the
+            // BrushDataFlags field of the EmfPlusPathGradientBrushData object.
+            if (TRANSFORM.isSet(dataFlags)) {
+                size += readXForm(leis, (transform = new AffineTransform()));
+            }
+
+            // An optional blend pattern for the path gradient brush. If this field is present, it MUST contain either
+            // an EmfPlusBlendColors object, or an EmfPlusBlendFactors object, but it MUST NOT contain both.
+            final boolean isPreset = PRESET_COLORS.isSet(dataFlags);
+            final boolean blendH = BLEND_FACTORS_H.isSet(dataFlags);
+            if (isPreset && blendH) {
+                throw new RuntimeException("invalid combination of preset colors and blend factors h");
+            }
+
+            size += (isPreset) ? readColors(leis, d -> positions = d, c -> blendColors = c) : 0;
+            size += (blendH) ? readFactors(leis, d -> positions = d, f -> blendFactorsH = f) : 0;
+
+            // An optional EmfPlusFocusScaleData object that specifies focus scales for the path gradient brush.
+            // This field MUST be present if the BrushDataFocusScales flag is set in the BrushDataFlags field of the
+            // EmfPlusPathGradientBrushData object.
+            if (FOCUS_SCALES.isSet(dataFlags)) {
+                // A 32-bit unsigned integer that specifies the number of focus scales. This value MUST be 2.
+                int focusScaleCount = leis.readInt();
+                if (focusScaleCount != 2) {
+                    throw new RuntimeException("invalid focus scale count");
+                }
+                // A floating-point value that defines the horizontal/vertical focus scale.
+                // The focus scale MUST be a value between 0.0 and 1.0, exclusive.
+                focusScaleX = (double)leis.readFloat();
+                focusScaleY = (double)leis.readFloat();
+                size += 3*LittleEndianConsts.INT_SIZE;
+            }
+
+            return size;
+        }
+    }
+
+    /** The EmfPlusTextureBrushData object specifies a texture image for a graphics brush. */
+    public static class EmfPlusTextureBrushData implements EmfPlusBrushData {
+        private int dataFlags;
+        private EmfPlusWrapMode wrapMode;
+        private AffineTransform transform;
+        private EmfPlusImage image;
+
+        @Override
+        public long init(LittleEndianInputStream leis, long dataSize) throws IOException {
+            // A 32-bit unsigned integer that specifies the data in the OptionalData field.
+            // This value MUST be composed of BrushData flags.
+            dataFlags = leis.readInt();
+
+            // A 32-bit signed integer from the WrapMode enumeration that specifies how to repeat the texture image
+            // across a shape, when the image is smaller than the area being filled.
+            wrapMode = EmfPlusWrapMode.valueOf(leis.readInt());
+
+            int size = 2*LittleEndianConsts.INT_SIZE;
+
+            if (TRANSFORM.isSet(dataFlags)) {
+                size += readXForm(leis, (transform = new AffineTransform()));
+            }
+
+            if (dataSize > size) {
+                size += (image = new EmfPlusImage()).init(leis, dataSize-size, EmfPlusObjectType.IMAGE, 0);
+            }
+
+            return size;
+        }
+    }
+
+    private static int readPositions(LittleEndianInputStream leis, Consumer<double[]> pos) {
+        final int count = leis.readInt();
+        int size = LittleEndianConsts.INT_SIZE;
+
+        double[] positions = new double[count];
+        for (int i=0; i<count; i++) {
+            positions[i] = leis.readFloat();
+            size += LittleEndianConsts.INT_SIZE;
+        }
+
+        pos.accept(positions);
+        return size;
+    }
+
+    private static int readColors(LittleEndianInputStream leis, Consumer<double[]> pos, Consumer<Color[]>  cols) {
+        int[] count = { 0 };
+        int size = readPositions(leis, p -> { count[0] = p.length; pos.accept(p); });
+        Color[] colors = new Color[count[0]];
+        for (int i=0; i<colors.length; i++) {
+            colors[i] = readARGB(leis.readInt());
+        }
+        cols.accept(colors);
+        return size + colors.length * LittleEndianConsts.INT_SIZE;
+    }
+
+    private static int readFactors(LittleEndianInputStream leis, Consumer<double[]> pos, Consumer<double[]> facs) {
+        int[] count = { 0 };
+        int size = readPositions(leis, p -> { count[0] = p.length; pos.accept(p); });
+        double[] factors = new double[count[0]];
+        for (int i=0; i<factors.length; i++) {
+            factors[i] = leis.readFloat();
+        }
+        facs.accept(factors);
+        return size + factors.length * LittleEndianConsts.INT_SIZE;
+    }
+}

src/scratchpad/src/org/apache/poi/hemf/record/emfplus/HemfPlusDraw.java

@@ -35,7 +35,6 @@ import org.apache.poi.hemf.record.emfplus.HemfPlusMisc.EmfPlusObjectId;
 import org.apache.poi.util.BitField;
 import org.apache.poi.util.BitFieldFactory;
 import org.apache.poi.util.IOUtils;
-import org.apache.poi.util.LittleEndian;
 import org.apache.poi.util.LittleEndianConsts;
 import org.apache.poi.util.LittleEndianInputStream;
 import org.apache.poi.util.StringUtil;
@@ -43,7 +42,7 @@ import org.apache.poi.util.StringUtil;
 public class HemfPlusDraw {
     private static final int MAX_OBJECT_SIZE = 1_000_000;
 
-    public enum UnitType {
+    public enum EmfPlusUnitType {
         /** Specifies a unit of logical distance within the world space. */
         World(0x00),
         /** Specifies a unit of distance based on the characteristics of the physical display. */
@@ -62,12 +61,12 @@ public class HemfPlusDraw {
 
         public final int id;
 
-        UnitType(int id) {
+        EmfPlusUnitType(int id) {
             this.id = id;
         }
 
-        public static UnitType valueOf(int id) {
-            for (UnitType wrt : values()) {
+        public static EmfPlusUnitType valueOf(int id) {
+            for (EmfPlusUnitType wrt : values()) {
                 if (wrt.id == id) return wrt;
             }
             return null;
@@ -98,6 +97,25 @@ public class HemfPlusDraw {
         }
     }
 
+    public interface EmfPlusRelativePosition {
+        /**
+         * This bit indicates whether the PointData field specifies relative or absolute locations.
+         * If set, each element in PointData specifies a location in the coordinate space that is relative to the
+         * location specified by the previous element in the array. In the case of the first element in PointData,
+         * a previous location at coordinates (0,0) is assumed.
+         * If clear, PointData specifies absolute locations according to the {@link #isCompressed()} flag.
+         *
+         * Note If this flag is set, the {@link #isCompressed()} flag (above) is undefined and MUST be ignored.
+         */
+        BitField POSITION = BitFieldFactory.getInstance(0x0800);
+
+        int getFlags();
+
+        default boolean isRelativePosition() {
+            return POSITION.isSet(getFlags());
+        }
+    }
+
 
 
     /**
@@ -182,27 +200,16 @@ public class HemfPlusDraw {
         }
     }
 
-    public static class EmfPlusDrawImagePoints implements HemfPlusRecord, EmfPlusObjectId, EmfPlusCompressed {
+    public static class EmfPlusDrawImagePoints implements HemfPlusRecord, EmfPlusObjectId, EmfPlusCompressed, EmfPlusRelativePosition {
         /**
          * This bit indicates that the rendering of the image includes applying an effect.
          * If set, an object of the Effect class MUST have been specified in an earlier EmfPlusSerializableObject record.
          */
         private static final BitField EFFECT = BitFieldFactory.getInstance(0x2000);
 
-        /**
-         * This bit indicates whether the PointData field specifies relative or absolute locations.
-         * If set, each element in PointData specifies a location in the coordinate space that is relative to the
-         * location specified by the previous element in the array. In the case of the first element in PointData,
-         * a previous location at coordinates (0,0) is assumed.
-         * If clear, PointData specifies absolute locations according to the {@link #isCompressed()} flag.
-         *
-         * Note If this flag is set, the {@link #isCompressed()} flag (above) is undefined and MUST be ignored.
-         */
-        private static final BitField POSITION = BitFieldFactory.getInstance(0x0800);
-
         private int flags;
         private int imageAttributesID;
-        private UnitType srcUnit;
+        private EmfPlusUnitType srcUnit;
         private final Rectangle2D srcRect = new Rectangle2D.Double();
         private final Point2D upperLeft = new Point2D.Double();
         private final Point2D lowerRight = new Point2D.Double();
@@ -229,8 +236,8 @@ public class HemfPlusDraw {
 
             // A 32-bit signed integer that defines the units of the SrcRect field.
             // It MUST be the UnitPixel value of the UnitType enumeration
-            srcUnit = UnitType.valueOf(leis.readInt());
-            assert(srcUnit == UnitType.Pixel);
+            srcUnit = EmfPlusUnitType.valueOf(leis.readInt());
+            assert(srcUnit == EmfPlusUnitType.Pixel);
 
             int size = 2 * LittleEndianConsts.INT_SIZE;
 
@@ -245,7 +252,7 @@ public class HemfPlusDraw {
 
             BiFunction<LittleEndianInputStream, Point2D, Integer> readPoint;
 
-            if (POSITION.isSet(flags)) {
+            if (isRelativePosition()) {
                 // If the POSITION flag is set in the Flags, the points specify relative locations.
                 readPoint = HemfPlusDraw::readPointR;
             } else if (isCompressed()) {
@@ -301,7 +308,7 @@ public class HemfPlusDraw {
     public static class EmfPlusDrawImage implements HemfPlusRecord, EmfPlusObjectId, EmfPlusCompressed {
         private int flags;
         private int imageAttributesID;
-        private UnitType srcUnit;
+        private EmfPlusUnitType srcUnit;
         private final Rectangle2D srcRect = new Rectangle2D.Double();
         private final Rectangle2D rectData = new Rectangle2D.Double();
 
@@ -325,8 +332,8 @@ public class HemfPlusDraw {
 
             // A 32-bit signed integer that defines the units of the SrcRect field.
             // It MUST be the UnitPixel value of the UnitType enumeration
-            srcUnit = UnitType.valueOf(leis.readInt());
-            assert(srcUnit == UnitType.Pixel);
+            srcUnit = EmfPlusUnitType.valueOf(leis.readInt());
+            assert(srcUnit == EmfPlusUnitType.Pixel);
 
             int size = 2 * LittleEndianConsts.INT_SIZE;
 
@@ -347,7 +354,7 @@ public class HemfPlusDraw {
         private static final BitField SOLID_COLOR = BitFieldFactory.getInstance(0x8000);
 
         private int flags;
-        private final byte[] brushId = new byte[LittleEndianConsts.INT_SIZE];
+        private int brushId;
 
         @Override
         public HemfPlusRecordType getEmfPlusRecordType() {
@@ -364,11 +371,11 @@ public class HemfPlusDraw {
         }
 
         public int getBrushId() {
-            return (isSolidColor()) ? -1 : LittleEndian.getInt(brushId);
+            return (isSolidColor()) ? -1 : brushId;
         }
 
         public Color getSolidColor() {
-            return (isSolidColor()) ? new Color(brushId[2], brushId[1], brushId[0], brushId[3]) : null;
+            return (isSolidColor()) ? readARGB(brushId) : null;
         }
 
         @Override
@@ -379,7 +386,7 @@ public class HemfPlusDraw {
             // the SOLID_COLOR bit in the Flags field.
             // If SOLID_COLOR is set, BrushId specifies a color as an EmfPlusARGB object.
             // If clear, BrushId contains the index of an EmfPlusBrush object in the EMF+ Object Table.
-            leis.readFully(brushId);
+            brushId = leis.readInt();
 
             return LittleEndianConsts.INT_SIZE;
         }
@@ -606,4 +613,9 @@ public class HemfPlusDraw {
         value[0] = ((value[0] << 8) | leis.readByte()) & 0x7FFF;
         return LittleEndianConsts.SHORT_SIZE;
     }
+
+    static Color readARGB(int argb) {
+        return new Color(  (argb >>> 8) & 0xFF, (argb >>> 16) & 0xFF, (argb >>> 24) & 0xFF, argb & 0xFF);
+    }
+
 }

src/scratchpad/src/org/apache/poi/hemf/record/emfplus/HemfPlusFont.java

@@ -0,0 +1,100 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+==================================================================== */
+
+package org.apache.poi.hemf.record.emfplus;
+
+import java.io.IOException;
+
+import org.apache.poi.hemf.record.emfplus.HemfPlusDraw.EmfPlusUnitType;
+import org.apache.poi.hemf.record.emfplus.HemfPlusHeader.EmfPlusGraphicsVersion;
+import org.apache.poi.hemf.record.emfplus.HemfPlusObject.EmfPlusObjectData;
+import org.apache.poi.util.BitField;
+import org.apache.poi.util.BitFieldFactory;
+import org.apache.poi.util.LittleEndianConsts;
+import org.apache.poi.util.LittleEndianInputStream;
+import org.apache.poi.util.StringUtil;
+
+public class HemfPlusFont {
+
+
+    public static class EmfPlusFont implements EmfPlusObjectData {
+        /**
+         * If set, the font typeface MUST be rendered with a heavier weight or thickness.
+         * If clear, the font typeface MUST be rendered with a normal thickness.
+         */
+        private static final BitField BOLD = BitFieldFactory.getInstance(0x00000001);
+
+        /**
+         * If set, the font typeface MUST be rendered with the vertical stems of the characters at an increased angle
+         * or slant relative to the baseline.
+         *
+         * If clear, the font typeface MUST be rendered with the vertical stems of the characters at a normal angle.
+         */
+        private static final BitField ITALIC = BitFieldFactory.getInstance(0x00000002);
+
+        /**
+         * If set, the font typeface MUST be rendered with a line underneath the baseline of the characters.
+         * If clear, the font typeface MUST be rendered without a line underneath the baseline.
+         */
+        private static final BitField UNDERLINE = BitFieldFactory.getInstance(0x00000004);
+
+        /**
+         * If set, the font typeface MUST be rendered with a line parallel to the baseline drawn through the middle of
+         * the characters.
+         * If clear, the font typeface MUST be rendered without a line through the characters.
+         */
+        private static final BitField STRIKEOUT = BitFieldFactory.getInstance(0x00000008);
+
+
+        private final EmfPlusGraphicsVersion version = new EmfPlusGraphicsVersion();
+        private double emSize;
+        private EmfPlusUnitType sizeUnit;
+        private int styleFlags;
+        private String family;
+
+        @Override
+        public long init(LittleEndianInputStream leis, long dataSize, HemfPlusObject.EmfPlusObjectType objectType, int flags) throws IOException {
+            // An EmfPlusGraphicsVersion object that specifies the version of operating system graphics that was used
+            // to create this object.
+            long size = version.init(leis);
+
+            // A 32-bit floating-point value that specifies the em size of the font in units specified by the SizeUnit field.
+            emSize = leis.readFloat();
+
+            // A 32-bit unsigned integer that specifies the units used for the EmSize field. These are typically the
+            // units that were employed when designing the font. The value MUST be in the UnitType enumeration
+            sizeUnit = EmfPlusUnitType.valueOf(leis.readInt());
+
+            // A 32-bit signed integer that specifies attributes of the character glyphs that affect the appearance of
+            // the font, such as bold and italic. This value MUST be composed of FontStyle flags
+            styleFlags = leis.readInt();
+
+            // A 32-bit unsigned integer that is reserved and MUST be ignored.
+            leis.skipFully(LittleEndianConsts.INT_SIZE);
+
+            // A 32-bit unsigned integer that specifies the number of characters in the FamilyName field.
+            int len = leis.readInt();
+            size += 5*LittleEndianConsts.INT_SIZE;
+
+            // A string of Length Unicode characters that contains the name of the font family.
+            family = StringUtil.readUnicodeLE(leis, len);
+            size += len*LittleEndianConsts.SHORT_SIZE;
+
+            return size;
+        }
+    }
+}

src/scratchpad/src/org/apache/poi/hemf/record/emfplus/HemfPlusImage.java

@@ -0,0 +1,439 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+==================================================================== */
+
+package org.apache.poi.hemf.record.emfplus;
+
+import static org.apache.poi.hemf.record.emfplus.HemfPlusDraw.readARGB;
+
+import java.awt.Color;
+import java.io.IOException;
+
+import org.apache.poi.hemf.record.emfplus.HemfPlusHeader.EmfPlusGraphicsVersion;
+import org.apache.poi.hemf.record.emfplus.HemfPlusObject.EmfPlusObjectData;
+import org.apache.poi.hemf.record.emfplus.HemfPlusObject.EmfPlusObjectType;
+import org.apache.poi.util.BitField;
+import org.apache.poi.util.BitFieldFactory;
+import org.apache.poi.util.IOUtils;
+import org.apache.poi.util.LittleEndianConsts;
+import org.apache.poi.util.LittleEndianInputStream;
+
+public class HemfPlusImage {
+    /** The ImageDataType enumeration defines types of image data formats. */
+    public enum EmfPlusImageDataType {
+        /** The type of image is not known. */
+        UNKNOWN(0x00000000),
+        /** Specifies a bitmap image. */
+        BITMAP(0x00000001),
+        /** Specifies a metafile image. */
+        METAFILE(0x00000002),
+        /** POI-specific - marks an unfinished/continuable image part */
+        CONTINUED(-1);
+
+        public final int id;
+
+        EmfPlusImageDataType(int id) {
+            this.id = id;
+        }
+
+        public static EmfPlusImageDataType valueOf(int id) {
+            for (EmfPlusImageDataType wrt : values()) {
+                if (wrt.id == id) return wrt;
+            }
+            return null;
+        }
+    }
+
+    public enum EmfPlusPixelFormat {
+        UNDEFINED(0X00000000),
+        INDEXED_1BPP(0X00030101),
+        INDEXED_4BPP(0X00030402),
+        INDEXED_8BPP(0X00030803),
+        GRAYSCALE_16BPP(0X00101004),
+        RGB555_16BPP(0X00021005),
+        RGB565_16BPP(0X00021006),
+        ARGB1555_16BPP(0X00061007),
+        RGB_24BPP(0X00021808),
+        RGB_32BPP(0X00022009),
+        ARGB_32BPP(0X0026200A),
+        PARGB_32BPP(0X000E200B),
+        RGB_48BPP(0X0010300C),
+        ARGB_64BPP(0X0034400D),
+        PARGB_64BPP(0X001A400E),
+        ;
+
+        private static final BitField CANONICAL = BitFieldFactory.getInstance(0x00200000);
+        private static final BitField EXTCOLORS = BitFieldFactory.getInstance(0x00100000);
+        private static final BitField PREMULTI = BitFieldFactory.getInstance(0x00080000);
+        private static final BitField ALPHA = BitFieldFactory.getInstance(0x00040000);
+        private static final BitField GDI = BitFieldFactory.getInstance(0x00020000);
+        private static final BitField PALETTE = BitFieldFactory.getInstance(0x00010000);
+        private static final BitField BPP = BitFieldFactory.getInstance(0x0000FF00);
+        private static final BitField INDEX = BitFieldFactory.getInstance(0x000000FF);
+
+        public final int id;
+
+        EmfPlusPixelFormat(int id) {
+            this.id = id;
+        }
+
+        public static EmfPlusPixelFormat valueOf(int id) {
+            for (EmfPlusPixelFormat wrt : values()) {
+                if (wrt.id == id) return wrt;
+            }
+            return null;
+        }
+
+        /**
+         * The pixel format enumeration index.
+         */
+        public int getGDIEnumIndex() {
+            return id == -1 ? -1 : INDEX.getValue(id);
+        }
+
+        /**
+         * The total number of bits per pixel.
+         */
+        public int getBitsPerPixel() {
+            return id == -1 ? -1 : BPP.getValue(id);
+        }
+
+        /**
+         * If set, the pixel values are indexes into a palette.
+         * If clear, the pixel values are actual colors.
+         */
+        public boolean isPaletteIndexed() {
+            return id != -1 && PALETTE.isSet(id);
+        }
+
+        /**
+         * If set, the pixel format is supported in Windows GDI.
+         * If clear, the pixel format is not supported in Windows GDI.
+         */
+        public boolean isGDISupported() {
+            return id != -1 && GDI.isSet(id);
+        }
+
+        /**
+         * If set, the pixel format includes an alpha transparency component.
+         * If clear, the pixel format does not include a component that specifies transparency.
+         */
+        public boolean isAlpha() {
+            return id != -1 && ALPHA.isSet(id);
+        }
+
+        /**
+         * If set, each color component in the pixel has been premultiplied by the pixel's alpha transparency value.
+         * If clear, each color component is multiplied by the pixel's alpha transparency value when the source pixel
+         * is blended with the destination pixel.
+         */
+        public boolean isPreMultiplied() {
+            return id != -1 && PREMULTI.isSet(id);
+        }
+
+        /**
+         * If set, the pixel format supports extended colors in 16-bits per channel.
+         * If clear, extended colors are not supported.
+         */
+        public boolean isExtendedColors() {
+            return id != -1 && EXTCOLORS.isSet(id);
+        }
+
+        /**
+         * If set, the pixel format is "canonical", which means that 32 bits per pixel are
+         * supported, with 24-bits for color components and an 8-bit alpha channel.
+         * If clear, the pixel format is not canonical.
+         */
+        public boolean isCanonical() {
+            return id != -1 && CANONICAL.isSet(id);
+        }
+    }
+
+    public enum EmfPlusBitmapDataType {
+        PIXEL(0x00000000),
+        COMPRESSED(0x00000001);
+
+        public final int id;
+
+        EmfPlusBitmapDataType(int id) {
+            this.id = id;
+        }
+
+        public static EmfPlusBitmapDataType valueOf(int id) {
+            for (EmfPlusBitmapDataType wrt : values()) {
+                if (wrt.id == id) return wrt;
+            }
+            return null;
+        }
+    }
+
+    public enum EmfPlusMetafileDataType {
+        Wmf(0x00000001),
+        WmfPlaceable(0x00000002),
+        Emf(0x00000003),
+        EmfPlusOnly(0x00000004),
+        EmfPlusDual(0x00000005);
+
+        public final int id;
+
+        EmfPlusMetafileDataType(int id) {
+            this.id = id;
+        }
+
+        public static EmfPlusMetafileDataType valueOf(int id) {
+            for (EmfPlusMetafileDataType wrt : values()) {
+                if (wrt.id == id) return wrt;
+            }
+            return null;
+        }
+    }
+
+
+    /**
+     * The WrapMode enumeration defines how the pattern from a texture or gradient brush is tiled
+     * across a shape or at shape boundaries, when it is smaller than the area being filled.
+     */
+    public enum EmfPlusWrapMode {
+        WRAP_MODE_TILE(0x00000000),
+        WRAP_MODE_TILE_FLIP_X(0x00000001),
+        WRAP_MODE_TILE_FLIP_Y(0x00000002),
+        WRAP_MODE_TILE_FLIP_XY(0x00000003),
+        WRAP_MODE_CLAMP(0x00000004)
+        ;
+
+        public final int id;
+
+        EmfPlusWrapMode(int id) {
+            this.id = id;
+        }
+
+        public static EmfPlusWrapMode valueOf(int id) {
+            for (EmfPlusWrapMode wrt : values()) {
+                if (wrt.id == id) return wrt;
+            }
+            return null;
+        }
+    }
+
+    public enum EmfPlusObjectClamp {
+        /** The object is clamped to a rectangle. */
+        RectClamp(0x00000000),
+        /** The object is clamped to a bitmap. */
+        BitmapClamp(0x00000001)
+        ;
+
+        public final int id;
+
+        EmfPlusObjectClamp(int id) {
+            this.id = id;
+        }
+
+        public static EmfPlusObjectClamp valueOf(int id) {
+            for (EmfPlusObjectClamp wrt : values()) {
+                if (wrt.id == id) return wrt;
+            }
+            return null;
+        }
+    }
+
+
+    public static class EmfPlusImage implements EmfPlusObjectData {
+        private static final int MAX_OBJECT_SIZE = 50_000_000;
+
+
+        private final EmfPlusGraphicsVersion graphicsVersion = new EmfPlusGraphicsVersion();
+        private EmfPlusImageDataType imageDataType;
+        private int bitmapWidth;
+        private int bitmapHeight;
+        private int bitmapStride;
+        private EmfPlusPixelFormat pixelFormat;
+        private EmfPlusBitmapDataType bitmapType;
+        private byte[] imageData;
+        private EmfPlusMetafileDataType metafileType;
+        private int metafileDataSize;
+
+        public EmfPlusImageDataType getImageDataType() {
+            return imageDataType;
+        }
+
+        public byte[] getImageData() {
+            return imageData;
+        }
+
+        public EmfPlusPixelFormat getPixelFormat() {
+            return pixelFormat;
+        }
+
+        public EmfPlusBitmapDataType getBitmapType() {
+            return bitmapType;
+        }
+
+        public int getBitmapWidth() {
+            return bitmapWidth;
+        }
+
+        public int getBitmapHeight() {
+            return bitmapHeight;
+        }
+
+        public int getBitmapStride() {
+            return bitmapStride;
+        }
+
+        public EmfPlusMetafileDataType getMetafileType() {
+            return metafileType;
+        }
+
+        @Override
+        public long init(LittleEndianInputStream leis, long dataSize, EmfPlusObjectType objectType, int flags) throws IOException {
+            leis.mark(LittleEndianConsts.INT_SIZE);
+            long size = graphicsVersion.init(leis);
+
+            if (graphicsVersion.getGraphicsVersion() == null || graphicsVersion.getMetafileSignature() != 0xDBC01) {
+                // CONTINUABLE is not always correctly set, so we check the version field if this record is continued
+                imageDataType = EmfPlusImageDataType.CONTINUED;
+                leis.reset();
+                size = 0;
+            } else {
+                imageDataType = EmfPlusImageDataType.valueOf(leis.readInt());
+                size += LittleEndianConsts.INT_SIZE;
+            }
+
+            if (imageDataType == null) {
+                imageDataType = EmfPlusImageDataType.UNKNOWN;
+            }
+
+            int fileSize;
+            switch (imageDataType) {
+                default:
+                case UNKNOWN:
+                case CONTINUED:
+                    bitmapWidth = -1;
+                    bitmapHeight = -1;
+                    bitmapStride = -1;
+                    bitmapType = null;
+                    pixelFormat = null;
+
+                    fileSize = (int) (dataSize);
+                    break;
+
+                case BITMAP:
+                    // A 32-bit signed integer that specifies the width in pixels of the area occupied by the bitmap.
+                    // If the image is compressed, according to the Type field, this value is undefined and MUST be ignored.
+                    bitmapWidth = leis.readInt();
+                    // A 32-bit signed integer that specifies the height in pixels of the area occupied by the bitmap.
+                    // If the image is compressed, according to the Type field, this value is undefined and MUST be ignored.
+                    bitmapHeight = leis.readInt();
+                    // A 32-bit signed integer that specifies the byte offset between the beginning of one scan-line
+                    // and the next. This value is the number of bytes per pixel, which is specified in the PixelFormat
+                    // field, multiplied by the width in pixels, which is specified in the Width field.
+                    // The value of this field MUST be a multiple of four. If the image is compressed, according to the
+                    // Type field, this value is undefined and MUST be ignored.
+                    bitmapStride = leis.readInt();
+                    // A 32-bit unsigned integer that specifies the format of the pixels that make up the bitmap image.
+                    //  The supported pixel formats are specified in the PixelFormat enumeration
+                    int pixelFormatInt = leis.readInt();
+                    // A 32-bit unsigned integer that specifies the metafileType of data in the BitmapData field.
+                    // This value MUST be defined in the BitmapDataType enumeration
+                    bitmapType = EmfPlusBitmapDataType.valueOf(leis.readInt());
+                    size += 5 * LittleEndianConsts.INT_SIZE;
+
+                    pixelFormat = (bitmapType == EmfPlusBitmapDataType.PIXEL)
+                            ? EmfPlusPixelFormat.valueOf(pixelFormatInt)
+                            : EmfPlusPixelFormat.UNDEFINED;
+                    assert (pixelFormat != null);
+
+                    fileSize = (int) (dataSize - size);
+
+                    break;
+
+                case METAFILE:
+                    // A 32-bit unsigned integer that specifies the type of metafile that is embedded in the
+                    // MetafileData field. This value MUST be defined in the MetafileDataType enumeration
+                    metafileType = EmfPlusMetafileDataType.valueOf(leis.readInt());
+
+                    // A 32-bit unsigned integer that specifies the size in bytes of the
+                    // metafile data in the MetafileData field.
+                    metafileDataSize = leis.readInt();
+
+                    size += 2 * LittleEndianConsts.INT_SIZE;
+
+                    // ignore metafileDataSize, which might ignore a (placeable) header in front
+                    // and also use the remaining bytes, which might contain padding bytes ...
+                    fileSize = (int) (dataSize - size);
+                    break;
+            }
+
+            assert (fileSize <= dataSize - size);
+
+            imageData = IOUtils.toByteArray(leis, fileSize, MAX_OBJECT_SIZE);
+
+            // TODO: remove padding bytes between placeable WMF header and body?
+
+            return size + fileSize;
+        }
+    }
+
+    public static class EmfPlusImageAttributes implements EmfPlusObjectData {
+        private final EmfPlusGraphicsVersion graphicsVersion = new EmfPlusGraphicsVersion();
+        private EmfPlusWrapMode wrapMode;
+        private Color clampColor;
+        private EmfPlusObjectClamp objectClamp;
+
+        @Override
+        public long init(LittleEndianInputStream leis, long dataSize, EmfPlusObjectType objectType, int flags) throws IOException {
+            // An EmfPlusGraphicsVersion object that specifies the version of operating system graphics that
+            // was used to create this object.
+            long size = graphicsVersion.init(leis);
+
+            // A 32-bit field that is not used and MUST be ignored.
+            leis.skipFully(LittleEndianConsts.INT_SIZE);
+
+            // A 32-bit unsigned integer that specifies how to handle edge conditions with a value from the WrapMode enumeration
+            wrapMode = EmfPlusWrapMode.valueOf(leis.readInt());
+
+            // An EmfPlusARGB object that specifies the edge color to use when the WrapMode value is WrapModeClamp.
+            // This color is visible when the source rectangle processed by an EmfPlusDrawImage record is larger than the image itself.
+            clampColor = readARGB(leis.readInt());
+
+            // A 32-bit signed integer that specifies the object clamping behavior. It is not used until this object
+            // is applied to an image being drawn. This value MUST be one of the values defined in the following table.
+            objectClamp = EmfPlusObjectClamp.valueOf(leis.readInt());
+
+            // A value that SHOULD be set to zero and MUST be ignored upon receipt.
+            leis.skipFully(LittleEndianConsts.INT_SIZE);
+
+            return size + 5*LittleEndianConsts.INT_SIZE;
+        }
+
+        public EmfPlusGraphicsVersion getGraphicsVersion() {
+            return graphicsVersion;
+        }
+
+        public EmfPlusWrapMode getWrapMode() {
+            return wrapMode;
+        }
+
+        public Color getClampColor() {
+            return clampColor;
+        }
+
+        public EmfPlusObjectClamp getObjectClamp() {
+            return objectClamp;
+        }
+    }
+
+}

src/scratchpad/src/org/apache/poi/hemf/record/emfplus/HemfPlusObject.java

@@ -17,12 +17,18 @@
 
 package org.apache.poi.hemf.record.emfplus;
 
-import java.awt.Color;
 import java.io.IOException;
 import java.util.function.Supplier;
 
+import org.apache.poi.hemf.record.emfplus.HemfPlusBrush.EmfPlusBrush;
+import org.apache.poi.hemf.record.emfplus.HemfPlusFont.EmfPlusFont;
 import org.apache.poi.hemf.record.emfplus.HemfPlusHeader.EmfPlusGraphicsVersion;
+import org.apache.poi.hemf.record.emfplus.HemfPlusImage.EmfPlusImage;
+import org.apache.poi.hemf.record.emfplus.HemfPlusImage.EmfPlusImageAttributes;
 import org.apache.poi.hemf.record.emfplus.HemfPlusMisc.EmfPlusObjectId;
+import org.apache.poi.hemf.record.emfplus.HemfPlusPath.EmfPlusPath;
+import org.apache.poi.hemf.record.emfplus.HemfPlusPen.EmfPlusPen;
+import org.apache.poi.hemf.record.emfplus.HemfPlusRegion.EmfPlusRegion;
 import org.apache.poi.util.BitField;
 import org.apache.poi.util.BitFieldFactory;
 import org.apache.poi.util.IOUtils;
@@ -43,19 +49,19 @@ public class HemfPlusObject {
         /**
          * Brush objects fill graphics regions.
          */
-        BRUSH(0x00000001, EmfPlusUnknownData::new),
+        BRUSH(0x00000001, EmfPlusBrush::new),
         /**
          * Pen objects draw graphics lines.
          */
-        PEN(0x00000002, EmfPlusUnknownData::new),
+        PEN(0x00000002, EmfPlusPen::new),
         /**
          * Path objects specify sequences of lines, curves, and shapes.
          */
-        PATH(0x00000003, EmfPlusUnknownData::new),
+        PATH(0x00000003, EmfPlusPath::new),
         /**
          * Region objects specify areas of the output surface.
          */
-        REGION(0x00000004, EmfPlusUnknownData::new),
+        REGION(0x00000004, EmfPlusRegion::new),
         /**
          * Image objects encapsulate bitmaps and metafiles.
          */
@@ -63,7 +69,7 @@ public class HemfPlusObject {
         /**
          * Font objects specify font properties, including typeface style, em size, and font family.
          */
-        FONT(0x00000006, EmfPlusUnknownData::new),
+        FONT(0x00000006, EmfPlusFont::new),
         /**
          * String format objects specify text layout, including alignment, orientation, tab stops, clipping,
          * and digit substitution for languages that do not use Western European digits.
@@ -96,220 +102,10 @@ public class HemfPlusObject {
         }
     }
 
-    public enum EmfPlusImageDataType {
-        UNKNOWN(0x00000000),
-        BITMAP(0x00000001),
-        METAFILE(0x00000002),
-        CONTINUED(-1);
-
-        public final int id;
-
-        EmfPlusImageDataType(int id) {
-            this.id = id;
-        }
-
-        public static EmfPlusImageDataType valueOf(int id) {
-            for (EmfPlusImageDataType wrt : values()) {
-                if (wrt.id == id) return wrt;
-            }
-            return null;
-        }
-    }
-
-    public enum EmfPlusBitmapDataType {
-        PIXEL(0x00000000),
-        COMPRESSED(0x00000001);
-
-        public final int id;
-
-        EmfPlusBitmapDataType(int id) {
-            this.id = id;
-        }
-
-        public static EmfPlusBitmapDataType valueOf(int id) {
-            for (EmfPlusBitmapDataType wrt : values()) {
-                if (wrt.id == id) return wrt;
-            }
-            return null;
-        }
-    }
-
-    public enum EmfPlusPixelFormat {
-        UNDEFINED(0X00000000),
-        INDEXED_1BPP(0X00030101),
-        INDEXED_4BPP(0X00030402),
-        INDEXED_8BPP(0X00030803),
-        GRAYSCALE_16BPP(0X00101004),
-        RGB555_16BPP(0X00021005),
-        RGB565_16BPP(0X00021006),
-        ARGB1555_16BPP(0X00061007),
-        RGB_24BPP(0X00021808),
-        RGB_32BPP(0X00022009),
-        ARGB_32BPP(0X0026200A),
-        PARGB_32BPP(0X000E200B),
-        RGB_48BPP(0X0010300C),
-        ARGB_64BPP(0X0034400D),
-        PARGB_64BPP(0X001A400E),
-        ;
-
-        private static final BitField CANONICAL = BitFieldFactory.getInstance(0x00200000);
-        private static final BitField EXTCOLORS = BitFieldFactory.getInstance(0x00100000);
-        private static final BitField PREMULTI = BitFieldFactory.getInstance(0x00080000);
-        private static final BitField ALPHA = BitFieldFactory.getInstance(0x00040000);
-        private static final BitField GDI = BitFieldFactory.getInstance(0x00020000);
-        private static final BitField PALETTE = BitFieldFactory.getInstance(0x00010000);
-        private static final BitField BPP = BitFieldFactory.getInstance(0x0000FF00);
-        private static final BitField INDEX = BitFieldFactory.getInstance(0x000000FF);
-
-        public final int id;
-
-        EmfPlusPixelFormat(int id) {
-            this.id = id;
-        }
-
-        public static EmfPlusPixelFormat valueOf(int id) {
-            for (EmfPlusPixelFormat wrt : values()) {
-                if (wrt.id == id) return wrt;
-            }
-            return null;
-        }
-
-        /**
-         * The pixel format enumeration index.
-         */
-        public int getGDIEnumIndex() {
-            return id == -1 ? -1 : INDEX.getValue(id);
-        }
-
-        /**
-         * The total number of bits per pixel.
-         */
-        public int getBitsPerPixel() {
-            return id == -1 ? -1 : BPP.getValue(id);
-        }
-
-        /**
-         * If set, the pixel values are indexes into a palette.
-         * If clear, the pixel values are actual colors.
-         */
-        public boolean isPaletteIndexed() {
-            return id != -1 && PALETTE.isSet(id);
-        }
-
-        /**
-         * If set, the pixel format is supported in Windows GDI.
-         * If clear, the pixel format is not supported in Windows GDI.
-         */
-        public boolean isGDISupported() {
-            return id != -1 && GDI.isSet(id);
-        }
-
-        /**
-         * If set, the pixel format includes an alpha transparency component.
-         * If clear, the pixel format does not include a component that specifies transparency.
-         */
-        public boolean isAlpha() {
-            return id != -1 && ALPHA.isSet(id);
-        }
-
-        /**
-         * If set, each color component in the pixel has been premultiplied by the pixel's alpha transparency value.
-         * If clear, each color component is multiplied by the pixel's alpha transparency value when the source pixel
-         * is blended with the destination pixel.
-         */
-        public boolean isPreMultiplied() {
-            return id != -1 && PREMULTI.isSet(id);
-        }
-
-        /**
-         * If set, the pixel format supports extended colors in 16-bits per channel.
-         * If clear, extended colors are not supported.
-         */
-        public boolean isExtendedColors() {
-            return id != -1 && EXTCOLORS.isSet(id);
-        }
-
-        /**
-         * If set, the pixel format is "canonical", which means that 32 bits per pixel are
-         * supported, with 24-bits for color components and an 8-bit alpha channel.
-         * If clear, the pixel format is not canonical.
-         */
-        public boolean isCanonical() {
-            return id != -1 && CANONICAL.isSet(id);
-        }
-    }
-
-    public enum EmfPlusMetafileDataType {
-        Wmf(0x00000001),
-        WmfPlaceable(0x00000002),
-        Emf(0x00000003),
-        EmfPlusOnly(0x00000004),
-        EmfPlusDual(0x00000005);
-
-        public final int id;
-
-        EmfPlusMetafileDataType(int id) {
-            this.id = id;
-        }
-
-        public static EmfPlusMetafileDataType valueOf(int id) {
-            for (EmfPlusMetafileDataType wrt : values()) {
-                if (wrt.id == id) return wrt;
-            }
-            return null;
-        }
-    }
-
-    /**
-     * The WrapMode enumeration defines how the pattern from a texture or gradient brush is tiled
-     * across a shape or at shape boundaries, when it is smaller than the area being filled.
-     */
-    public enum EmfPlusWrapMode {
-        WRAP_MODE_TILE(0x00000000),
-        WRAP_MODE_TILE_FLIP_X(0x00000001),
-        WRAP_MODE_TILE_FLIP_Y(0x00000002),
-        WRAP_MODE_TILE_FLIP_XY(0x00000003),
-        WRAP_MODE_CLAMP(0x00000004)
-        ;
-
-        public final int id;
-
-        EmfPlusWrapMode(int id) {
-            this.id = id;
-        }
-
-        public static EmfPlusWrapMode valueOf(int id) {
-            for (EmfPlusWrapMode wrt : values()) {
-                if (wrt.id == id) return wrt;
-            }
-            return null;
-        }
-    }
-
-    public enum EmfPlusObjectClamp {
-        /** The object is clamped to a rectangle. */
-        RectClamp(0x00000000),
-        /** The object is clamped to a bitmap. */
-        BitmapClamp(0x00000001)
-        ;
-
-        public final int id;
-
-        EmfPlusObjectClamp(int id) {
-            this.id = id;
-        }
-
-        public static EmfPlusObjectClamp valueOf(int id) {
-            for (EmfPlusObjectClamp wrt : values()) {
-                if (wrt.id == id) return wrt;
-            }
-            return null;
-        }
-    }
 
     /**
      * The EmfPlusObject record specifies an object for use in graphics operations. The object definition
-     * can span multiple records, which is indicated by the value of the Flags field.
+     * can span multiple records), which is indicated by the value of the Flags field.
      */
     public static class EmfPlusObject implements HemfPlusRecord, EmfPlusObjectId {
 
@@ -400,189 +196,4 @@ public class HemfPlusObject {
             return dataSize;
         }
     }
-
-    public static class EmfPlusImage implements EmfPlusObjectData {
-        private final EmfPlusGraphicsVersion graphicsVersion = new EmfPlusGraphicsVersion();
-        private EmfPlusImageDataType imageDataType;
-        private int bitmapWidth;
-        private int bitmapHeight;
-        private int bitmapStride;
-        private EmfPlusPixelFormat pixelFormat;
-        private EmfPlusBitmapDataType bitmapType;
-        private byte[] imageData;
-        private EmfPlusMetafileDataType metafileType;
-        private int metafileDataSize;
-
-        public EmfPlusImageDataType getImageDataType() {
-            return imageDataType;
-        }
-
-        public byte[] getImageData() {
-            return imageData;
-        }
-
-        public EmfPlusPixelFormat getPixelFormat() {
-            return pixelFormat;
-        }
-
-        public EmfPlusBitmapDataType getBitmapType() {
-            return bitmapType;
-        }
-
-        public int getBitmapWidth() {
-            return bitmapWidth;
-        }
-
-        public int getBitmapHeight() {
-            return bitmapHeight;
-        }
-
-        public int getBitmapStride() {
-            return bitmapStride;
-        }
-
-        public EmfPlusMetafileDataType getMetafileType() {
-            return metafileType;
-        }
-
-        @Override
-        public long init(LittleEndianInputStream leis, long dataSize, EmfPlusObjectType objectType, int flags) throws IOException {
-            leis.mark(LittleEndianConsts.INT_SIZE);
-            long size = graphicsVersion.init(leis);
-
-            if (graphicsVersion.getGraphicsVersion() == null || graphicsVersion.getMetafileSignature() != 0xDBC01) {
-                // CONTINUABLE is not always correctly set, so we check the version field if this record is continued
-                imageDataType = EmfPlusImageDataType.CONTINUED;
-                leis.reset();
-                size = 0;
-            } else {
-                imageDataType = EmfPlusImageDataType.valueOf(leis.readInt());
-                size += LittleEndianConsts.INT_SIZE;
-            }
-
-            if (imageDataType == null) {
-                imageDataType = EmfPlusImageDataType.UNKNOWN;
-            }
-
-            int fileSize;
-            switch (imageDataType) {
-                default:
-                case UNKNOWN:
-                case CONTINUED:
-                    bitmapWidth = -1;
-                    bitmapHeight = -1;
-                    bitmapStride = -1;
-                    bitmapType = null;
-                    pixelFormat = null;
-
-                    fileSize = (int) (dataSize);
-                    break;
-
-                case BITMAP:
-                    // A 32-bit signed integer that specifies the width in pixels of the area occupied by the bitmap.
-                    // If the image is compressed, according to the Type field, this value is undefined and MUST be ignored.
-                    bitmapWidth = leis.readInt();
-                    // A 32-bit signed integer that specifies the height in pixels of the area occupied by the bitmap.
-                    // If the image is compressed, according to the Type field, this value is undefined and MUST be ignored.
-                    bitmapHeight = leis.readInt();
-                    // A 32-bit signed integer that specifies the byte offset between the beginning of one scan-line
-                    // and the next. This value is the number of bytes per pixel, which is specified in the PixelFormat
-                    // field, multiplied by the width in pixels, which is specified in the Width field.
-                    // The value of this field MUST be a multiple of four. If the image is compressed, according to the
-                    // Type field, this value is undefined and MUST be ignored.
-                    bitmapStride = leis.readInt();
-                    // A 32-bit unsigned integer that specifies the format of the pixels that make up the bitmap image.
-                    //  The supported pixel formats are specified in the PixelFormat enumeration
-                    int pixelFormatInt = leis.readInt();
-                    // A 32-bit unsigned integer that specifies the metafileType of data in the BitmapData field.
-                    // This value MUST be defined in the BitmapDataType enumeration
-                    bitmapType = EmfPlusBitmapDataType.valueOf(leis.readInt());
-                    size += 5 * LittleEndianConsts.INT_SIZE;
-
-                    pixelFormat = (bitmapType == EmfPlusBitmapDataType.PIXEL)
-                            ? EmfPlusPixelFormat.valueOf(pixelFormatInt)
-                            : EmfPlusPixelFormat.UNDEFINED;
-                    assert (pixelFormat != null);
-
-                    fileSize = (int) (dataSize - size);
-
-                    break;
-
-                case METAFILE:
-                    // A 32-bit unsigned integer that specifies the type of metafile that is embedded in the
-                    // MetafileData field. This value MUST be defined in the MetafileDataType enumeration
-                    metafileType = EmfPlusMetafileDataType.valueOf(leis.readInt());
-
-                    // A 32-bit unsigned integer that specifies the size in bytes of the
-                    // metafile data in the MetafileData field.
-                    metafileDataSize = leis.readInt();
-
-                    size += 2 * LittleEndianConsts.INT_SIZE;
-
-                    // ignore metafileDataSize, which might ignore a (placeable) header in front
-                    // and also use the remaining bytes, which might contain padding bytes ...
-                    fileSize = (int) (dataSize - size);
-                    break;
-            }
-
-            assert (fileSize <= dataSize - size);
-
-            imageData = IOUtils.toByteArray(leis, fileSize, MAX_OBJECT_SIZE);
-
-            // TODO: remove padding bytes between placeable WMF header and body?
-
-            return size + fileSize;
-        }
-    }
-
-    public static class EmfPlusImageAttributes implements EmfPlusObjectData {
-        private final EmfPlusGraphicsVersion graphicsVersion = new EmfPlusGraphicsVersion();
-        private EmfPlusWrapMode wrapMode;
-        private Color clampColor;
-        private EmfPlusObjectClamp objectClamp;
-
-        @Override
-        public long init(LittleEndianInputStream leis, long dataSize, EmfPlusObjectType objectType, int flags) throws IOException {
-            // An EmfPlusGraphicsVersion object that specifies the version of operating system graphics that
-            // was used to create this object.
-            long size = graphicsVersion.init(leis);
-
-            // A 32-bit field that is not used and MUST be ignored.
-            leis.skip(LittleEndianConsts.INT_SIZE);
-
-            // A 32-bit unsigned integer that specifies how to handle edge conditions with a value from the WrapMode enumeration
-            wrapMode = EmfPlusWrapMode.valueOf(leis.readInt());
-
-            // An EmfPlusARGB object that specifies the edge color to use when the WrapMode value is WrapModeClamp.
-            // This color is visible when the source rectangle processed by an EmfPlusDrawImage record is larger than the image itself.
-            byte[] buf = new byte[LittleEndianConsts.INT_SIZE];
-            leis.readFully(buf);
-            clampColor = new Color(buf[2], buf[1], buf[0], buf[3]);
-
-            // A 32-bit signed integer that specifies the object clamping behavior. It is not used until this object
-            // is applied to an image being drawn. This value MUST be one of the values defined in the following table.
-            objectClamp = EmfPlusObjectClamp.valueOf(leis.readInt());
-
-            // A value that SHOULD be set to zero and MUST be ignored upon receipt.
-            leis.skip(LittleEndianConsts.INT_SIZE);
-
-            return size + 5*LittleEndianConsts.INT_SIZE;
-        }
-
-        public EmfPlusGraphicsVersion getGraphicsVersion() {
-            return graphicsVersion;
-        }
-
-        public EmfPlusWrapMode getWrapMode() {
-            return wrapMode;
-        }
-
-        public Color getClampColor() {
-            return clampColor;
-        }
-
-        public EmfPlusObjectClamp getObjectClamp() {
-            return objectClamp;
-        }
-    }
 }

src/scratchpad/src/org/apache/poi/hemf/record/emfplus/HemfPlusPath.java

@@ -0,0 +1,150 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+==================================================================== */
+
+package org.apache.poi.hemf.record.emfplus;
+
+import java.awt.geom.Point2D;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.function.BiFunction;
+
+import org.apache.poi.hemf.record.emfplus.HemfPlusDraw.EmfPlusCompressed;
+import org.apache.poi.hemf.record.emfplus.HemfPlusDraw.EmfPlusRelativePosition;
+import org.apache.poi.hemf.record.emfplus.HemfPlusObject.EmfPlusObjectData;
+import org.apache.poi.hemf.record.emfplus.HemfPlusObject.EmfPlusObjectType;
+import org.apache.poi.util.BitField;
+import org.apache.poi.util.BitFieldFactory;
+import org.apache.poi.util.LittleEndianConsts;
+import org.apache.poi.util.LittleEndianInputStream;
+
+public class HemfPlusPath {
+
+    /** The PathPointType enumeration defines types of points on a graphics path. */
+    public enum EmfPlusPathPointType {
+        /** Specifies that the point is the starting point of a path. */
+        START,
+        /** Specifies that the point is one of the two endpoints of a line. */
+        LINE,
+        // not defined
+        UNUSED,
+        /** Specifies that the point is an endpoint or control point of a cubic Bezier curve */
+        BEZIER;
+    }
+
+    public static class EmfPlusPath implements EmfPlusObjectData, EmfPlusCompressed, EmfPlusRelativePosition {
+        /**
+         * If set, the point types in the PathPointTypes array are specified by EmfPlusPathPointTypeRLE objects,
+         * which use run-length encoding (RLE) compression, and/or EmfPlusPathPointType objects.
+         * If clear, the point types in the PathPointTypes array are specified by EmfPlusPathPointType objects.
+         */
+        private static final BitField RLE_COMPRESSED = BitFieldFactory.getInstance(0x00001000);
+
+        /** Specifies that a line segment that passes through the point is dashed. */
+        private static final BitField POINT_TYPE_DASHED = BitFieldFactory.getInstance(0x10);
+
+        /** Specifies that the point is a position marker. */
+        private static final BitField POINT_TYPE_MARKER = BitFieldFactory.getInstance(0x20);
+
+        /** Specifies that the point is the endpoint of a subpath. */
+        private static final BitField POINT_TYPE_CLOSE = BitFieldFactory.getInstance(0x80);
+
+        private static final BitField POINT_TYPE_ENUM = BitFieldFactory.getInstance(0x0F);
+
+
+        private static final BitField POINT_RLE_BEZIER = BitFieldFactory.getInstance(0x80);
+
+        private static final BitField POINT_RLE_COUNT = BitFieldFactory.getInstance(0x3F);
+
+        private final HemfPlusHeader.EmfPlusGraphicsVersion version = new HemfPlusHeader.EmfPlusGraphicsVersion();
+        private int pointFlags;
+        private Point2D[] pathPoints;
+        private byte[] pointTypes;
+
+        @Override
+        public long init(LittleEndianInputStream leis, long dataSize, EmfPlusObjectType objectType, int flags) throws IOException {
+            long size = version.init(leis);
+
+            // A 32-bit unsigned integer that specifies the number of points and associated point types that
+            // are defined by this object.
+            int pointCount = leis.readInt();
+
+            // A 16-bit unsigned integer that specifies how to interpret the points
+            // and associated point types that are defined by this object.
+            pointFlags = leis.readShort();
+
+            leis.skipFully(LittleEndianConsts.SHORT_SIZE);
+            size += 2* LittleEndianConsts.INT_SIZE;
+
+            BiFunction<LittleEndianInputStream,Point2D,Integer> readPoint;
+
+            if (isRelativePosition()) {
+                readPoint = HemfPlusDraw::readPointR;
+            } else if (isCompressed()) {
+                readPoint = HemfPlusDraw::readPointS;
+            } else {
+                readPoint = HemfPlusDraw::readPointF;
+            }
+
+            pathPoints = new Point2D[pointCount];
+            for (int i=0; i<pointCount; i++) {
+                pathPoints[i] = new Point2D.Double();
+                size += readPoint.apply(leis,pathPoints[i]);
+            }
+
+            pointTypes = new byte[pointCount];
+            final boolean isRLE = RLE_COMPRESSED.isSet(pointFlags);
+            if (isRLE) {
+                for (int i=0, rleCount; i<pointCount; i+=rleCount, size+=2) {
+                    rleCount = POINT_RLE_COUNT.getValue(leis.readByte());
+                    Arrays.fill(pointTypes, pointCount, pointCount+rleCount, leis.readByte());
+                }
+            } else {
+                leis.readFully(pointTypes);
+                size += pointCount;
+            }
+
+            int padding = (int)((4 - (size % 4)) % 4);
+            leis.skipFully(padding);
+            size += padding;
+
+            return size;
+        }
+
+        public boolean isPointDashed(int index) {
+            return POINT_TYPE_DASHED.isSet(pointTypes[index]);
+        }
+
+        public boolean isPointMarker(int index) {
+            return POINT_TYPE_MARKER.isSet(pointTypes[index]);
+        }
+
+        public boolean isPointClosed(int index) {
+            return POINT_TYPE_CLOSE.isSet(pointTypes[index]);
+        }
+
+        public EmfPlusPathPointType getPointType(int index) {
+            return EmfPlusPathPointType.values()[POINT_TYPE_ENUM.getValue(pointTypes[index])];
+        }
+
+        @Override
+        public int getFlags() {
+            return pointFlags;
+        }
+    }
+
+
+}

src/scratchpad/src/org/apache/poi/hemf/record/emfplus/HemfPlusPen.java

@@ -0,0 +1,602 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+==================================================================== */
+
+package org.apache.poi.hemf.record.emfplus;
+
+import static org.apache.poi.hemf.record.emf.HemfFill.readXForm;
+import static org.apache.poi.hemf.record.emfplus.HemfPlusDraw.readPointF;
+
+import java.awt.geom.AffineTransform;
+import java.awt.geom.Point2D;
+import java.io.IOException;
+import java.util.function.Consumer;
+
+import org.apache.poi.hemf.record.emfplus.HemfPlusHeader.EmfPlusGraphicsVersion;
+import org.apache.poi.hemf.record.emfplus.HemfPlusObject.EmfPlusObjectData;
+import org.apache.poi.hemf.record.emfplus.HemfPlusObject.EmfPlusObjectType;
+import org.apache.poi.hemf.record.emfplus.HemfPlusPath.EmfPlusPath;
+import org.apache.poi.util.BitField;
+import org.apache.poi.util.BitFieldFactory;
+import org.apache.poi.util.Internal;
+import org.apache.poi.util.LittleEndianConsts;
+import org.apache.poi.util.LittleEndianInputStream;
+
+public class HemfPlusPen {
+    /**
+     * The LineCapType enumeration defines types of line caps to use at the ends of lines that are drawn
+     * with graphics pens.
+     */
+    public enum EmfPlusLineCapType {
+        /** Specifies a squared-off line cap. The end of the line MUST be the last point in the line. */
+        FLAT(0X00000000),
+        /**
+         * Specifies a square line cap. The center of the square MUST be located at
+         * the last point in the line. The width of the square is the line width.
+         */
+        SQUARE(0X00000001),
+        /**
+         * Specifies a circular line cap. The center of the circle MUST be located at
+         * the last point in the line. The diameter of the circle is the line width.
+         */
+        ROUND(0X00000002),
+        /**
+         * Specifies a triangular line cap. The base of the triangle MUST be located
+         * at the last point in the line. The base of the triangle is the line width.
+         */
+        TRIANGLE(0X00000003),
+        /** Specifies that the line end is not anchored. */
+        NO_ANCHOR(0X00000010),
+        /**
+         * Specifies that the line end is anchored with a square line cap. The center of the square MUST be located
+         * at the last point in the line. The height and width of the square are the line width.
+         */
+        SQUARE_ANCHOR(0X00000011),
+        /**
+         * Specifies that the line end is anchored with a circular line cap. The center of the circle MUST be located
+         * at the last point in the line. The circle SHOULD be wider than the line.
+         */
+        ROUND_ANCHOR(0X00000012),
+        /**
+         * Specifies that the line end is anchored with a diamond-shaped line cap, which is a square turned at
+         * 45 degrees. The center of the diamond MUST be located at the last point in the line.
+         * The diamond SHOULD be wider than the line.
+         */
+        DIAMOND_ANCHOR(0X00000013),
+        /**
+         * Specifies that the line end is anchored with an arrowhead shape. The arrowhead point MUST be located at
+         * the last point in the line. The arrowhead SHOULD be wider than the line.
+         */
+        ARROW_ANCHOR(0X00000014),
+        /** Mask used to check whether a line cap is an anchor cap. */
+        ANCHOR_MASK(0X000000F0),
+        /** Specifies a custom line cap. */
+        CUSTOM(0X000000FF)
+        ;
+
+        public final int id;
+
+        EmfPlusLineCapType(int id) {
+            this.id = id;
+        }
+
+        public static EmfPlusLineCapType valueOf(int id) {
+            for (EmfPlusLineCapType wrt : values()) {
+                if (wrt.id == id) return wrt;
+            }
+            return null;
+        }
+    }
+
+    /**
+     * The LineJoinType enumeration defines ways to join two lines that are drawn by the same graphics
+     * pen and whose ends meet.
+     */
+    public enum EmfPlusLineJoin {
+        MITER(0X00000000),
+        BEVEL(0X00000001),
+        ROUND(0X00000002),
+        MITER_CLIPPED(0X00000003)
+        ;
+
+        public final int id;
+
+        EmfPlusLineJoin(int id) {
+            this.id = id;
+        }
+
+        public static EmfPlusLineJoin valueOf(int id) {
+            for (EmfPlusLineJoin wrt : values()) {
+                if (wrt.id == id) return wrt;
+            }
+            return null;
+        }
+
+    }
+
+    /** The LineStyle enumeration defines styles of lines that are drawn with graphics pens. */
+    public enum EmfPlusLineStyle {
+        /** Specifies a solid line. */
+        SOLID(0X00000000),
+        /** Specifies a dashed line. */
+        DASH(0X00000001),
+        /** Specifies a dotted line. */
+        DOT(0X00000002),
+        /** Specifies an alternating dash-dot line. */
+        DASH_DOT(0X00000003),
+        /** Specifies an alternating dash-dot-dot line. */
+        DASH_DOT_DOT(0X00000004),
+        /** Specifies a user-defined, custom dashed line. */
+        CUSTOM(0X00000005)
+        ;
+
+        public final int id;
+
+        EmfPlusLineStyle(int id) {
+            this.id = id;
+        }
+
+        public static EmfPlusLineStyle valueOf(int id) {
+            for (EmfPlusLineStyle wrt : values()) {
+                if (wrt.id == id) return wrt;
+            }
+            return null;
+        }
+    }
+
+    /**
+     * The DashedLineCapType enumeration defines types of line caps to use at the ends of dashed lines
+     * that are drawn with graphics pens.
+     */
+    public enum EmfPlusDashedLineCapType {
+        /** Specifies a flat dashed line cap. */
+        FLAT(0X00000000),
+        /** Specifies a round dashed line cap. */
+        ROUND(0X00000002),
+        /** Specifies a triangular dashed line cap. */
+        TRIANGLE(0X00000003)
+        ;
+
+        public final int id;
+
+        EmfPlusDashedLineCapType(int id) {
+            this.id = id;
+        }
+
+        public static EmfPlusDashedLineCapType valueOf(int id) {
+            for (EmfPlusDashedLineCapType wrt : values()) {
+                if (wrt.id == id) return wrt;
+            }
+            return null;
+        }
+    }
+
+    /**
+     * The PenAlignment enumeration defines the distribution of the width of the pen with respect to the
+     * line being drawn.
+     */
+    public enum EmfPlusPenAlignment {
+        /** Specifies that the EmfPlusPen object is centered over the theoretical line. */
+        CENTER(0X00000000),
+        /** Specifies that the pen is positioned on the inside of the theoretical line. */
+        INSET(0X00000001),
+        /** Specifies that the pen is positioned to the left of the theoretical line. */
+        LEFT(0X00000002),
+        /** Specifies that the pen is positioned on the outside of the theoretical line. */
+        OUTSET(0X00000003),
+        /** Specifies that the pen is positioned to the right of the theoretical line. */
+        RIGHT(0X00000004)
+        ;
+
+        public final int id;
+
+        EmfPlusPenAlignment(int id) {
+            this.id = id;
+        }
+
+        public static EmfPlusPenAlignment valueOf(int id) {
+            for (EmfPlusPenAlignment wrt : values()) {
+                if (wrt.id == id) return wrt;
+            }
+            return null;
+        }
+    }
+
+    public static class EmfPlusPen implements EmfPlusObjectData {
+
+
+        /**
+         * If set, a 2x3 transform matrix MUST be specified in the OptionalData field of an EmfPlusPenData object.
+         */
+        private final static BitField TRANSFORM = BitFieldFactory.getInstance(0x00000001);
+        /**
+         * If set, the style of a starting line cap MUST be specified in the OptionalData field of an
+         * EmfPlusPenData object.
+         */
+        private final static BitField START_CAP = BitFieldFactory.getInstance(0x00000002);
+        /**
+         * Indicates whether the style of an ending line cap MUST be specified in the OptionalData field
+         * of an EmfPlusPenData object.
+         */
+        private final static BitField END_CAP = BitFieldFactory.getInstance(0x00000004);
+        /**
+         * Indicates whether a line join type MUST be specified in the OptionalData
+         * field of an EmfPlusPenData object.
+         */
+        private final static BitField JOIN = BitFieldFactory.getInstance(0x00000008);
+        /**
+         * Indicates whether a miter limit MUST be specified in the OptionalData field of an EmfPlusPenData object.
+         */
+        private final static BitField MITER_LIMIT = BitFieldFactory.getInstance(0x00000010);
+        /**
+         * Indicates whether a line style MUST be specified in the OptionalData field of an EmfPlusPenData object.
+         */
+        private final static BitField LINE_STYLE = BitFieldFactory.getInstance(0x00000020);
+        /**
+         * Indicates whether a dashed line cap MUST be specified in the OptionalData field of an EmfPlusPenData object.
+         */
+        private final static BitField DASHED_LINE_CAP = BitFieldFactory.getInstance(0x00000040);
+        /**
+         * Indicates whether a dashed line offset MUST be specified in the OptionalData field of an EmfPlusPenData object.
+         */
+        private final static BitField DASHED_LINE_OFFSET = BitFieldFactory.getInstance(0x00000080);
+        /**
+         * Indicates whether an EmfPlusDashedLineData object MUST be specified in the
+         * OptionalData field of an EmfPlusPenData object.
+         */
+        private final static BitField DASHED_LINE = BitFieldFactory.getInstance(0x00000100);
+        /**
+         * Indicates whether a pen alignment MUST be specified in the OptionalData field of an EmfPlusPenData object.
+         */
+        private final static BitField NON_CENTER = BitFieldFactory.getInstance(0x00000200);
+        /**
+         * Indicates whether the length and content of a EmfPlusCompoundLineData object are present in the
+         * OptionalData field of an EmfPlusPenData object.
+         */
+        private final static BitField COMPOUND_LINE = BitFieldFactory.getInstance(0x00000400);
+        /**
+         * Indicates whether an EmfPlusCustomStartCapData object MUST be specified
+         * in the OptionalData field of an EmfPlusPenData object.y
+         */
+        private final static BitField CUSTOM_START_CAP = BitFieldFactory.getInstance(0x00000800);
+        /**
+         * Indicates whether an EmfPlusCustomEndCapData object MUST be specified in
+         * the OptionalData field of an EmfPlusPenData object.
+         */
+        private final static BitField CUSTOM_END_CAP = BitFieldFactory.getInstance(0x00001000);
+
+        private final EmfPlusGraphicsVersion graphicsVersion = new EmfPlusGraphicsVersion();
+
+
+        private int type;
+        private int penDataFlags;
+        private HemfPlusDraw.EmfPlusUnitType unitType;
+        private double penWidth;
+        private AffineTransform trans;
+        private EmfPlusLineCapType startCap, endCap;
+        private EmfPlusLineJoin join;
+        private Double mitterLimit;
+        private EmfPlusLineStyle style;
+        EmfPlusDashedLineCapType dashedLineCapType;
+        private Double dashOffset;
+        private double[] dashedLineData;
+        private EmfPlusPenAlignment penAlignment;
+        private double[] compoundLineData;
+        private EmfPlusCustomLineCap customStartCap;
+        private EmfPlusCustomLineCap customEndCap;
+
+        @Override
+        public long init(LittleEndianInputStream leis, long dataSize, EmfPlusObjectType objectType, int flags) throws IOException {
+            // An EmfPlusGraphicsVersion object that specifies the version of operating system graphics that
+            // was used to create this object.
+            long size = graphicsVersion.init(leis);
+            // This field MUST be set to zero.
+            type = leis.readInt();
+            // A 32-bit unsigned integer that specifies the data in the OptionalData field.
+            // This value MUST be composed of PenData flags
+            penDataFlags = leis.readInt();
+            // A 32-bit unsigned integer that specifies the measuring units for the pen.
+            // The value MUST be from the UnitType enumeration
+            unitType = HemfPlusDraw.EmfPlusUnitType.valueOf(leis.readInt());
+            // A 32-bit floating-point value that specifies the width of the line drawn by the pen in the units specified
+            // by the PenUnit field. If a zero width is specified, a minimum value is used, which is determined by the units.
+            penWidth = leis.readFloat();
+            size += 4* LittleEndianConsts.INT_SIZE;
+
+            if (TRANSFORM.isSet(penDataFlags)) {
+                // An optional EmfPlusTransformMatrix object that specifies a world space to device space transform for
+                // the pen. This field MUST be present if the PenDataTransform flag is set in the PenDataFlags field of
+                // the EmfPlusPenData object.
+                trans = new AffineTransform();
+                size += readXForm(leis, trans);
+            }
+
+            if (START_CAP.isSet(penDataFlags)) {
+                // An optional 32-bit signed integer that specifies the shape for the start of a line in the
+                // CustomStartCapData field. This field MUST be present if the PenDataStartCap flag is set in the
+                // PenDataFlags field of the EmfPlusPenData object, and the value MUST be defined in the LineCapType enumeration
+                startCap = EmfPlusLineCapType.valueOf(leis.readInt());
+                size += LittleEndianConsts.INT_SIZE;
+            }
+
+            if (END_CAP.isSet(penDataFlags)) {
+                // An optional 32-bit signed integer that specifies the shape for the end of a line in the
+                // CustomEndCapData field. This field MUST be present if the PenDataEndCap flag is set in the
+                // PenDataFlags field of the EmfPlusPenData object, and the value MUST be defined in the LineCapType enumeration.
+                endCap = EmfPlusLineCapType.valueOf(leis.readInt());
+                size += LittleEndianConsts.INT_SIZE;
+            }
+
+            if (JOIN.isSet(penDataFlags)) {
+                // An optional 32-bit signed integer that specifies how to join two lines that are drawn by the same pen
+                // and whose ends meet. This field MUST be present if the PenDataJoin flag is set in the PenDataFlags
+                // field of the EmfPlusPenData object, and the value MUST be defined in the LineJoinType enumeration
+                join = EmfPlusLineJoin.valueOf(leis.readInt());
+                size += LittleEndianConsts.INT_SIZE;
+            }
+
+            if (MITER_LIMIT.isSet(penDataFlags)) {
+                // An optional 32-bit floating-point value that specifies the miter limit, which is the maximum allowed
+                // ratio of miter length to line width. The miter length is the distance from the intersection of the
+                // line walls on the inside the join to the intersection of the line walls outside the join. The miter
+                // length can be large when the angle between two lines is small. This field MUST be present if the
+                // PenDataMiterLimit flag is set in the PenDataFlags field of the EmfPlusPenData object.
+                mitterLimit = (double)leis.readFloat();
+                size += LittleEndianConsts.INT_SIZE;
+            }
+
+            if (LINE_STYLE.isSet(penDataFlags)) {
+                // An optional 32-bit signed integer that specifies the style used for lines drawn with this pen object.
+                // This field MUST be present if the PenDataLineStyle flag is set in the PenDataFlags field of the
+                // EmfPlusPenData object, and the value MUST be defined in the LineStyle enumeration
+                style = EmfPlusLineStyle.valueOf(leis.readInt());
+                size += LittleEndianConsts.INT_SIZE;
+            }
+
+            if (DASHED_LINE_CAP.isSet(penDataFlags)) {
+                // An optional 32-bit signed integer that specifies the shape for both ends of each dash in a dashed line.
+                // This field MUST be present if the PenDataDashedLineCap flag is set in the PenDataFlags field of the
+                // EmfPlusPenData object, and the value MUST be defined in the DashedLineCapType enumeration
+                dashedLineCapType = EmfPlusDashedLineCapType.valueOf(leis.readInt());
+                size += LittleEndianConsts.INT_SIZE;
+            }
+
+            if (DASHED_LINE_OFFSET.isSet(penDataFlags)) {
+                // An optional 32-bit floating-point value that specifies the distance from the start of a line to the
+                // start of the first space in a dashed line pattern. This field MUST be present if the
+                // PenDataDashedLineOffset flag is set in the PenDataFlags field of the EmfPlusPenData object.
+                dashOffset = (double)leis.readFloat();
+                size += LittleEndianConsts.INT_SIZE;
+            }
+
+            if (DASHED_LINE.isSet(penDataFlags)) {
+                // A 32-bit unsigned integer that specifies the number of elements in the DashedLineData field.
+                int dashesSize = leis.readInt();
+                if (dashesSize < 0 || dashesSize > 1000) {
+                    throw new RuntimeException("Invalid dash data size");
+                }
+
+                // An array of DashedLineDataSize floating-point values that specify the lengths of the dashes and spaces in a dashed line.
+                dashedLineData = new double[dashesSize];
+                for (int i=0; i<dashesSize; i++) {
+                    dashedLineData[i] = leis.readFloat();
+                }
+
+                size += LittleEndianConsts.INT_SIZE * (dashesSize+1);
+            }
+
+            if (NON_CENTER.isSet(penDataFlags)) {
+                // An optional 32-bit signed integer that specifies the distribution of the pen width with respect to
+                // the coordinates of the line being drawn. This field MUST be present if the PenDataNonCenter flag is
+                // set in the PenDataFlags field of the EmfPlusPenData object, and the value MUST be defined in the
+                // PenAlignment enumeration
+                penAlignment = EmfPlusPenAlignment.valueOf(leis.readInt());
+                size += LittleEndianConsts.INT_SIZE;
+            }
+
+            if (COMPOUND_LINE.isSet(penDataFlags)) {
+                // A 32-bit unsigned integer that specifies the number of elements in the CompoundLineData field.
+                int compoundSize = leis.readInt();
+                if (compoundSize < 0 || compoundSize > 1000) {
+                    throw new RuntimeException("Invalid compound line data size");
+                }
+
+                // An array of CompoundLineDataSize floating-point values that specify the compound line of a pen.
+                // The elements MUST be in increasing order, and their values MUST be between 0.0 and 1.0, inclusive.
+                compoundLineData = new double[compoundSize];
+
+                for (int i=0; i<compoundSize; i++) {
+                    compoundLineData[i] = leis.readFloat();
+                }
+                size += LittleEndianConsts.INT_SIZE * (compoundSize+1);
+            }
+
+            if (CUSTOM_START_CAP.isSet(penDataFlags)) {
+                size += initCustomCap(c -> customStartCap = c, leis);
+            }
+
+            if (CUSTOM_END_CAP.isSet(penDataFlags)) {
+                size += initCustomCap(c -> customEndCap = c, leis);
+            }
+
+            return size;
+        }
+
+        private long initCustomCap(Consumer<EmfPlusCustomLineCap> setter, LittleEndianInputStream leis) throws IOException {
+            EmfPlusGraphicsVersion version = new EmfPlusGraphicsVersion();
+            long size = version.init(leis);
+
+            boolean adjustableArrow = (leis.readInt() != 0);
+            size += LittleEndianConsts.INT_SIZE;
+
+            EmfPlusCustomLineCap cap = (adjustableArrow) ? new EmfPlusAdjustableArrowCap() : new EmfPlusPathArrowCap();
+            size += cap.init(leis);
+
+            setter.accept(cap);
+
+            return size;
+        }
+
+        @Internal
+        public interface EmfPlusCustomLineCap {
+            long init(LittleEndianInputStream leis) throws IOException;
+        }
+
+        public static class EmfPlusPathArrowCap implements EmfPlusCustomLineCap {
+            /**
+             * If set, an EmfPlusFillPath object MUST be specified in the OptionalData field of the
+             * EmfPlusCustomLineCapData object for filling the custom line cap.
+             */
+            private static final BitField FILL_PATH = BitFieldFactory.getInstance(0x00000001);
+            /**
+             * If set, an EmfPlusLinePath object MUST be specified in the OptionalData field of the
+             * EmfPlusCustomLineCapData object for outlining the custom line cap.
+             */
+            private static final BitField LINE_PATH = BitFieldFactory.getInstance(0x00000002);
+
+
+            private int dataFlags;
+            private EmfPlusLineCapType baseCap;
+            private double baseInset;
+            private EmfPlusLineCapType startCap;
+            private EmfPlusLineCapType endCap;
+            private EmfPlusLineJoin join;
+            private double mitterLimit;
+            private double widthScale;
+            private final Point2D fillHotSpot = new Point2D.Double();
+            private final Point2D lineHotSpot = new Point2D.Double();
+            private EmfPlusPath fillPath;
+            private EmfPlusPath outlinePath;
+
+            @Override
+            public long init(LittleEndianInputStream leis) throws IOException {
+                // A 32-bit unsigned integer that specifies the data in the OptionalData field.
+                // This value MUST be composed of CustomLineCapData flags
+                dataFlags = leis.readInt();
+
+                // A 32-bit unsigned integer that specifies the value from the LineCap enumeration on which
+                // the custom line cap is based.
+                baseCap = EmfPlusLineCapType.valueOf(leis.readInt());
+
+                // A 32-bit floating-point value that specifies the distance between the
+                // beginning of the line cap and the end of the line.
+                baseInset = leis.readFloat();
+
+                // A 32-bit unsigned integer that specifies the value in the LineCap enumeration that indicates the line
+                // cap used at the start/end of the line to be drawn.
+                startCap = EmfPlusLineCapType.valueOf(leis.readInt());
+                endCap = EmfPlusLineCapType.valueOf(leis.readInt());
+
+                // A 32-bit unsigned integer that specifies the value in the LineJoin enumeration, which specifies how
+                // to join two lines that are drawn by the same pen and whose ends meet. At the intersection of the two
+                // line ends, a line join makes the connection look more continuous.
+                join = EmfPlusLineJoin.valueOf(leis.readInt());
+
+                // A 32-bit floating-point value that contains the limit of the thickness of the join on a mitered corner
+                // by setting the maximum allowed ratio of miter length to line width.
+                mitterLimit = leis.readFloat();
+
+                // A 32-bit floating-point value that specifies the amount by which to scale the custom line cap with
+                // respect to the width of the EmfPlusPen object that is used to draw the lines.
+                widthScale = leis.readFloat();
+
+                int size = 8* LittleEndianConsts.INT_SIZE;
+
+                // An EmfPlusPointF object that is not currently used. It MUST be set to {0.0, 0.0}.
+                size += readPointF(leis, fillHotSpot);
+                size += readPointF(leis, lineHotSpot);
+
+                if (FILL_PATH.isSet(dataFlags)) {
+                    fillPath = new EmfPlusPath();
+                    size += fillPath.init(leis, -1, null, -1);
+                }
+
+                if (LINE_PATH.isSet(dataFlags)) {
+                    outlinePath = new EmfPlusPath();
+                    size += outlinePath.init(leis, -1, null, -1);
+                }
+
+                return size;
+            }
+        }
+
+        public static class EmfPlusAdjustableArrowCap implements EmfPlusCustomLineCap {
+            private double width;
+            private double height;
+            private double middleInset;
+            private boolean isFilled;
+            private EmfPlusLineCapType startCap;
+            private EmfPlusLineCapType endCap;
+            private EmfPlusLineJoin join;
+            private double mitterLimit;
+            private double widthScale;
+            private final Point2D fillHotSpot = new Point2D.Double();
+            private final Point2D lineHotSpot = new Point2D.Double();
+
+            @Override
+            public long init(LittleEndianInputStream leis) throws IOException {
+                // A 32-bit floating-point value that specifies the width of the arrow cap.
+                // The width of the arrow cap is scaled by the width of the EmfPlusPen object that is used to draw the
+                // line being capped. For example, when drawing a capped line with a pen that has a width of 5 pixels,
+                // and the adjustable arrow cap object has a width of 3, the actual arrow cap is drawn 15 pixels wide.
+                width = leis.readFloat();
+
+                // A 32-bit floating-point value that specifies the height of the arrow cap.
+                // The height of the arrow cap is scaled by the width of the EmfPlusPen object that is used to draw the
+                // line being capped. For example, when drawing a capped line with a pen that has a width of 5 pixels,
+                // and the adjustable arrow cap object has a height of 3, the actual arrow cap is drawn 15 pixels high.
+                height = leis.readFloat();
+
+                // A 32-bit floating-point value that specifies the number of pixels between the outline of the arrow
+                // cap and the fill of the arrow cap.
+                middleInset = leis.readFloat();
+
+                // A 32-bit Boolean value that specifies whether the arrow cap is filled.
+                // If the arrow cap is not filled, only the outline is drawn.
+                isFilled = (leis.readInt() != 0);
+
+                // A 32-bit unsigned integer that specifies the value in the LineCap enumeration that indicates
+                // the line cap to be used at the start/end of the line to be drawn.
+                startCap = EmfPlusLineCapType.valueOf(leis.readInt());
+                endCap = EmfPlusLineCapType.valueOf(leis.readInt());
+
+                // 32-bit unsigned integer that specifies the value in the LineJoin enumeration that specifies how to
+                // join two lines that are drawn by the same pen and whose ends meet. At the intersection of the two
+                // line ends, a line join makes the connection look more continuous.
+                join = EmfPlusLineJoin.valueOf(leis.readInt());
+
+                // A 32-bit floating-point value that specifies the limit of the thickness of the join on a mitered
+                // corner by setting the maximum allowed ratio of miter length to line width.
+                mitterLimit = leis.readFloat();
+
+                // A 32-bit floating-point value that specifies the amount by which to scale an EmfPlusCustomLineCap
+                // object with respect to the width of the graphics pen that is used to draw the lines.
+                widthScale = leis.readFloat();
+
+                int size = 9 * LittleEndianConsts.INT_SIZE;
+
+                // An EmfPlusPointF object that is not currently used. It MUST be set to {0.0, 0.0}.
+                size += readPointF(leis, fillHotSpot);
+
+                // An EmfPlusPointF object that is not currently used. It MUST be set to {0.0, 0.0}.
+                size += readPointF(leis, lineHotSpot);
+
+                return size;
+            }
+        }
+
+    }
+}

src/scratchpad/src/org/apache/poi/hemf/record/emfplus/HemfPlusRegion.java

@@ -0,0 +1,173 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+==================================================================== */
+
+package org.apache.poi.hemf.record.emfplus;
+
+import static org.apache.poi.hemf.record.emfplus.HemfPlusDraw.readRectF;
+
+import java.awt.geom.Rectangle2D;
+import java.io.IOException;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+import org.apache.poi.hemf.record.emfplus.HemfPlusHeader.EmfPlusGraphicsVersion;
+import org.apache.poi.hemf.record.emfplus.HemfPlusObject.EmfPlusObjectData;
+import org.apache.poi.hemf.record.emfplus.HemfPlusObject.EmfPlusObjectType;
+import org.apache.poi.hemf.record.emfplus.HemfPlusPath.EmfPlusPath;
+import org.apache.poi.util.LittleEndianConsts;
+import org.apache.poi.util.LittleEndianInputStream;
+
+public class HemfPlusRegion {
+    public enum EmfPlusRegionNodeDataType {
+        /**
+         * Specifies a region node with child nodes. A Boolean AND operation SHOULD be applied to the left and right
+         * child nodes specified by an EmfPlusRegionNodeChildNodes object
+         */
+        AND(0X00000001, EmfPlusRegionNode::new),
+        /**
+         * Specifies a region node with child nodes. A Boolean OR operation SHOULD be applied to the left and right
+         * child nodes specified by an EmfPlusRegionNodeChildNodes object.
+         */
+        OR(0X00000002, EmfPlusRegionNode::new),
+        /**
+         * Specifies a region node with child nodes. A Boolean XOR operation SHOULD be applied to the left and right
+         * child nodes specified by an EmfPlusRegionNodeChildNodes object.
+         */
+        XOR(0X00000003, EmfPlusRegionNode::new),
+        /**
+         * Specifies a region node with child nodes. A Boolean operation, defined as "the part of region 1 that is excluded
+         * from region 2", SHOULD be applied to the left and right child nodes specified by an EmfPlusRegionNodeChildNodes object.
+         */
+        EXCLUDE(0X00000004, EmfPlusRegionNode::new),
+        /**
+         * Specifies a region node with child nodes. A Boolean operation, defined as "the part of region 2 that is excluded
+         * from region 1", SHOULD be applied to the left and right child nodes specified by an EmfPlusRegionNodeChildNodes object.
+         */
+        COMPLEMENT(0X00000005, EmfPlusRegionNode::new),
+        /**
+         * Specifies a region node with no child nodes.
+         * The RegionNodeData field SHOULD specify a boundary with an EmfPlusRectF object.
+         */
+        RECT(0X10000000, EmfPlusRegionRect::new),
+        /**
+         * Specifies a region node with no child nodes.
+         * The RegionNodeData field SHOULD specify a boundary with an EmfPlusRegionNodePath object
+         */
+        PATH(0X10000001, EmfPlusRegionPath::new),
+        /** Specifies a region node with no child nodes. The RegionNodeData field SHOULD NOT be present. */
+        EMPTY(0X10000002, EmfPlusRegionEmpty::new),
+        /** Specifies a region node with no child nodes, and its bounds are not defined. */
+        INFINITE(0X10000003, EmfPlusRegionInfinite::new)
+        ;
+
+        public final int id;
+        public final Supplier<EmfPlusRegionNodeData> constructor;
+
+        EmfPlusRegionNodeDataType(int id, Supplier<EmfPlusRegionNodeData> constructor) {
+            this.id = id;
+            this.constructor = constructor;
+        }
+
+        public static EmfPlusRegionNodeDataType valueOf(int id) {
+            for (EmfPlusRegionNodeDataType wrt : values()) {
+                if (wrt.id == id) return wrt;
+            }
+            return null;
+        }
+    }
+
+    public static class EmfPlusRegion implements EmfPlusObjectData {
+
+        private final EmfPlusGraphicsVersion version = new EmfPlusGraphicsVersion();
+        private EmfPlusRegionNodeData regionNode;
+
+        @Override
+        public long init(LittleEndianInputStream leis, long dataSize, EmfPlusObjectType objectType, int flags) throws IOException {
+            long size = version.init(leis);
+
+            // A 32-bit unsigned integer that specifies the number of child nodes in the RegionNode field.
+            int nodeCount = leis.readInt();
+            size += LittleEndianConsts.INT_SIZE;
+
+            // An array of RegionNodeCount+1 EmfPlusRegionNode objects. Regions are specified as a binary tree of
+            // region nodes, and each node MUST either be a terminal node or specify one or two child nodes.
+            // RegionNode MUST contain at least one element.
+            size += readNode(leis, d -> regionNode = d);
+
+            return size;
+        }
+
+
+    }
+
+
+    public interface EmfPlusRegionNodeData {
+        long init(LittleEndianInputStream leis) throws IOException;
+    }
+
+    public static class EmfPlusRegionPath extends EmfPlusPath implements EmfPlusRegionNodeData {
+        public long init(LittleEndianInputStream leis) throws IOException {
+            int dataSize = leis.readInt();
+            return super.init(leis, dataSize, EmfPlusObjectType.PATH, 0) + LittleEndianConsts.INT_SIZE;
+        }
+    }
+
+    public static class EmfPlusRegionInfinite implements EmfPlusRegionNodeData {
+        @Override
+        public long init(LittleEndianInputStream leis) throws IOException {
+            return 0;
+        }
+    }
+
+    public static class EmfPlusRegionEmpty implements EmfPlusRegionNodeData {
+        @Override
+        public long init(LittleEndianInputStream leis) throws IOException {
+            return 0;
+        }
+    }
+
+    public static class EmfPlusRegionRect implements EmfPlusRegionNodeData {
+        private final Rectangle2D rect = new Rectangle2D.Double();
+
+        @Override
+        public long init(LittleEndianInputStream leis) {
+            return readRectF(leis, rect);
+        }
+    }
+
+    public static class EmfPlusRegionNode implements EmfPlusRegionNodeData {
+        private EmfPlusRegionNodeData left, right;
+
+        @Override
+        public long init(LittleEndianInputStream leis) throws IOException {
+            long size = readNode(leis, n -> left = n);
+            size += readNode(leis, n -> right = n);
+            return size;
+        }
+    }
+
+
+    private static long readNode(LittleEndianInputStream leis, Consumer<EmfPlusRegionNodeData> con) throws IOException {
+        // A 32-bit unsigned integer that specifies the type of data in the RegionNodeData field.
+        // This value MUST be defined in the RegionNodeDataType enumeration
+        EmfPlusRegionNodeDataType type = EmfPlusRegionNodeDataType.valueOf(leis.readInt());
+        assert(type != null);
+        EmfPlusRegionNodeData nd = type.constructor.get();
+        con.accept(nd);
+        return LittleEndianConsts.INT_SIZE + nd.init(leis);
+    }
+}

src/scratchpad/src/org/apache/poi/hemf/usermodel/HemfEmbeddedIterator.java

@@ -36,7 +36,11 @@ import javax.imageio.ImageIO;
 
 import org.apache.poi.hemf.record.emf.HemfComment;
 import org.apache.poi.hemf.record.emf.HemfRecord;
+import org.apache.poi.hemf.record.emfplus.HemfPlusImage.EmfPlusBitmapDataType;
+import org.apache.poi.hemf.record.emfplus.HemfPlusImage.EmfPlusImage;
+import org.apache.poi.hemf.record.emfplus.HemfPlusImage.EmfPlusPixelFormat;
 import org.apache.poi.hemf.record.emfplus.HemfPlusObject;
+import org.apache.poi.hemf.record.emfplus.HemfPlusObject.EmfPlusObject;
 import org.apache.poi.hwmf.record.HwmfBitmapDib;
 import org.apache.poi.hwmf.record.HwmfFill;
 import org.apache.poi.hwmf.usermodel.HwmfEmbedded;
@@ -105,7 +109,7 @@ public class HemfEmbeddedIterator implements Iterator<HwmfEmbedded> {
                     return true;
                 }
 
-                if (obj instanceof HemfPlusObject.EmfPlusObject && ((HemfPlusObject.EmfPlusObject)obj).getObjectType() == HemfPlusObject.EmfPlusObjectType.IMAGE) {
+                if (obj instanceof EmfPlusObject && ((EmfPlusObject)obj).getObjectType() == HemfPlusObject.EmfPlusObjectType.IMAGE) {
                     current = obj;
                     return true;
                 }
@@ -196,13 +200,13 @@ public class HemfEmbeddedIterator implements Iterator<HwmfEmbedded> {
     }
 
     private HwmfEmbedded checkEmfPlusObject() {
-        if (!(current instanceof HemfPlusObject.EmfPlusObject)) {
+        if (!(current instanceof EmfPlusObject)) {
             return null;
         }
 
-        HemfPlusObject.EmfPlusObject epo = (HemfPlusObject.EmfPlusObject)current;
+        EmfPlusObject epo = (EmfPlusObject)current;
         assert(epo.getObjectType() == HemfPlusObject.EmfPlusObjectType.IMAGE);
-        HemfPlusObject.EmfPlusImage img = epo.getObjectData();
+        EmfPlusImage img = epo.getObjectData();
         assert(img.getImageDataType() != null);
 
         HwmfEmbedded emb = getEmfPlusImageData();
@@ -210,7 +214,7 @@ public class HemfEmbeddedIterator implements Iterator<HwmfEmbedded> {
         HwmfEmbeddedType et;
         switch (img.getImageDataType()) {
             case BITMAP:
-                if (img.getBitmapType() == HemfPlusObject.EmfPlusBitmapDataType.COMPRESSED) {
+                if (img.getBitmapType() == EmfPlusBitmapDataType.COMPRESSED) {
                     switch (FileMagic.valueOf(emb.getRawData())) {
                         case JPEG:
                             et = HwmfEmbeddedType.JPEG;
@@ -262,11 +266,11 @@ public class HemfEmbeddedIterator implements Iterator<HwmfEmbedded> {
     /**
      * Compress GDIs internal format to something useful
      */
-    private void compressGDIBitmap(HemfPlusObject.EmfPlusImage img, HwmfEmbedded emb, HwmfEmbeddedType et) {
+    private void compressGDIBitmap(EmfPlusImage img, HwmfEmbedded emb, HwmfEmbeddedType et) {
         final int width = img.getBitmapWidth();
         final int height = img.getBitmapHeight();
         final int stride = img.getBitmapStride();
-        final HemfPlusObject.EmfPlusPixelFormat pf = img.getPixelFormat();
+        final EmfPlusPixelFormat pf = img.getPixelFormat();
 
         int[] nBits, bOffs;
         switch (pf) {
@@ -306,14 +310,14 @@ public class HemfEmbeddedIterator implements Iterator<HwmfEmbedded> {
 
 
     private HwmfEmbedded getEmfPlusImageData() {
-        HemfPlusObject.EmfPlusObject epo = (HemfPlusObject.EmfPlusObject)current;
+        EmfPlusObject epo = (EmfPlusObject)current;
         assert(epo.getObjectType() == HemfPlusObject.EmfPlusObjectType.IMAGE);
 
         final int objectId = epo.getObjectId();
 
         HwmfEmbedded emb = new HwmfEmbedded();
 
-        HemfPlusObject.EmfPlusImage img = (HemfPlusObject.EmfPlusImage)epo.getObjectData();
+        EmfPlusImage img = (EmfPlusImage)epo.getObjectData();
         assert(img.getImageDataType() != null);
 
         ByteArrayOutputStream bos = new ByteArrayOutputStream();
@@ -324,10 +328,10 @@ public class HemfEmbeddedIterator implements Iterator<HwmfEmbedded> {
                 current = null;
                 //noinspection ConstantConditions
                 if (hasNext() &&
-                    (current instanceof HemfPlusObject.EmfPlusObject) &&
-                    ((epo = (HemfPlusObject.EmfPlusObject) current).getObjectId() == objectId)
+                    (current instanceof EmfPlusObject) &&
+                    ((epo = (EmfPlusObject) current).getObjectId() == objectId)
                 ) {
-                    img = (HemfPlusObject.EmfPlusImage)epo.getObjectData();
+                    img = (EmfPlusImage)epo.getObjectData();
                 } else {
                     return emb;
                 }

src/scratchpad/testcases/org/apache/poi/hemf/usermodel/HemfPictureTest.java

@@ -94,7 +94,7 @@ public class HemfPictureTest {
 
                 if (entry.isDirectory() || !etName.endsWith(".emf") || passed.contains(etName)) continue;
 
-                if (!etName.equals("emfs/commoncrawl2/2S/2SYMYPLNJURGCXJKLNZCJQGIBHVMQTRS_0.emf")) continue;
+                // if (!etName.equals("emfs/commoncrawl2/2S/2SYMYPLNJURGCXJKLNZCJQGIBHVMQTRS_0.emf")) continue;
 
                 // emfs/commoncrawl2/ZJ/ZJT2BZPLQR7DKSKYLYL6GRDEUM2KIO5F_4.emf
                 // emfs/govdocs1/005/005203.ppt_3.emf