Variant.VT_FILETIME, Variant.VT_LPSTR, Variant.VT_LPWSTR,
Variant.VT_CF, Variant.VT_BOOL };
-
+
private static final POILogger logger = POILogFactory.getLogger(VariantSupport.class);
//arbitrarily selected; may need to increase
private static final int MAX_RECORD_LENGTH = 100_000;
* been issued for.
*/
private static List<Long> unsupportedMessage;
-
+
private static final byte[] paddingBytes = new byte[3];
-
+
/**
* Specifies whether warnings about unsupported variant types are to be
* written to {@code System.err} or not.
LittleEndianByteArrayInputStream lei = new LittleEndianByteArrayInputStream(src, offset);
return read( lei, length, type, codepage );
}
-
+
public static Object read( LittleEndianByteArrayInputStream lei,
final int length, final long type, final int codepage )
throws ReadingNotSupportedException, UnsupportedEncodingException {
*
* August 20, 2009
*/
- // l1 = LittleEndian.getInt(src, o1); o1 += LittleEndian.INT_SIZE;
+ // l1 = LittleEndian.getInt(src, o1); o1 += LittleEndianConts.INT_SIZE;
// }
// final byte[] v = new byte[l1];
// System.arraycopy(src, o1, v, 0, v.length);
case Variant.VT_BOOL:
VariantBool bool = (VariantBool) typedPropertyValue.getValue();
return bool.getValue();
-
+
/*
* it is not very good, but what can do without breaking current
* API? --sergey
if (bi.bitLength() > 64) {
throw new WritingNotSupportedException(type, value);
}
-
+
byte[] biBytesBE = bi.toByteArray(), biBytesLE = new byte[LittleEndianConsts.LONG_SIZE];
int i=biBytesBE.length;
for (byte b : biBytesBE) {
}
i--;
}
-
+
out.write(biBytesLE);
length = LittleEndianConsts.LONG_SIZE;
}
}
break;
}
-
+
case Variant.VT_R8:
if (value instanceof Number) {
LittleEndian.putDouble( ((Number)value).doubleValue(), out);
throw new WritingNotSupportedException(type, value);
}
}
-
+
/* pad values to 4-bytes */
int padding = (4-(length & 0x3)) & 0x3;
out.write(paddingBytes, 0, padding);
import org.apache.poi.hssf.record.ObjRecord;
import org.apache.poi.ss.usermodel.ClientAnchor.AnchorType;
import org.apache.poi.ss.usermodel.Picture;
+import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.ss.util.ImageUtils;
-import org.apache.poi.util.POILogFactory;
-import org.apache.poi.util.POILogger;
+import org.apache.poi.util.Removal;
import org.apache.poi.util.StringUtil;
/**
* Represents a escher picture. Eg. A GIF, JPEG etc...
*/
public class HSSFPicture extends HSSFSimpleShape implements Picture {
- @SuppressWarnings("unused")
- private static POILogger logger = POILogFactory.getLogger(HSSFPicture.class);
-
- public static final int PICTURE_TYPE_EMF = HSSFWorkbook.PICTURE_TYPE_EMF; // Windows Enhanced Metafile
- public static final int PICTURE_TYPE_WMF = HSSFWorkbook.PICTURE_TYPE_WMF; // Windows Metafile
- public static final int PICTURE_TYPE_PICT = HSSFWorkbook.PICTURE_TYPE_PICT; // Macintosh PICT
- public static final int PICTURE_TYPE_JPEG = HSSFWorkbook.PICTURE_TYPE_JPEG; // JFIF
- public static final int PICTURE_TYPE_PNG = HSSFWorkbook.PICTURE_TYPE_PNG; // PNG
- public static final int PICTURE_TYPE_DIB = HSSFWorkbook.PICTURE_TYPE_DIB; // Windows DIB
+ /**
+ * Windows Enhanced Metafile
+ * @deprecated use {@link Workbook#PICTURE_TYPE_EMF}
+ */
+ @Removal(version = "5.0.0")
+ @Deprecated
+ public static final int PICTURE_TYPE_EMF = Workbook.PICTURE_TYPE_EMF;
+
+ /**
+ * Windows Metafile
+ * @deprecated use {@link Workbook#PICTURE_TYPE_WMF}
+ */
+ @Removal(version = "5.0.0")
+ @Deprecated
+ public static final int PICTURE_TYPE_WMF = Workbook.PICTURE_TYPE_WMF;
+
+ /**
+ * Macintosh PICT
+ * @deprecated use {@link Workbook#PICTURE_TYPE_PICT}
+ */
+ @Removal(version = "5.0.0")
+ @Deprecated
+ public static final int PICTURE_TYPE_PICT = Workbook.PICTURE_TYPE_PICT;
+
+ /**
+ * JFIF / JPEG
+ * @deprecated use {@link Workbook#PICTURE_TYPE_JPEG}
+ */
+ @Removal(version = "5.0.0")
+ @Deprecated
+ public static final int PICTURE_TYPE_JPEG = Workbook.PICTURE_TYPE_JPEG;
+
+ /**
+ * PNG
+ * @deprecated use {@link Workbook#PICTURE_TYPE_PNG}
+ */
+ @Removal(version = "5.0.0")
+ @Deprecated
+ public static final int PICTURE_TYPE_PNG = Workbook.PICTURE_TYPE_PNG;
+
+ /**
+ * Windows DIB
+ * @deprecated use {@link Workbook#PICTURE_TYPE_DIB}
+ */
+ @Removal(version = "5.0.0")
+ @Deprecated
+ public static final int PICTURE_TYPE_DIB = Workbook.PICTURE_TYPE_DIB;
public HSSFPicture(EscherContainerRecord spContainer, ObjRecord objRecord) {
super(spContainer, objRecord);
protected EscherContainerRecord createSpContainer() {
EscherContainerRecord spContainer = super.createSpContainer();
EscherOptRecord opt = spContainer.getChildById(EscherOptRecord.RECORD_ID);
+ assert(opt != null);
opt.removeEscherProperty(EscherPropertyTypes.LINESTYLE__LINEDASHING);
opt.removeEscherProperty(EscherPropertyTypes.LINESTYLE__NOLINEDRAWDASH);
spContainer.removeChildRecord(spContainer.getChildById(EscherTextboxRecord.RECORD_ID));
/**
* Reset the image to the dimension of the embedded image
- *
+ *
* <p>
* Please note, that this method works correctly only for workbooks
* with default font size (Arial 10pt for .xls).
public void resize(double scale) {
resize(scale,scale);
}
-
+
/**
* Resize the image
* <p>
* <code>resize(1.0,1.0)</code> keeps the original size,<br>
* <code>resize(0.5,0.5)</code> resize to 50% of the original,<br>
* <code>resize(2.0,2.0)</code> resizes to 200% of the original.<br>
- * <code>resize({@link Double#MAX_VALUE},{@link Double#MAX_VALUE})</code> resizes to the dimension of the embedded image.
+ * <code>resize({@link Double#MAX_VALUE},{@link Double#MAX_VALUE})</code> resizes to the dimension of the embedded image.
* </p>
*
* @param scaleX the amount by which the image width is multiplied relative to the original width.
public HSSFClientAnchor getPreferredSize(double scale){
return getPreferredSize(scale, scale);
}
-
+
/**
* Calculate the preferred size for this picture.
*
int type = bse.getBlipTypeWin32();
return ImageUtils.getImageDimension(new ByteArrayInputStream(data), type);
}
-
+
/**
* Return picture data for this shape
*
if (picIdx == -1) {
return null;
}
-
+
HSSFPatriarch patriarch = getPatriarch();
HSSFShape parent = getParent();
while(patriarch == null && parent != null) {
? ""
: StringUtil.getFromUnicodeLE(propFile.getComplexData()).trim();
}
-
+
public void setFileName(String data){
- // TODO: add trailing \u0000?
+ // TODO: add trailing \u0000?
byte[] bytes = StringUtil.getToUnicodeLE(data);
EscherComplexProperty prop = new EscherComplexProperty(EscherPropertyTypes.BLIP__BLIPFILENAME, true, bytes.length);
prop.setComplexData(bytes);
ObjRecord obj = (ObjRecord) getObjRecord().cloneViaReserialise();
return new HSSFPicture(spContainer, obj);
}
-
+
/**
* @return the anchor that is used by this picture.
*/
return (a instanceof HSSFClientAnchor) ? (HSSFClientAnchor)a : null;
}
-
+
/**
* @return the sheet which contains the picture shape
*/
import org.apache.poi.poifs.common.POIFSBigBlockSize;
import org.apache.poi.poifs.common.POIFSConstants;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
/**
* A block of block allocation table entries. BATBlocks are created
private POIFSBigBlockSize bigBlockSize;
/**
- * For a regular fat block, these are 128 / 1024
+ * For a regular fat block, these are 128 / 1024
* next sector values.
* For a XFat (DIFat) block, these are 127 / 1023
* next sector values, then a chaining value.
*/
private int[] _values;
-
+
/**
* Does this BATBlock have any free sectors in it?
*/
private boolean _has_free_sectors;
-
+
/**
* Where in the file are we?
*/
private int ourBlockIndex;
-
+
/**
* Create a single instance initialized with default values
*/
private BATBlock(POIFSBigBlockSize bigBlockSize)
{
this.bigBlockSize = bigBlockSize;
-
+
int _entries_per_block = bigBlockSize.getBATEntriesPerBlock();
_values = new int[_entries_per_block];
_has_free_sectors = true;
{
// Create an empty block
BATBlock block = new BATBlock(bigBlockSize);
-
+
// Fill it
- byte[] buffer = new byte[LittleEndian.INT_SIZE];
+ byte[] buffer = new byte[LittleEndianConsts.INT_SIZE];
for(int i=0; i<block._values.length; i++) {
data.get(buffer);
block._values[i] = LittleEndian.getInt(buffer);
}
block.recomputeFree();
-
+
// All done
return block;
}
-
+
/**
* Creates a single BATBlock, with all the values set to empty.
*/
* number of FAT (BAT) sectors specified. (We don't care if those BAT
* blocks come from the 109 in the header, or from header + XBATS, it
* won't affect the calculation)
- *
+ *
* The actual file size will be between [size of fatCount-1 blocks] and
* [size of fatCount blocks].
* For 512 byte block sizes, this means we may over-estimate by up to 65kb.
final int numBATs) {
// Header isn't FAT addressed
long size = 1;
-
+
// The header has up to 109 BATs, and extra ones are referenced
// from XBATs
// However, all BATs can contain 128/1024 blocks
size += (((long)numBATs) * bigBlockSize.getBATEntriesPerBlock());
-
+
// So far we've been in sector counts, turn into bytes
return size * bigBlockSize.getBigBlockSize();
}
* and the relative index within it.
* The List of BATBlocks must be in sequential order
*/
- public static BATBlockAndIndex getBATBlockAndIndex(final int offset,
+ public static BATBlockAndIndex getBATBlockAndIndex(final int offset,
final HeaderBlock header, final List<BATBlock> bats) {
POIFSBigBlockSize bigBlockSize = header.getBigBlockSize();
int entriesPerBlock = bigBlockSize.getBATEntriesPerBlock();
-
+
int whichBAT = offset / entriesPerBlock;
int index = offset % entriesPerBlock;
return new BATBlockAndIndex( index, bats.get(whichBAT) );
}
-
+
/**
* Returns the BATBlock that handles the specified offset,
* and the relative index within it, for the mini stream.
* The List of BATBlocks must be in sequential order
*/
- public static BATBlockAndIndex getSBATBlockAndIndex(final int offset,
+ public static BATBlockAndIndex getSBATBlockAndIndex(final int offset,
final HeaderBlock header, final List<BATBlock> sbats) {
return getBATBlockAndIndex(offset, header, sbats);
}
-
+
/**
* Does this BATBlock have any free sectors in it, or
* is it full?
}
return usedSectors;
}
-
+
public int getValueAt(int relativeOffset) {
if(relativeOffset >= _values.length) {
throw new ArrayIndexOutOfBoundsException(
- "Unable to fetch offset " + relativeOffset + " as the " +
+ "Unable to fetch offset " + relativeOffset + " as the " +
"BAT only contains " + _values.length + " entries"
- );
+ );
}
return _values[relativeOffset];
}
public void setValueAt(int relativeOffset, int value) {
int oldValue = _values[relativeOffset];
_values[relativeOffset] = value;
-
+
// Do we need to re-compute the free?
if(value == POIFSConstants.UNUSED_BLOCK) {
_has_free_sectors = true;
recomputeFree();
}
}
-
+
/**
* Record where in the file we live
*/
this.ourBlockIndex = index;
}
/**
- * Retrieve where in the file we live
+ * Retrieve where in the file we live
*/
public int getOurBlockIndex() {
return ourBlockIndex;
// Save it out
block.put( serialize() );
}
-
+
private byte[] serialize() {
// Create the empty array
byte[] data = new byte[ bigBlockSize.getBigBlockSize() ];
-
+
// Fill in the values
int offset = 0;
for (int _value : _values) {
LittleEndian.putInt(data, offset, _value);
- offset += LittleEndian.INT_SIZE;
+ offset += LittleEndianConsts.INT_SIZE;
}
-
+
// Done
return data;
}
import org.apache.poi.util.Internal;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
import org.apache.poi.util.POILogFactory;
import org.apache.poi.util.POILogger;
import org.apache.poi.util.Units;
public ImageHeaderWMF(byte[] data, final int off) {
int offset = off;
- int key = LittleEndian.getInt(data, offset); offset += LittleEndian.INT_SIZE; //header key
+ int key = LittleEndian.getInt(data, offset); offset += LittleEndianConsts.INT_SIZE; //header key
if (key != APMHEADER_KEY) {
LOG.log(POILogger.WARN, "WMF file doesn't contain a placeable header - ignore parsing");
handle = 0;
return;
}
- handle = LittleEndian.getUShort(data, offset); offset += LittleEndian.SHORT_SIZE;
- left = LittleEndian.getShort(data, offset); offset += LittleEndian.SHORT_SIZE;
- top = LittleEndian.getShort(data, offset); offset += LittleEndian.SHORT_SIZE;
- right = LittleEndian.getShort(data, offset); offset += LittleEndian.SHORT_SIZE;
- bottom = LittleEndian.getShort(data, offset); offset += LittleEndian.SHORT_SIZE;
+ handle = LittleEndian.getUShort(data, offset); offset += LittleEndianConsts.SHORT_SIZE;
+ left = LittleEndian.getShort(data, offset); offset += LittleEndianConsts.SHORT_SIZE;
+ top = LittleEndian.getShort(data, offset); offset += LittleEndianConsts.SHORT_SIZE;
+ right = LittleEndian.getShort(data, offset); offset += LittleEndianConsts.SHORT_SIZE;
+ bottom = LittleEndian.getShort(data, offset); offset += LittleEndianConsts.SHORT_SIZE;
- inch = LittleEndian.getUShort(data, offset); offset += LittleEndian.SHORT_SIZE;
- reserved = LittleEndian.getInt(data, offset); offset += LittleEndian.INT_SIZE;
+ inch = LittleEndian.getUShort(data, offset); offset += LittleEndianConsts.SHORT_SIZE;
+ reserved = LittleEndian.getInt(data, offset); offset += LittleEndianConsts.INT_SIZE;
- checksum = LittleEndian.getShort(data, offset); offset += LittleEndian.SHORT_SIZE;
+ checksum = LittleEndian.getShort(data, offset); offset += LittleEndianConsts.SHORT_SIZE;
if (checksum != getChecksum()){
LOG.log(POILogger.WARN, "WMF checksum does not match the header data");
}
public void write(OutputStream out) throws IOException {
byte[] header = new byte[22];
int pos = 0;
- LittleEndian.putInt(header, pos, APMHEADER_KEY); pos += LittleEndian.INT_SIZE; //header key
- LittleEndian.putUShort(header, pos, 0); pos += LittleEndian.SHORT_SIZE; //hmf
- LittleEndian.putUShort(header, pos, left); pos += LittleEndian.SHORT_SIZE; //left
- LittleEndian.putUShort(header, pos, top); pos += LittleEndian.SHORT_SIZE; //top
- LittleEndian.putUShort(header, pos, right); pos += LittleEndian.SHORT_SIZE; //right
- LittleEndian.putUShort(header, pos, bottom); pos += LittleEndian.SHORT_SIZE; //bottom
- LittleEndian.putUShort(header, pos, inch); pos += LittleEndian.SHORT_SIZE; //inch
- LittleEndian.putInt(header, pos, 0); pos += LittleEndian.INT_SIZE; //reserved
+ LittleEndian.putInt(header, pos, APMHEADER_KEY); pos += LittleEndianConsts.INT_SIZE; //header key
+ LittleEndian.putUShort(header, pos, 0); pos += LittleEndianConsts.SHORT_SIZE; //hmf
+ LittleEndian.putUShort(header, pos, left); pos += LittleEndianConsts.SHORT_SIZE; //left
+ LittleEndian.putUShort(header, pos, top); pos += LittleEndianConsts.SHORT_SIZE; //top
+ LittleEndian.putUShort(header, pos, right); pos += LittleEndianConsts.SHORT_SIZE; //right
+ LittleEndian.putUShort(header, pos, bottom); pos += LittleEndianConsts.SHORT_SIZE; //bottom
+ LittleEndian.putUShort(header, pos, inch); pos += LittleEndianConsts.SHORT_SIZE; //inch
+ LittleEndian.putInt(header, pos, 0); pos += LittleEndianConsts.INT_SIZE; //reserved
checksum = getChecksum();
LittleEndian.putUShort(header, pos, checksum);
import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import java.text.FieldPosition;
+import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Formatter;
private void writeScientific(double value, StringBuffer output, Set<CellNumberStringMod> mods) {
StringBuffer result = new StringBuffer();
- FieldPosition fractionPos = new FieldPosition(DecimalFormat.FRACTION_FIELD);
+ FieldPosition fractionPos = new FieldPosition(NumberFormat.FRACTION_FIELD);
decimalFmt.format(value, result, fractionPos);
writeInteger(result, output, integerSpecials, mods, showGroupingSeparator);
writeFractional(result, output);
import org.apache.poi.util.BitField;
import org.apache.poi.util.BitFieldFactory;
-import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
import org.apache.poi.util.LittleEndianInput;
import org.apache.poi.util.LittleEndianOutput;
public int getSize() {
if (_jumpTable != null) {
- return SIZE + (_jumpTable.length + 1) * LittleEndian.SHORT_SIZE;
+ return SIZE + (_jumpTable.length + 1) * LittleEndianConsts.SHORT_SIZE;
}
return SIZE;
}
import javax.xml.crypto.URIDereferencer;
import javax.xml.crypto.dsig.CanonicalizationMethod;
import javax.xml.crypto.dsig.DigestMethod;
+import javax.xml.crypto.dsig.Transform;
import javax.xml.crypto.dsig.XMLSignatureFactory;
import javax.xml.crypto.dsig.keyinfo.KeyInfoFactory;
}
switch (canonicalizationMethod) {
+ case Transform.ENVELOPED:
case CanonicalizationMethod.INCLUSIVE:
case CanonicalizationMethod.INCLUSIVE_WITH_COMMENTS:
- case CanonicalizationMethod.ENVELOPED:
case CanonicalizationMethod.EXCLUSIVE:
case CanonicalizationMethod.EXCLUSIVE_WITH_COMMENTS:
return canonicalizationMethod;
, List<XMLObject> objects)
throws XMLSignatureException {
List<Transform> transforms = new ArrayList<>();
- Transform envelopedTransform = newTransform(signatureInfo, CanonicalizationMethod.ENVELOPED);
+ Transform envelopedTransform = newTransform(signatureInfo, Transform.ENVELOPED);
transforms.add(envelopedTransform);
Transform exclusiveTransform = newTransform(signatureInfo, CanonicalizationMethod.EXCLUSIVE);
transforms.add(exclusiveTransform);
package org.apache.poi.xdgf.geom;
+import com.graphbuilder.curve.BSpline;
import com.graphbuilder.curve.ControlPath;
import com.graphbuilder.curve.GroupIterator;
import com.graphbuilder.curve.NURBSpline;
NURBSpline spline = new NURBSpline(controlPoints, gi);
spline.setDegree(degree);
- spline.setKnotVectorType(NURBSpline.NON_UNIFORM);
+ spline.setKnotVectorType(BSpline.NON_UNIFORM);
spline.setKnotVector(knots);
if (weights == null) {
import org.apache.poi.util.Internal;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
/**
* This class encapsulates what the spec calls a "Cell" object.
* @param cell cell buffer to update
*/
public static void parse(byte[] data, int offset, int currentRow, XSSFBCellHeader cell) {
- int colNum = XSSFBUtils.castToInt(LittleEndian.getUInt(data, offset)); offset += LittleEndian.INT_SIZE;
+ int colNum = XSSFBUtils.castToInt(LittleEndian.getUInt(data, offset)); offset += LittleEndianConsts.INT_SIZE;
int styleIdx = XSSFBUtils.get24BitInt(data, offset); offset += 3;
//TODO: range checking
boolean showPhonetic = false;//TODO: fill this out
import org.apache.poi.util.Internal;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
/**
* @since 3.16-beta3
class XSSFBCellRange {
//TODO: Convert this to generate an AreaReference
- public static final int length = 4* LittleEndian.INT_SIZE;
+ public static final int length = 4* LittleEndianConsts.INT_SIZE;
/**
* Parses an RfX cell range from the data starting at the offset.
* This performs no range checking.
if (cellRange == null) {
cellRange = new XSSFBCellRange();
}
- cellRange.firstRow = XSSFBUtils.castToInt(LittleEndian.getUInt(data, offset)); offset += LittleEndian.INT_SIZE;
- cellRange.lastRow = XSSFBUtils.castToInt(LittleEndian.getUInt(data, offset)); offset += LittleEndian.INT_SIZE;
- cellRange.firstCol = XSSFBUtils.castToInt(LittleEndian.getUInt(data, offset)); offset += LittleEndian.INT_SIZE;
+ cellRange.firstRow = XSSFBUtils.castToInt(LittleEndian.getUInt(data, offset)); offset += LittleEndianConsts.INT_SIZE;
+ cellRange.lastRow = XSSFBUtils.castToInt(LittleEndian.getUInt(data, offset)); offset += LittleEndianConsts.INT_SIZE;
+ cellRange.firstCol = XSSFBUtils.castToInt(LittleEndian.getUInt(data, offset)); offset += LittleEndianConsts.INT_SIZE;
cellRange.lastCol = XSSFBUtils.castToInt(LittleEndian.getUInt(data, offset));
return cellRange;
import org.apache.poi.ss.util.CellAddress;
import org.apache.poi.util.Internal;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
/**
* @since 3.16-beta3
switch (recordType) {
case BrtBeginComment:
int offset = 0;
- authorId = XSSFBUtils.castToInt(LittleEndian.getUInt(data)); offset += LittleEndian.INT_SIZE;
+ authorId = XSSFBUtils.castToInt(LittleEndian.getUInt(data)); offset += LittleEndianConsts.INT_SIZE;
cellRange = XSSFBCellRange.parse(data, offset, cellRange);
offset+= XSSFBCellRange.length;
//for strict parsing; confirm that firstRow==lastRow and firstCol==colLats (2.4.28)
import org.apache.poi.openxml4j.opc.PackageRelationship;
import org.apache.poi.openxml4j.opc.PackageRelationshipCollection;
import org.apache.poi.openxml4j.opc.PackagingURIHelper;
-import org.apache.poi.util.IOUtils;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
import org.apache.poi.util.POILogFactory;
import org.apache.poi.util.POILogger;
import org.apache.poi.xssf.binary.XSSFBCommentsTable;
int offset = 0;
//this is the sheet state #2.5.142
/*long hsShtat =*/ //noinspection ResultOfMethodCallIgnored
- LittleEndian.getUInt(data, offset); offset += LittleEndian.INT_SIZE;
+ LittleEndian.getUInt(data, offset); offset += LittleEndianConsts.INT_SIZE;
- long iTabID = LittleEndian.getUInt(data, offset); offset += LittleEndian.INT_SIZE;
+ long iTabID = LittleEndian.getUInt(data, offset); offset += LittleEndianConsts.INT_SIZE;
//according to #2.4.304
if (iTabID < 1 || iTabID > 0x0000FFFFL) {
throw new XSSFBParseException("table id out of range: "+iTabID);
//undocumented what is contained in these 8 bytes.
//for the non-beta xlsb files, this would be 4, not 8.
int offset = 8;
- long iTabID = LittleEndian.getUInt(data, offset); offset += LittleEndian.INT_SIZE;
+ long iTabID = LittleEndian.getUInt(data, offset); offset += LittleEndianConsts.INT_SIZE;
if (iTabID < 1 || iTabID > 0x0000FFFFL) {
throw new XSSFBParseException("table id out of range: "+iTabID);
}
package org.apache.poi.hdgf.chunks;
-import org.apache.poi.util.LittleEndian;
-
import java.nio.charset.Charset;
+import org.apache.poi.util.LittleEndian;
+
/**
* A chunk header
*/
* @return the header size
*/
public static int getHeaderSize(int documentVersion) {
- if(documentVersion > 6) {
- return ChunkHeaderV11.getHeaderSize();
- } else if(documentVersion == 6) {
- return ChunkHeaderV6.getHeaderSize();
- } else {
- return ChunkHeaderV4V5.getHeaderSize();
- }
+ return documentVersion >= 6 ? ChunkHeaderV6.getHeaderSize() : ChunkHeaderV4V5.getHeaderSize();
}
public abstract int getSizeInBytes();
import org.apache.poi.util.GenericRecordJsonWriter;
import org.apache.poi.util.GenericRecordUtil;
import org.apache.poi.util.IOUtils;
-import org.apache.poi.util.LittleEndian;
import org.apache.poi.util.LittleEndianConsts;
import org.apache.poi.util.LittleEndianInputStream;
xform.setToIdentity();
}
- return 6 * LittleEndian.INT_SIZE;
+ return 6 * LittleEndianConsts.INT_SIZE;
}
static Shape getRgnShape(List<Rectangle2D> rgnRects) {
import org.apache.poi.poifs.filesystem.POIFSFileSystem;
import org.apache.poi.util.IOUtils;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
/**
* Utility class which dumps raw contents of a ppt file into XML format
return bos.toByteArray();
}
}
-
+
/**
* Dump the structure of the supplied PPT file into XML
* @param outWriter <code>Writer</code> to write out
//read record header
int info = LittleEndian.getUShort(data, pos);
- pos += LittleEndian.SHORT_SIZE;
+ pos += LittleEndianConsts.SHORT_SIZE;
int type = LittleEndian.getUShort(data, pos);
- pos += LittleEndian.SHORT_SIZE;
+ pos += LittleEndianConsts.SHORT_SIZE;
int size = (int)LittleEndian.getUInt(data, pos);
- pos += LittleEndian.INT_SIZE;
+ pos += LittleEndianConsts.INT_SIZE;
//get name of the record by type
String recname = RecordTypes.forTypeID(type).name();
import org.apache.poi.common.Duplicatable;
import org.apache.poi.common.usermodel.GenericRecord;
import org.apache.poi.hslf.exceptions.HSLFException;
-import org.apache.poi.hslf.record.StyleTextPropAtom;
import org.apache.poi.util.HexDump;
import org.apache.poi.util.LittleEndian;
import org.apache.poi.util.POILogFactory;
if (!isMasterStyle) {
// First goes the number of characters we affect
// MasterStyles don't have this field
- StyleTextPropAtom.writeLittleEndian(charactersCovered,o);
+ org.apache.poi.hslf.record.Record.writeLittleEndian(charactersCovered,o);
}
// Then we have the indentLevel field if it's a paragraph collection
if (textPropType == TextPropType.paragraph && indentLevel > -1) {
- StyleTextPropAtom.writeLittleEndian(indentLevel, o);
+ org.apache.poi.hslf.record.Record.writeLittleEndian(indentLevel, o);
}
// Then the mask field
for (TextProp textProp : textProps.values()) {
mask |= textProp.getWriteMask();
}
- StyleTextPropAtom.writeLittleEndian(mask,o);
+ org.apache.poi.hslf.record.Record.writeLittleEndian(mask,o);
// Then the contents of all the properties
for (TextProp textProp : getTextPropList()) {
// don't add empty properties, as they can't be recognized while reading
continue;
} else if (textProp.getSize() == 2) {
- StyleTextPropAtom.writeLittleEndian((short)val,o);
+ org.apache.poi.hslf.record.Record.writeLittleEndian((short)val,o);
} else if (textProp.getSize() == 4) {
- StyleTextPropAtom.writeLittleEndian(val,o);
+ org.apache.poi.hslf.record.Record.writeLittleEndian(val,o);
} else if (textProp instanceof HSLFTabStopPropCollection) {
((HSLFTabStopPropCollection)textProp).writeProperty(o);
}
import java.util.function.Supplier;
import org.apache.poi.ddf.DefaultEscherRecordFactory;
+import org.apache.poi.ddf.EscherClientDataRecord;
import org.apache.poi.ddf.EscherRecord;
import org.apache.poi.ddf.EscherRecordFactory;
protected Supplier<? extends EscherRecord> getConstructor(short options, short recordId) {
if (recordId == EscherPlaceholder.RECORD_ID) {
return EscherPlaceholder::new;
- } else if (recordId == HSLFEscherClientDataRecord.RECORD_ID) {
+ } else if (recordId == EscherClientDataRecord.RECORD_ID) {
return HSLFEscherClientDataRecord::new;
}
return super.getConstructor(options, recordId);
import org.apache.poi.util.GenericRecordUtil;
import org.apache.poi.util.IOUtils;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
import org.apache.poi.util.LittleEndianOutputStream;
import org.apache.poi.util.POILogFactory;
import org.apache.poi.util.POILogger;
//number of indentation levels
short levels = LittleEndian.getShort(_data, 0);
- pos += LittleEndian.SHORT_SIZE;
+ pos += LittleEndianConsts.SHORT_SIZE;
paragraphStyles = new ArrayList<>(levels);
charStyles = new ArrayList<>(levels);
// Fetch the 2 byte value, that is safe to ignore for some types of text
short indentLevel = LittleEndian.getShort(_data, pos);
prprops.setIndentLevel(indentLevel);
- pos += LittleEndian.SHORT_SIZE;
+ pos += LittleEndianConsts.SHORT_SIZE;
} else {
prprops.setIndentLevel((short)-1);
}
head = LittleEndian.getInt(_data, pos);
- pos += LittleEndian.INT_SIZE;
+ pos += LittleEndianConsts.INT_SIZE;
pos += prprops.buildTextPropList( head, _data, pos);
paragraphStyles.add(prprops);
head = LittleEndian.getInt(_data, pos);
- pos += LittleEndian.INT_SIZE;
+ pos += LittleEndianConsts.INT_SIZE;
TextPropCollection chprops = new TextPropCollection(0, TextPropType.character);
pos += chprops.buildTextPropList( head, _data, pos);
charStyles.add(chprops);
while (segIter.hasNext()) {
byte[] segElem = segIter.next();
- HSLFFreeformShape.PathInfo pi = getPathInfo(segElem);
+ HSLFAutoShape.PathInfo pi = getPathInfo(segElem);
if (pi == null) {
continue;
}
}
private static void handleEscapeInfo(CTPath2D pathCT, Path2D path2D, byte[] segElem, Iterator<byte[]> vertIter) {
- HSLFFreeformShape.EscapeInfo ei = getEscapeInfo(segElem);
+ HSLFAutoShape.EscapeInfo ei = getEscapeInfo(segElem);
if (ei == null) {
return;
}
return new Point2D.Double(xyPoints[0],xyPoints[1]);
}
- private static HSLFFreeformShape.PathInfo getPathInfo(byte[] elem) {
+ private static HSLFAutoShape.PathInfo getPathInfo(byte[] elem) {
int elemUS = LittleEndian.getUShort(elem, 0);
int pathInfo = PATH_INFO.getValue(elemUS);
- return HSLFFreeformShape.PathInfo.valueOf(pathInfo);
+ return HSLFAutoShape.PathInfo.valueOf(pathInfo);
}
- private static HSLFFreeformShape.EscapeInfo getEscapeInfo(byte[] elem) {
+ private static HSLFAutoShape.EscapeInfo getEscapeInfo(byte[] elem) {
int elemUS = LittleEndian.getUShort(elem, 0);
int escInfo = ESCAPE_INFO.getValue(elemUS);
- return HSLFFreeformShape.EscapeInfo.valueOf(escInfo);
+ return HSLFAutoShape.EscapeInfo.valueOf(escInfo);
}
import org.apache.poi.poifs.crypt.HashAlgorithm;
import org.apache.poi.sl.usermodel.PictureData;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
import org.apache.poi.util.Units;
/**
private int uidInstanceCount = 1;
/**
- * The 1-based index within the pictures stream
+ * The 1-based index within the pictures stream
*/
private int index = -1;
-
+
/**
* Blip signature.
*/
/**
* The instance type/signatures defines if one or two UID instances will be included
- *
+ *
* @param uidInstanceCount the number of uid sequences
*/
protected void setUIDInstanceCount(int uidInstanceCount) {
this.uidInstanceCount = uidInstanceCount;
}
-
+
/**
* Returns the raw binary data of this Picture excluding the first 8 bytes
* which hold image signature and size of the image data.
public byte[] getChecksum() {
return getChecksum(getData());
}
-
+
/**
* Compute 16-byte checksum of this picture using MD5 algorithm.
*/
public void write(OutputStream out) throws IOException {
byte[] data;
- data = new byte[LittleEndian.SHORT_SIZE];
+ data = new byte[LittleEndianConsts.SHORT_SIZE];
LittleEndian.putUShort(data, 0, getSignature());
out.write(data);
- data = new byte[LittleEndian.SHORT_SIZE];
+ data = new byte[LittleEndianConsts.SHORT_SIZE];
PictureType pt = getType();
LittleEndian.putUShort(data, 0, pt.nativeId + 0xF018);
out.write(data);
byte[] rd = getRawData();
- data = new byte[LittleEndian.INT_SIZE];
+ data = new byte[LittleEndianConsts.INT_SIZE];
LittleEndian.putInt(data, 0, rd.length);
out.write(data);
public void setIndex(int index) {
this.index = index;
}
-
+
@Override
public final String getContentType() {
return getType().contentType;
/**
* Common class for {@link ExcelToFoConverter} and {@link ExcelToHtmlConverter}
- *
+ *
* @author Sergey Vladimirov (vlsergey {at} gmail {dot} com)
* @see AbstractWordConverter
*/
{
protected static int getColumnWidth( HSSFSheet sheet, int columnIndex )
{
- return ExcelToHtmlUtils.getColumnWidthInPx( sheet
+ return AbstractExcelUtils.getColumnWidthInPx( sheet
.getColumnWidth( columnIndex ) );
}
protected static int getDefaultColumnWidth( HSSFSheet sheet )
{
- return ExcelToHtmlUtils.getColumnWidthInPx( sheet
+ return AbstractExcelUtils.getColumnWidthInPx( sheet
.getDefaultColumnWidth() );
}
/**
* Generates name for output as column header in case
* <tt>{@link #isOutputColumnHeaders()} == true</tt>
- *
+ *
* @param columnIndex
* 0-based column index
*/
value = ErrorEval.getText( cell.getErrorCellValue() );
break;
default:
- value = ExcelToHtmlUtils.EMPTY;
+ value = AbstractExcelUtils.EMPTY;
break;
}
break;
case BLANK:
- value = ExcelToHtmlUtils.EMPTY;
+ value = AbstractExcelUtils.EMPTY;
break;
case NUMERIC:
value = _formatter.formatCellValue( cell );
return true;
}
- return ExcelToHtmlUtils.isEmpty( value );
+ return AbstractExcelUtils.isEmpty( value );
}
public void setFontReplacer( FontReplacer fontReplacer )
}
else
{
- value = ExcelToHtmlUtils.EMPTY;
+ value = AbstractExcelUtils.EMPTY;
}
break;
case NUMERIC:
POILogger.WARN,
"Unexpected cell cachedFormulaResultType ("
+ cell.getCachedFormulaResultType() + ")" );
- value = ExcelToHtmlUtils.EMPTY;
+ value = AbstractExcelUtils.EMPTY;
break;
}
break;
case BLANK:
- value = ExcelToHtmlUtils.EMPTY;
+ value = AbstractExcelUtils.EMPTY;
break;
case NUMERIC:
value = _formatter.formatCellValue( cell );
return true;
}
- final boolean noText = ExcelToHtmlUtils.isEmpty( value );
+ final boolean noText = AbstractExcelUtils.isEmpty( value );
final boolean wrapInDivs = !noText && !cellStyle.getWrapText();
final boolean emptyStyle = isEmptyStyle( cellStyle );
block.appendChild( text );
tableCellElement.appendChild( block );
- return ExcelToHtmlUtils.isEmpty( value ) && emptyStyle;
+ return AbstractExcelUtils.isEmpty( value ) && emptyStyle;
}
protected void processCellStyle( HSSFWorkbook workbook,
.getFillBackgroundColorColor();
if ( backgroundColor != null )
cellTarget.setAttribute( "background-color",
- ExcelToHtmlUtils.getColor( backgroundColor ) );
+ AbstractExcelUtils.getColor( backgroundColor ) );
}
processCellStyleBorder( workbook, cellTarget, "top",
return;
StringBuilder borderStyle = new StringBuilder();
- borderStyle.append( ExcelToHtmlUtils.getBorderWidth( xlsBorder ) );
+ borderStyle.append( AbstractExcelUtils.getBorderWidth( xlsBorder ) );
final HSSFColor color = workbook.getCustomPalette().getColor(
borderColor );
if ( color != null )
{
borderStyle.append( ' ' );
- borderStyle.append( ExcelToHtmlUtils.getColor( color ) );
+ borderStyle.append( AbstractExcelUtils.getColor( color ) );
borderStyle.append( ' ' );
- borderStyle.append( ExcelToHtmlUtils.getBorderStyle( xlsBorder ) );
+ borderStyle.append( AbstractExcelUtils.getBorderStyle( xlsBorder ) );
}
cellTarget.setAttribute( "border-" + type, borderStyle.toString() );
font.getColor() );
if ( fontColor != null )
blockTarget.setAttribute( "color",
- ExcelToHtmlUtils.getColor( fontColor ) );
+ AbstractExcelUtils.getColor( fontColor ) );
if ( font.getFontHeightInPoints() != 0 )
blockTarget.setAttribute( "font-size", font.getFontHeightInPoints()
if ( !isOutputHiddenColumns() && sheet.isColumnHidden( colIx ) )
continue;
- CellRangeAddress range = ExcelToHtmlUtils.getMergedRange(
+ CellRangeAddress range = AbstractExcelUtils.getMergedRange(
mergedRanges, row.getRowNum(), colIx );
if ( range != null
/**
* Converts xls files (97-2007) to HTML file.
- *
+ *
* @author Sergey Vladimirov (vlsergey {at} gmail {dot} com)
*/
@Beta
/**
* Java main() interface to interact with {@link ExcelToHtmlConverter}
- *
+ *
* <p>
* Usage: ExcelToHtmlConverter infile outfile
* </p>
/**
* Converts Excel file (97-2007) into HTML file.
- *
+ *
* @param xlsFile
* workbook file to process
* @return DOM representation of result HTML
* @throws ParserConfigurationException If configuration is incorrect
*/
public static Document process( File xlsFile ) throws IOException, ParserConfigurationException {
- try (HSSFWorkbook workbook = ExcelToHtmlUtils.loadXls(xlsFile)) {
+ try (HSSFWorkbook workbook = AbstractExcelUtils.loadXls(xlsFile)) {
return ExcelToHtmlConverter.process(workbook);
}
}
/**
* Converts Excel file (97-2007) into HTML file.
- *
+ *
* @param xlsStream workbook stream to process
* @return DOM representation of result HTML
* @throws IOException If an error occurs reading or writing files
/**
* Converts Excel file (97-2007) into HTML file.
- *
+ *
* @param workbook workbook instance to process
* @return DOM representation of result HTML
* @throws IOException If an error occurs reading or writing files
case SOLID_FOREGROUND:
final HSSFColor foregroundColor = cellStyle.getFillForegroundColorColor();
if ( foregroundColor == null ) break;
- String fgCol = ExcelToHtmlUtils.getColor( foregroundColor );
+ String fgCol = AbstractExcelUtils.getColor( foregroundColor );
style.append("background-color:").append(fgCol).append(";");
break;
default:
final HSSFColor backgroundColor = cellStyle.getFillBackgroundColorColor();
if ( backgroundColor == null ) break;
- String bgCol = ExcelToHtmlUtils.getColor( backgroundColor );
+ String bgCol = AbstractExcelUtils.getColor( backgroundColor );
style.append("background-color:").append(bgCol).append(";");
break;
}
}
StringBuilder borderStyle = new StringBuilder();
- borderStyle.append( ExcelToHtmlUtils.getBorderWidth( xlsBorder ) );
+ borderStyle.append( AbstractExcelUtils.getBorderWidth( xlsBorder ) );
borderStyle.append( ' ' );
- borderStyle.append( ExcelToHtmlUtils.getBorderStyle( xlsBorder ) );
+ borderStyle.append( AbstractExcelUtils.getBorderStyle( xlsBorder ) );
final HSSFColor color = workbook.getCustomPalette().getColor(
borderColor );
if ( color != null )
{
borderStyle.append( ' ' );
- borderStyle.append( ExcelToHtmlUtils.getColor( color ) );
+ borderStyle.append( AbstractExcelUtils.getColor( color ) );
}
style.append("border-").append(type).append(":").append(borderStyle).append(";");
final HSSFColor fontColor = workbook.getCustomPalette().getColor(
font.getColor() );
if ( fontColor != null )
- style.append("color: ").append(ExcelToHtmlUtils.getColor(fontColor)).append("; ");
+ style.append("color: ").append(AbstractExcelUtils.getColor(fontColor)).append("; ");
if ( font.getFontHeightInPoints() != 0 )
style.append("font-size:").append(font.getFontHeightInPoints()).append("pt;");
}
else
{
- value = ExcelToHtmlUtils.EMPTY;
+ value = AbstractExcelUtils.EMPTY;
}
break;
case NUMERIC:
POILogger.WARN,
"Unexpected cell cachedFormulaResultType ("
+ cell.getCachedFormulaResultType() + ")" );
- value = ExcelToHtmlUtils.EMPTY;
+ value = AbstractExcelUtils.EMPTY;
break;
}
break;
case BLANK:
- value = ExcelToHtmlUtils.EMPTY;
+ value = AbstractExcelUtils.EMPTY;
break;
case NUMERIC:
value = _formatter.formatCellValue( cell );
return true;
}
- final boolean noText = ExcelToHtmlUtils.isEmpty( value );
+ final boolean noText = AbstractExcelUtils.isEmpty( value );
final boolean wrapInDivs = !noText && isUseDivsToSpan() && !cellStyle.getWrapText();
if ( cellStyle.getIndex() != 0 ) {
@SuppressWarnings("resource")
HSSFWorkbook workbook = cell.getRow().getSheet().getWorkbook();
String mainCssClass = getStyleClassName( workbook, cellStyle );
-
+
if ( wrapInDivs ) {
tableCellElement.setAttribute( "class", mainCssClass + " "
+ cssClassContainerCell );
tableCellElement.appendChild( text );
}
- return ExcelToHtmlUtils.isEmpty( value ) && (cellStyle.getIndex() == 0);
+ return AbstractExcelUtils.isEmpty( value ) && (cellStyle.getIndex() == 0);
}
protected void processColumnHeaders( HSSFSheet sheet, int maxSheetColumns,
}
protected void processDocumentInformation(SummaryInformation summaryInformation ) {
- if ( ExcelToHtmlUtils.isNotEmpty( summaryInformation.getTitle() ) )
+ if ( AbstractExcelUtils.isNotEmpty( summaryInformation.getTitle() ) )
htmlDocumentFacade.setTitle( summaryInformation.getTitle() );
- if ( ExcelToHtmlUtils.isNotEmpty( summaryInformation.getAuthor() ) )
+ if ( AbstractExcelUtils.isNotEmpty( summaryInformation.getAuthor() ) )
htmlDocumentFacade.addAuthor( summaryInformation.getAuthor() );
- if ( ExcelToHtmlUtils.isNotEmpty( summaryInformation.getKeywords() ) )
+ if ( AbstractExcelUtils.isNotEmpty( summaryInformation.getKeywords() ) )
htmlDocumentFacade.addKeywords( summaryInformation.getKeywords() );
- if ( ExcelToHtmlUtils.isNotEmpty( summaryInformation.getComments() ) )
+ if ( AbstractExcelUtils.isNotEmpty( summaryInformation.getComments() ) )
htmlDocumentFacade
.addDescription( summaryInformation.getComments() );
}
if ( !isOutputHiddenColumns() && sheet.isColumnHidden( colIx ) )
continue;
- CellRangeAddress range = ExcelToHtmlUtils.getMergedRange(
+ CellRangeAddress range = AbstractExcelUtils.getMergedRange(
mergedRanges, row.getRowNum(), colIx );
if ( range != null
imageWidth *= aspectRatioX / 1000f;
}
imageWidth /= AbstractWordUtils.TWIPS_PER_INCH;
-
+
float imageHeight = picture.getDyaGoal();
if (aspectRatioY > 0) {
imageHeight *= aspectRatioY / 1000f;
picture.suggestPictureType(),
picture.suggestFullFileName(), imageWidth, imageHeight );
- if ( WordToFoUtils.isNotEmpty( url ) )
+ if ( AbstractWordUtils.isNotEmpty( url ) )
{
processImage( currentBlock, inlined, picture, url );
return;
* Creates array of all possible cell edges. In HTML (and FO) cells from
* different rows and same column should have same width, otherwise spanning
* shall be used.
- *
+ *
* @param table
* table to build cell edges array from
* @return array of cell edges (including leftest one) in twips
{
Node child1 = childNodes.item( i );
Node child2 = childNodes.item( i + 1 );
- if ( !WordToFoUtils.canBeMerged( child1, child2, childTagName ) )
+ if ( !AbstractWordUtils.canBeMerged( child1, child2, childTagName ) )
continue;
// merge
numberingState.levels.remove( childKey );
}
}
-
+
bulletBuffer.append( NumberFormatter.getNumber( num,
list.getNumberFormat( level ) ) );
}
if ( child.getNodeType() == Node.ELEMENT_NODE )
{
Element childElement = (Element) child;
- if ( WordToFoUtils.isNotEmpty( childElement.getNamespaceURI() )
- && WordToFoUtils.isNotEmpty( childElement
- .getLocalName() )
+ if ( AbstractWordUtils.isNotEmpty( childElement.getNamespaceURI() )
+ && AbstractWordUtils.isNotEmpty( childElement.getLocalName() )
&& namespace.equals( childElement.getNamespaceURI() )
&& name.equals( childElement.getLocalName() ) )
{
}
}
- if ( WordToFoUtils.isNotEmpty( value ) )
+ if ( AbstractWordUtils.isNotEmpty( value ) )
{
Element property = document.createElementNS( namespace, prefix
+ ":" + name );
import org.apache.poi.hwpf.sprm.SprmBuffer;
import org.apache.poi.util.Internal;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
import org.apache.poi.util.StringUtil;
@Internal
while (tableStream[offset] == GRPPRL_TYPE) {
offset++;
int size = LittleEndian.getShort(tableStream, offset);
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
byte[] bs = LittleEndian.getByteArray(tableStream, offset, size, MAX_RECORD_LENGTH);
offset += size;
" but had " + tableStream[offset]);
}
int pieceTableSize = LittleEndian.getInt(tableStream, ++offset);
- offset += LittleEndian.INT_SIZE;
+ offset += LittleEndianConsts.INT_SIZE;
_tpt = newTextPieceTable(documentStream, tableStream, offset, pieceTableSize, fcMin, charset);
}
byte[] table = _tpt.writeTo(wordDocumentStream);
- byte[] numHolder = new byte[LittleEndian.INT_SIZE];
+ byte[] numHolder = new byte[LittleEndianConsts.INT_SIZE];
LittleEndian.putInt(numHolder, 0, table.length);
tableStream.write(numHolder);
tableStream.write(table);
import org.apache.poi.util.Internal;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
/**
* The FFData structure specifies form field data for a text box, check box, or
* <p>
* This class is internal. It content or properties may change without notice
* due to changes in our knowledge of internal Microsoft Word binary structures.
- *
+ *
* @author Sergey Vladimirov; according to [MS-DOC] -- v20121003 Word (.doc)
* Binary File Format; Copyright (c) 2012 Microsoft Corporation;
* Release: October 8, 2012
{
this._wDef = Integer
.valueOf( LittleEndian.getUShort( std, offset ) );
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
}
else
{
if ( _base.getIType() == FFDataBase.ITYPE_CHCK
|| _base.getIType() == FFDataBase.ITYPE_DROP )
{
- size += LittleEndian.SHORT_SIZE;
+ size += LittleEndianConsts.SHORT_SIZE;
}
size += _xstzTextFormat.getSize();
|| _base.getIType() == FFDataBase.ITYPE_DROP )
{
LittleEndian.putUShort( buffer, offset, _wDef );
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
}
offset += _xstzTextFormat.serialize( buffer, offset );
import org.apache.poi.util.Internal;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
import org.apache.poi.util.POILogFactory;
import org.apache.poi.util.POILogger;
private final static POILogger log = POILogFactory.getLogger(FIBFieldHandler.class);
- private static final int FIELD_SIZE = LittleEndian.INT_SIZE * 2;
+ private static final int FIELD_SIZE = LittleEndianConsts.INT_SIZE * 2;
private Map<Integer, UnhandledDataStructure> _unknownMap = new HashMap<>();
private int[] _fields;
{
int fieldOffset = (x * FIELD_SIZE) + offset;
int dsOffset = LittleEndian.getInt(mainStream, fieldOffset);
- fieldOffset += LittleEndian.INT_SIZE;
+ fieldOffset += LittleEndianConsts.INT_SIZE;
int dsSize = LittleEndian.getInt(mainStream, fieldOffset);
if (offsetList.contains(Integer.valueOf(x)) ^ areKnown)
public int sizeInBytes()
{
- return (_fields.length * LittleEndian.INT_SIZE);
+ return (_fields.length * LittleEndianConsts.INT_SIZE);
}
public int getFieldsCount() {
return _fields.length / 2;
}
-
+
void writeTo(byte[] mainStream, int offset, ByteArrayOutputStream tableStream)
throws IOException
{
{
_fields[x * 2] = tableStream.size();
LittleEndian.putInt(mainStream, offset, tableStream.size());
- offset += LittleEndian.INT_SIZE;
+ offset += LittleEndianConsts.INT_SIZE;
byte[] buf = ds.getBuf();
tableStream.write(buf);
_fields[(x * 2) + 1] = buf.length;
LittleEndian.putInt(mainStream, offset, buf.length);
- offset += LittleEndian.INT_SIZE;
+ offset += LittleEndianConsts.INT_SIZE;
}
else
{
LittleEndian.putInt(mainStream, offset, _fields[x * 2]);
- offset += LittleEndian.INT_SIZE;
+ offset += LittleEndianConsts.INT_SIZE;
LittleEndian.putInt(mainStream, offset, _fields[(x * 2) + 1]);
- offset += LittleEndian.INT_SIZE;
+ offset += LittleEndianConsts.INT_SIZE;
}
}
}
{
result.append( '\t' );
result.append( leftPad( Integer.toString( x ), 8, ' ' ) );
- result.append( leftPad( Integer.toString( 154 + x * LittleEndian.INT_SIZE * 2 ), 6, ' ' ) );
+ result.append( leftPad( Integer.toString( 154 + x * LittleEndianConsts.INT_SIZE * 2 ), 6, ' ' ) );
result.append( " 0x" );
- result.append( leftPad( Integer.toHexString( 154 + x * LittleEndian.INT_SIZE * 2 ), 4, '0' ) );
+ result.append( leftPad( Integer.toHexString( 154 + x * LittleEndianConsts.INT_SIZE * 2 ), 4, '0' ) );
result.append( leftPad( Integer.toString( getFieldOffset( x ) ), 8, ' ' ) );
result.append( leftPad( Integer.toString( getFieldSize( x ) ), 8, ' ' ) );
import org.apache.poi.util.IOUtils;
import org.apache.poi.util.Internal;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
/**
* FFN - Font Family Name. FFN is a data structure that stores the names of the Main
int offsetTmp = offset;
_cbFfnM1 = LittleEndian.getUByte(buf,offset);
- offset += LittleEndian.BYTE_SIZE;
+ offset += LittleEndianConsts.BYTE_SIZE;
_info = buf[offset];
- offset += LittleEndian.BYTE_SIZE;
+ offset += LittleEndianConsts.BYTE_SIZE;
_wWeight = LittleEndian.getShort(buf, offset);
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
_chs = buf[offset];
- offset += LittleEndian.BYTE_SIZE;
+ offset += LittleEndianConsts.BYTE_SIZE;
_ixchSzAlt = buf[offset];
- offset += LittleEndian.BYTE_SIZE;
+ offset += LittleEndianConsts.BYTE_SIZE;
// read panose and fs so we can write them back out.
System.arraycopy(buf, offset, _panose, 0, _panose.length);
for(int i = 0; i < _xszFfnLength; i++)
{
_xszFfn[i] = (char)LittleEndian.getShort(buf, offset);
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
}
byte[] buf = IOUtils.safelyAllocate(this.getSize(), MAX_RECORD_LENGTH);
buf[offset] = (byte)_cbFfnM1;
- offset += LittleEndian.BYTE_SIZE;
+ offset += LittleEndianConsts.BYTE_SIZE;
buf[offset] = _info;
- offset += LittleEndian.BYTE_SIZE;
+ offset += LittleEndianConsts.BYTE_SIZE;
LittleEndian.putShort(buf, offset, _wWeight);
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
buf[offset] = _chs;
- offset += LittleEndian.BYTE_SIZE;
+ offset += LittleEndianConsts.BYTE_SIZE;
buf[offset] = _ixchSzAlt;
- offset += LittleEndian.BYTE_SIZE;
+ offset += LittleEndianConsts.BYTE_SIZE;
System.arraycopy(_panose,0,buf, offset,_panose.length);
offset += _panose.length;
for(int i = 0; i < _xszFfn.length; i++)
{
LittleEndian.putShort(buf, offset, (short)_xszFfn[i]);
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
}
return buf;
public boolean equals(Object other) {
if (!(other instanceof Ffn)) return false;
Ffn o = (Ffn)other;
-
+
return (
o._cbFfnM1 == this._cbFfnM1
&& o._info == this._info
import org.apache.poi.util.IOUtils;
import org.apache.poi.util.Internal;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
import org.apache.poi.util.POILogFactory;
import org.apache.poi.util.POILogger;
assert offset == 32;
_csw = LittleEndian.getUShort( mainDocument, offset );
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
assert offset == 34;
_fibRgW = new FibRgW97( mainDocument, offset );
assert offset == 62;
_cslw = LittleEndian.getUShort( mainDocument, offset );
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
assert offset == 64;
if ( _fibBase.getNFib() < 105 )
_cbRgFcLcb = 74;
// skip fibRgFcLcbBlob (read later at fillVariableFields)
- offset += _cbRgFcLcb * LittleEndian.INT_SIZE * 2;
+ offset += _cbRgFcLcb * LittleEndianConsts.INT_SIZE * 2;
_cswNew = LittleEndian.getUShort( mainDocument, offset );
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
_cswNew = 0;
_nFibNew = -1;
assert offset == 152;
_cbRgFcLcb = LittleEndian.getUShort( mainDocument, offset );
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
assert offset == 154;
// skip fibRgFcLcbBlob (read later at fillVariableFields)
- offset += _cbRgFcLcb * LittleEndian.INT_SIZE * 2;
+ offset += _cbRgFcLcb * LittleEndianConsts.INT_SIZE * 2;
_cswNew = LittleEndian.getUShort( mainDocument, offset );
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
if ( _cswNew != 0 )
{
_nFibNew = LittleEndian.getUShort( mainDocument, offset );
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
// first short is already read as _nFibNew
final int fibRgCswNewLength = ( _cswNew - 1 )
- * LittleEndian.SHORT_SIZE;
+ * LittleEndianConsts.SHORT_SIZE;
_fibRgCswNew = IOUtils.safelyAllocate(fibRgCswNewLength, MAX_RECORD_LENGTH);
LittleEndian.getByteArray( mainDocument, offset, fibRgCswNewLength, MAX_RECORD_LENGTH );
offset += fibRgCswNewLength;
{
int nfib = getNFib();
String nfibHex = String.format(Locale.ROOT, "%04X", nfib);
-
+
// Note - CommonCrawl shows there's more variation in these than
// the documentation suggests, so accept common clusters around
// the "correct" value as well
{
_fieldHandler.setFieldSize(FIBFieldHandler.STTBFFFN, lcbSttbFffn);
}
-
+
public int getFcSttbfRMark()
{
return _fieldHandler.getFieldOffset(FIBFieldHandler.STTBFRMARK);
{
return _fieldHandler.getFieldSize(FIBFieldHandler.STTBFRMARK);
}
-
+
public void setFcSttbfRMark(int fcSttbfRMark)
{
_fieldHandler.setFieldOffset(FIBFieldHandler.STTBFRMARK, fcSttbfRMark);
{
_fieldHandler.setFieldSize(FIBFieldHandler.PLFLFO, modifiedHigh);
}
-
+
/**
* How many bytes of the main stream contain real data.
*/
int offset = FibBase.getSize();
LittleEndian.putUShort( mainStream, offset, _csw );
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
_fibRgW.serialize( mainStream, offset );
offset += FibRgW97.getSize();
LittleEndian.putUShort( mainStream, offset, _cslw );
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
( (FibRgLw97) _fibRgLw ).serialize( mainStream, offset );
offset += FibRgLw97.getSize();
LittleEndian.putUShort( mainStream, offset, _cbRgFcLcb );
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
_fieldHandler.writeTo( mainStream, offset, tableStream );
- offset += _cbRgFcLcb * LittleEndian.INT_SIZE * 2;
+ offset += _cbRgFcLcb * LittleEndianConsts.INT_SIZE * 2;
LittleEndian.putUShort( mainStream, offset, _cswNew );
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
if ( _cswNew != 0 )
{
LittleEndian.putUShort( mainStream, offset, _nFibNew );
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
System.arraycopy( _fibRgCswNew, 0, mainStream, offset,
_fibRgCswNew.length );
public int getSize()
{
- return FibBase.getSize() + LittleEndian.SHORT_SIZE + FibRgW97.getSize()
- + LittleEndian.SHORT_SIZE + FibRgLw97.getSize()
- + LittleEndian.SHORT_SIZE + _fieldHandler.sizeInBytes();
+ return FibBase.getSize() + LittleEndianConsts.SHORT_SIZE + FibRgW97.getSize()
+ + LittleEndianConsts.SHORT_SIZE + FibRgLw97.getSize()
+ + LittleEndianConsts.SHORT_SIZE + _fieldHandler.sizeInBytes();
}
public FibBase getFibBase()
import org.apache.poi.hwpf.model.io.HWPFFileSystem;
import org.apache.poi.util.Internal;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
import org.apache.poi.util.POILogFactory;
import org.apache.poi.util.POILogger;
this.fcSttbfffn = offset;
_stringCount = LittleEndian.getShort(buf, offset);
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
_extraDataSz = LittleEndian.getShort(buf, offset);
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
_fontNames = new Ffn[_stringCount]; //Ffn corresponds to a Pascal style String in STTBF.
public void writeTo( ByteArrayOutputStream tableStream ) throws IOException
{
- byte[] buf = new byte[LittleEndian.SHORT_SIZE];
+ byte[] buf = new byte[LittleEndianConsts.SHORT_SIZE];
LittleEndian.putShort(buf, 0, _stringCount);
tableStream.write(buf);
LittleEndian.putShort(buf, 0, _extraDataSz);
|| o._extraDataSz != this._extraDataSz
|| o._fontNames.length != this._fontNames.length
) return false;
-
+
for (int i=0; i<o._fontNames.length; i++) {
if (!o._fontNames[i].equals(this._fontNames[i])) return false;
}
-
+
return true;
}
import org.apache.poi.util.Internal;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
/**
* The LFOData structure contains the Main Document CP of the corresponding LFO,
int offset = startOffset;
_cp = LittleEndian.getInt( buf, offset );
- offset += LittleEndian.INT_SIZE;
+ offset += LittleEndianConsts.INT_SIZE;
_rgLfoLvl = new ListFormatOverrideLevel[cLfolvl];
for ( int x = 0; x < cLfolvl; x++ )
public int getSizeInBytes()
{
int result = 0;
- result += LittleEndian.INT_SIZE;
+ result += LittleEndianConsts.INT_SIZE;
for ( ListFormatOverrideLevel lfolvl : _rgLfoLvl )
result += lfolvl.getSizeInBytes();
import org.apache.poi.util.Internal;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
import org.apache.poi.util.POILogFactory;
import org.apache.poi.util.POILogger;
int offset = lstOffset;
int cLst = LittleEndian.getShort( tableStream, offset );
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
int levelOffset = offset + ( cLst * LSTF.getSize() );
for ( int x = 0; x < cLst; x++ )
==================================================================== */
package org.apache.poi.hwpf.model;
+import java.util.Arrays;
+
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
import org.apache.poi.util.POILogFactory;
import org.apache.poi.util.POILogger;
-import java.util.Arrays;
-
public class NilPICFAndBinData
{
{
int lcb = LittleEndian.getInt( data, offset );
int cbHeader = LittleEndian.getUShort( data, offset
- + LittleEndian.INT_SIZE );
+ + LittleEndianConsts.INT_SIZE );
if ( cbHeader != 0x44 )
{
import org.apache.poi.common.usermodel.fonts.FontCharset;
import org.apache.poi.util.Internal;
-import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
import org.apache.poi.util.POILogFactory;
import org.apache.poi.util.POILogger;
import org.apache.poi.util.StringUtil;
charset = wmfCharset.getCharset();
}
charset = charset == null ? StringUtil.WIN_1252 : charset;
- offset += LittleEndian.BYTE_SIZE;
+ offset += LittleEndianConsts.BYTE_SIZE;
//if this byte here == 7, it _may_ signify existence of
//an altername font name
//not sure what the byte after the _chs does
- offset += LittleEndian.BYTE_SIZE;
+ offset += LittleEndianConsts.BYTE_SIZE;
int fontNameLength = -1;
for (int i = offset; i < fontTableEnd; i++) {
if (buf[i] == 0) {
//reset to 0 for length calculation
altFontNameLength = (altFontNameLength < 0) ? 0 : altFontNameLength + 1;//add one for zero byte
- int len = LittleEndian.INT_SIZE + LittleEndian.BYTE_SIZE + LittleEndian.BYTE_SIZE +//6 starting bytes
+ int len = LittleEndianConsts.INT_SIZE + LittleEndianConsts.BYTE_SIZE + LittleEndianConsts.BYTE_SIZE +//6 starting bytes
fontNameLength + altFontNameLength + 1;//+1 is for the zero byte
//this len should == fontDescriptionLength
import org.apache.poi.util.Internal;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
import org.apache.poi.util.POILogFactory;
import org.apache.poi.util.POILogger;
int fontTableLength = LittleEndian.getShort(buf, offset);
int endOfTableOffset = offset + length;
- int startOffset = offset + LittleEndian.SHORT_SIZE;//first short should == length!
+ int startOffset = offset + LittleEndianConsts.SHORT_SIZE;//first short should == length!
while (true) {
OldFfn oldFfn = OldFfn.build(buf, startOffset, endOfTableOffset);
import org.apache.poi.util.IOUtils;
import org.apache.poi.util.Internal;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
/**
* This class holds all of the section formatting
// were the new ones, we sometimes "need" more data than we have.
// As a workaround, have a few extra 0 bytes on the end!
byte[] buf = IOUtils.safelyAllocate(sepxSize+2, Short.MAX_VALUE+2);
- fileOffset += LittleEndian.SHORT_SIZE;
+ fileOffset += LittleEndianConsts.SHORT_SIZE;
System.arraycopy(documentStream, fileOffset, buf, 0, buf.length);
sepx = new SEPX(sed, startAt, endAt, buf);
}
import org.apache.poi.util.BitFieldFactory;
import org.apache.poi.util.Internal;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
@Internal
public final class ParagraphHeight implements Duplicatable {
public ParagraphHeight(byte[] buf, int offset) {
infoField = LittleEndian.getShort(buf, offset);
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
reserved = LittleEndian.getShort(buf, offset);
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
dxaCol = LittleEndian.getInt(buf, offset);
- offset += LittleEndian.INT_SIZE;
+ offset += LittleEndianConsts.INT_SIZE;
dymLineOrHeight = LittleEndian.getInt(buf, offset);
}
byte[] buf = new byte[12];
int offset = 0;
LittleEndian.putShort(buf, offset, infoField);
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
LittleEndian.putShort(buf, offset, reserved);
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
LittleEndian.putInt(buf, offset, dxaCol);
- offset += LittleEndian.INT_SIZE;
+ offset += LittleEndianConsts.INT_SIZE;
LittleEndian.putInt(buf, offset, dymLineOrHeight);
return buf;
import org.apache.poi.common.Duplicatable;
import org.apache.poi.util.Internal;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
import org.apache.poi.util.StringUtil;
@Internal
*/
public PieceDescriptor(byte[] buf, int offset, Charset charset) {
descriptor = LittleEndian.getShort(buf, offset);
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
fc = LittleEndian.getInt(buf, offset);
- offset += LittleEndian.INT_SIZE;
+ offset += LittleEndianConsts.INT_SIZE;
prm = new PropertyModifier(LittleEndian.getShort(buf, offset));
if (charset == null) {
// see if this piece uses unicode.
int offset = 0;
byte[] buf = new byte[8];
LittleEndian.putShort(buf, offset, descriptor);
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
LittleEndian.putInt(buf, offset, tempFc);
- offset += LittleEndian.INT_SIZE;
+ offset += LittleEndianConsts.INT_SIZE;
LittleEndian.putShort(buf, offset, prm.getValue());
return buf;
import org.apache.poi.util.IOUtils;
import org.apache.poi.util.Internal;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
/**
* Plex of CPs stored in File (PLCF)
public byte[] toByteArray() {
int size = _props.size();
- int cpBufSize = ((size + 1) * LittleEndian.INT_SIZE);
+ int cpBufSize = ((size + 1) * LittleEndianConsts.INT_SIZE);
int structBufSize = +(_cbStruct * size);
int bufSize = cpBufSize + structBufSize;
for (int x = 0; x < size; x++) {
GenericPropertyNode node = _props.get(x);
nodeEnd = node.getEnd();
-
+
// put the starting offset of the property into the plcf.
- LittleEndian.putInt(buf, (LittleEndian.INT_SIZE * x), node.getStart());
+ LittleEndian.putInt(buf, (LittleEndianConsts.INT_SIZE * x), node.getStart());
// put the struct into the plcf
System.arraycopy(node.getBytes(), 0, buf, cpBufSize + (x * _cbStruct), _cbStruct);
}
// put the ending offset of the last property into the plcf.
- LittleEndian.putInt(buf, LittleEndian.INT_SIZE * size, nodeEnd);
+ LittleEndian.putInt(buf, LittleEndianConsts.INT_SIZE * size, nodeEnd);
return buf;
}
import java.util.NoSuchElementException;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
import org.apache.poi.util.POILogFactory;
import org.apache.poi.util.POILogger;
* [MS-DOC] -- v20110315 Word (.doc) Binary File Format
*/
long lfoMacLong = LittleEndian.getUInt( tableStream, offset );
- offset += LittleEndian.INT_SIZE;
+ offset += LittleEndianConsts.INT_SIZE;
if ( lfoMacLong > Integer.MAX_VALUE )
{
import org.apache.poi.common.Duplicatable;
import org.apache.poi.util.Internal;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
/**
* Section Descriptor (SED)
public SectionDescriptor(byte[] buf, int offset)
{
fn = LittleEndian.getShort(buf, offset);
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
fcSepx = LittleEndian.getInt(buf, offset);
- offset += LittleEndian.INT_SIZE;
+ offset += LittleEndianConsts.INT_SIZE;
fnMpr = LittleEndian.getShort(buf, offset);
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
fcMpr = LittleEndian.getInt(buf, offset);
}
byte[] buf = new byte[12];
LittleEndian.putShort(buf, offset, fn);
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
LittleEndian.putInt(buf, offset, fcSepx);
- offset += LittleEndian.INT_SIZE;
+ offset += LittleEndianConsts.INT_SIZE;
LittleEndian.putShort(buf, offset, fnMpr);
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
LittleEndian.putInt(buf, offset, fcMpr);
return buf;
import org.apache.poi.util.IOUtils;
import org.apache.poi.util.Internal;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
import org.apache.poi.util.POILogFactory;
import org.apache.poi.util.POILogger;
// The first short at the offset is the size of the grpprl.
int sepxSize = LittleEndian.getShort(documentStream, fileOffset);
byte[] buf = IOUtils.safelyAllocate(sepxSize, MAX_RECORD_LENGTH);
- fileOffset += LittleEndian.SHORT_SIZE;
+ fileOffset += LittleEndianConsts.SHORT_SIZE;
System.arraycopy(documentStream, fileOffset, buf, 0, buf.length);
_sections.add(new SEPX(sed, startAt, endAt, buf));
}
import java.util.Arrays;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
import org.apache.poi.util.POILogFactory;
import org.apache.poi.util.POILogger;
import org.apache.poi.util.StringUtil;
* <p>
* This class is internal. It content or properties may change without notice
* due to changes in our knowledge of internal Microsoft Word binary structures.
- *
+ *
* @author Sergey Vladimirov; according to [MS-DOC] -- v20121003 Word (.doc)
* Binary File Format; Copyright (c) 2012 Microsoft Corporation;
* Release: October 8, 2012
public void fillFields( byte[] buffer, int startOffset )
{
short ffff = LittleEndian.getShort( buffer, startOffset );
- int offset = startOffset + LittleEndian.SHORT_SIZE;
+ int offset = startOffset + LittleEndianConsts.SHORT_SIZE;
if ( ffff != (short) 0xffff )
{
public int getSize()
{
// ffff
- int size = LittleEndian.SHORT_SIZE;
+ int size = LittleEndianConsts.SHORT_SIZE;
// cData
size += _cDataLength;
// cbExtra
- size += LittleEndian.SHORT_SIZE;
+ size += LittleEndianConsts.SHORT_SIZE;
if ( this._fExtend )
{
for ( String data : _data )
{
// cchData
- size += LittleEndian.SHORT_SIZE;
+ size += LittleEndianConsts.SHORT_SIZE;
// data
size += 2 * data.length();
}
for ( String data : _data )
{
// cchData
- size += LittleEndian.BYTE_SIZE;
+ size += LittleEndianConsts.BYTE_SIZE;
// data
- size += 1 * data.length();
+ size += data.length();
}
}
{
LittleEndian.putInt( buffer, 2, _data.length );
LittleEndian.putUShort( buffer, 6, _cbExtra );
- offset = 2 + LittleEndian.INT_SIZE + LittleEndian.SHORT_SIZE;
+ offset = 2 + LittleEndianConsts.INT_SIZE + LittleEndianConsts.SHORT_SIZE;
}
else
{
LittleEndian.putUShort( buffer, 2, _data.length );
LittleEndian.putUShort( buffer, 4, _cbExtra );
- offset = 2 + LittleEndian.SHORT_SIZE + LittleEndian.SHORT_SIZE;
+ offset = 2 + LittleEndianConsts.SHORT_SIZE + LittleEndianConsts.SHORT_SIZE;
}
for ( int i = 0; i < _data.length; i++ )
if ( _fExtend )
{
LittleEndian.putUShort( buffer, offset, entry.length() );
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
StringUtil.putUnicodeLE( entry, buffer, offset );
offset += 2 * entry.length();
import org.apache.poi.util.IOUtils;
import org.apache.poi.util.Internal;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
import org.apache.poi.util.POILogFactory;
import org.apache.poi.util.POILogger;
import org.apache.poi.util.StringUtil;
if (word9) {
nameLength = LittleEndian.getShort(std, nameStart);
multiplier = 2;
- nameStart += LittleEndian.SHORT_SIZE;
+ nameStart += LittleEndianConsts.SHORT_SIZE;
} else {
nameLength = std[nameStart];
}
_upxs = new UPX[countOfUPX];
for (int x = 0; x < countOfUPX; x++) {
int upxSize = LittleEndian.getShort(std, varOffset);
- varOffset += LittleEndian.SHORT_SIZE;
+ varOffset += LittleEndianConsts.SHORT_SIZE;
byte[] upx = IOUtils.safelyAllocate(upxSize, Short.MAX_VALUE);
System.arraycopy(std, varOffset, upx, 0, upxSize);
char[] letters = _name.toCharArray();
LittleEndian.putShort(buf, _baseLength, (short) letters.length);
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
for (int x = 0; x < letters.length; x++) {
LittleEndian.putShort(buf, offset, (short) letters[x]);
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
}
// get past the null delimiter for the name.
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
for (int x = 0; x < _upxs.length; x++) {
short upxSize = (short) _upxs[x].size();
LittleEndian.putShort(buf, offset, upxSize);
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
System.arraycopy(_upxs[x].getUPX(), 0, buf, offset, upxSize);
offset += upxSize + (upxSize % 2);
}
import org.apache.poi.hwpf.usermodel.ParagraphProperties;
import org.apache.poi.util.Internal;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
/**
* Represents a document's stylesheet. A word documents formatting is stored as
public StyleSheet(byte[] tableStream, int offset) {
int startOffset = offset;
_cbStshi = LittleEndian.getShort(tableStream, offset);
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
/*
* Count of styles in stylesheet
- *
+ *
* The number of styles in this style sheet. There will be stshi.cstd
* (cbSTD, STD) pairs in the file following the STSHI. Note: styles can
* be empty, i.e. cbSTD==0.
// shall we discard cbLSD and mpstilsd?
- offset = startOffset + LittleEndian.SHORT_SIZE + _cbStshi;
+ offset = startOffset + LittleEndianConsts.SHORT_SIZE + _cbStshi;
_styleDescriptions = new StyleDescription[_stshif.getCstd()];
for (int x = 0; x < _stshif.getCstd(); x++) {
int stdSize = LittleEndian.getShort(tableStream, offset);
byte[] buf = new byte[_cbStshi + 2];
LittleEndian.putUShort(buf, offset, (short) _cbStshi);
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
_stshif.setCstd(_styleDescriptions.length);
_stshif.serialize(buf, offset);
import java.util.Arrays;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
/**
* The Xst structure is a string. The string is prepended by its length and is
int offset = startOffset;
_cch = LittleEndian.getUShort( data, offset );
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
_rgtchar = new char[_cch];
for ( int x = 0; x < _cch; x++ )
{
_rgtchar[x] = (char) LittleEndian.getShort( data, offset );
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
}
}
public int getSize()
{
- return LittleEndian.SHORT_SIZE + _rgtchar.length * 2;
+ return LittleEndianConsts.SHORT_SIZE + _rgtchar.length * 2;
}
@Override
int offset = startOffset;
LittleEndian.putUShort( data, offset, _cch );
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
for ( char c : _rgtchar )
{
LittleEndian.putShort( data, offset, (short) c );
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
}
}
import org.apache.poi.util.Internal;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
import org.apache.poi.util.POILogFactory;
import org.apache.poi.util.POILogger;
public int getSize()
{
- return _xst.getSize() + LittleEndian.SHORT_SIZE;
+ return _xst.getSize() + LittleEndianConsts.SHORT_SIZE;
}
public int serialize( byte[] data, int startOffset )
offset += _xst.getSize();
LittleEndian.putUShort( data, offset, _chTerm );
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
return offset - startOffset;
}
import org.apache.poi.hwpf.usermodel.ShadingDescriptor80;
import org.apache.poi.util.Internal;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
import org.apache.poi.util.POILogFactory;
import org.apache.poi.util.POILogger;
for (int x = 0; x < delSize; x++)
{
tabMap.remove(Integer.valueOf(LittleEndian.getShort(grpprl, offset)));
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
}
int addSize = grpprl[offset++];
Integer key = Integer.valueOf(LittleEndian.getShort(grpprl, offset));
TabDescriptor val = new TabDescriptor( grpprl, start + ((TabDescriptor.getSize() * addSize) + x) );
tabMap.put(key, val);
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
}
tabPositions = new int[tabMap.size()];
pap.setRgdxaTab(tabPositions);
pap.setRgtbd(tabDescriptors);
}
-
-// private static void handleTabsAgain(ParagraphProperties pap, SprmOperation sprm)
-// {
-// byte[] grpprl = sprm.getGrpprl();
-// int offset = sprm.getGrpprlOffset();
-// int delSize = grpprl[offset++];
-// int[] tabPositions = pap.getRgdxaTab();
-// byte[] tabDescriptors = pap.getRgtbd();
-//
-// HashMap tabMap = new HashMap();
-// for (int x = 0; x < tabPositions.length; x++)
-// {
-// tabMap.put(Integer.valueOf(tabPositions[x]), Byte.valueOf(tabDescriptors[x]));
-// }
-//
-// for (int x = 0; x < delSize; x++)
-// {
-// tabMap.remove(Integer.valueOf(LittleEndian.getInt(grpprl, offset)));
-// offset += LittleEndian.INT_SIZE;;
-// }
-//
-// int addSize = grpprl[offset++];
-// for (int x = 0; x < addSize; x++)
-// {
-// Integer key = Integer.valueOf(LittleEndian.getInt(grpprl, offset));
-// Byte val = Byte.valueOf(grpprl[(LittleEndian.INT_SIZE * (addSize - x)) + x]);
-// tabMap.put(key, val);
-// offset += LittleEndian.INT_SIZE;
-// }
-//
-// tabPositions = new int[tabMap.size()];
-// tabDescriptors = new byte[tabPositions.length];
-// ArrayList list = new ArrayList();
-//
-// Iterator keyIT = tabMap.keySet().iterator();
-// while (keyIT.hasNext())
-// {
-// list.add(keyIT.next());
-// }
-// Collections.sort(list);
-//
-// for (int x = 0; x < tabPositions.length; x++)
-// {
-// Integer key = ((Integer)list.get(x));
-// tabPositions[x] = key.intValue();
-// tabDescriptors[x] = ((Byte)tabMap.get(key)).byteValue();
-// }
-//
-// pap.setRgdxaTab(tabPositions);
-// pap.setRgtbd(tabDescriptors);
-// }
-
}
import org.apache.poi.hwpf.usermodel.SectionProperties;
import org.apache.poi.util.Internal;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
@Internal
public final class SectionSprmCompressor
{
byte[] buf = new byte[7];
buf[0] = (byte)(newSEP.getFPropMark() ? 1 : 0);
- int offset = LittleEndian.BYTE_SIZE;
+ int offset = LittleEndianConsts.BYTE_SIZE;
LittleEndian.putShort(buf, 0, (short)newSEP.getIbstPropRMark());
- offset += LittleEndian.SHORT_SIZE;
+ offset += LittleEndianConsts.SHORT_SIZE;
newSEP.getDttmPropRMark().serialize(buf, offset);
size += SprmUtils.addSprm((short)0xD227, -1, buf, sprmList);
}
import org.apache.poi.util.IOUtils;
import org.apache.poi.util.Internal;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
import org.apache.poi.util.Removal;
@Internal
}
public void addSprm(short opcode, byte operand) {
- int addition = LittleEndian.SHORT_SIZE + LittleEndian.BYTE_SIZE;
+ int addition = LittleEndianConsts.SHORT_SIZE + LittleEndianConsts.BYTE_SIZE;
ensureCapacity(addition);
LittleEndian.putShort(_buf, _offset, opcode);
- _offset += LittleEndian.SHORT_SIZE;
+ _offset += LittleEndianConsts.SHORT_SIZE;
_buf[_offset++] = operand;
}
public void addSprm(short opcode, byte[] operand) {
- int addition = LittleEndian.SHORT_SIZE + LittleEndian.BYTE_SIZE + operand.length;
+ int addition = LittleEndianConsts.SHORT_SIZE + LittleEndianConsts.BYTE_SIZE + operand.length;
ensureCapacity(addition);
LittleEndian.putShort(_buf, _offset, opcode);
- _offset += LittleEndian.SHORT_SIZE;
+ _offset += LittleEndianConsts.SHORT_SIZE;
_buf[_offset++] = (byte) operand.length;
System.arraycopy(operand, 0, _buf, _offset, operand.length);
}
public void addSprm(short opcode, int operand) {
- int addition = LittleEndian.SHORT_SIZE + LittleEndian.INT_SIZE;
+ int addition = LittleEndianConsts.SHORT_SIZE + LittleEndianConsts.INT_SIZE;
ensureCapacity(addition);
LittleEndian.putShort(_buf, _offset, opcode);
- _offset += LittleEndian.SHORT_SIZE;
+ _offset += LittleEndianConsts.SHORT_SIZE;
LittleEndian.putInt(_buf, _offset, operand);
- _offset += LittleEndian.INT_SIZE;
+ _offset += LittleEndianConsts.INT_SIZE;
}
public void addSprm(short opcode, short operand) {
- int addition = LittleEndian.SHORT_SIZE + LittleEndian.SHORT_SIZE;
+ int addition = LittleEndianConsts.SHORT_SIZE + LittleEndianConsts.SHORT_SIZE;
ensureCapacity(addition);
LittleEndian.putShort(_buf, _offset, opcode);
- _offset += LittleEndian.SHORT_SIZE;
+ _offset += LittleEndianConsts.SHORT_SIZE;
LittleEndian.putShort(_buf, _offset, operand);
- _offset += LittleEndian.SHORT_SIZE;
+ _offset += LittleEndianConsts.SHORT_SIZE;
}
public void append(byte[] grpprl) {
import org.apache.poi.util.BitFieldFactory;
import org.apache.poi.util.Internal;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
/**
* This class is used to represent a sprm operation from a Word 97/2000/XP
{
return _gOffset;
}
-
+
public int getOperand()
{
switch ( getSizeCode() )
byte operandLength = _grpprl[_gOffset + 1];
// initialized to zeros by JVM
- byte[] codeBytes = new byte[LittleEndian.INT_SIZE];
+ byte[] codeBytes = new byte[LittleEndianConsts.INT_SIZE];
for ( int i = 0; i < operandLength; i++ )
if ( _gOffset + i < _grpprl.length )
codeBytes[i] = _grpprl[_gOffset + 1 + i];
import org.apache.poi.util.IOUtils;
import org.apache.poi.util.Internal;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
@Internal
public static byte[] shortArrayToByteArray(short[] convert)
{
- byte[] buf = IOUtils.safelyAllocate(convert.length * (long)LittleEndian.SHORT_SIZE, MAX_RECORD_LENGTH);
+ byte[] buf = IOUtils.safelyAllocate(convert.length * (long)LittleEndianConsts.SHORT_SIZE, MAX_RECORD_LENGTH);
for (int x = 0; x < convert.length; x++)
{
- LittleEndian.putShort(buf, x * LittleEndian.SHORT_SIZE, convert[x]);
+ LittleEndian.putShort(buf, x * LittleEndianConsts.SHORT_SIZE, convert[x]);
}
return buf;
{
byte[] buf = new byte[4];
LittleEndian.putShort(buf, 0, brc[0]);
- LittleEndian.putShort(buf, LittleEndian.SHORT_SIZE, brc[1]);
+ LittleEndian.putShort(buf, LittleEndianConsts.SHORT_SIZE, brc[1]);
return LittleEndian.getInt(buf);
}
}
import org.apache.poi.util.IOUtils;
import org.apache.poi.util.Internal;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
@Internal
public final class TableSprmCompressor
int itcMac = newTAP.getItcMac();
byte[] buf = IOUtils.safelyAllocate(
1
- + (LittleEndian.SHORT_SIZE*((long)itcMac + 1))
+ + (LittleEndianConsts.SHORT_SIZE*((long)itcMac + 1))
+ (TableCellDescriptor.SIZE*(long)itcMac),
MAX_RECORD_LENGTH);
buf[0] = (byte)itcMac;
short[] dxaCenters = newTAP.getRgdxaCenter();
for (int x = 0; x < dxaCenters.length; x++)
{
- LittleEndian.putShort(buf, 1 + (x * LittleEndian.SHORT_SIZE),
+ LittleEndian.putShort(buf, 1 + (x * LittleEndianConsts.SHORT_SIZE),
dxaCenters[x]);
}
for (int x = 0; x < cellDescriptors.length; x++)
{
cellDescriptors[x].serialize(buf,
- 1+((itcMac+1)*LittleEndian.SHORT_SIZE)+(x*TableCellDescriptor.SIZE));
+ 1+((itcMac+1)* LittleEndianConsts.SHORT_SIZE)+(x*TableCellDescriptor.SIZE));
}
size += SprmUtils.addSpecialSprm((short)0xD608, buf, sprmList);
import org.apache.poi.util.BitField;
import org.apache.poi.util.BitFieldFactory;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
import org.apache.poi.util.Removal;
/**
public BorderCode(byte[] buf, int offset)
{
_info = LittleEndian.getShort(buf, offset);
- _info2 = LittleEndian.getShort(buf, offset + LittleEndian.SHORT_SIZE);
+ _info2 = LittleEndian.getShort(buf, offset + LittleEndianConsts.SHORT_SIZE);
}
public void serialize(byte[] buf, int offset)
{
LittleEndian.putShort(buf, offset, _info);
- LittleEndian.putShort(buf, offset + LittleEndian.SHORT_SIZE, _info2);
+ LittleEndian.putShort(buf, offset + LittleEndianConsts.SHORT_SIZE, _info2);
}
public int toInt()
import org.apache.poi.util.BitField;
import org.apache.poi.util.BitFieldFactory;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
import org.apache.poi.util.LocaleUtil;
import org.apache.poi.util.Removal;
public DateAndTime(byte[] buf, int offset) {
_info = LittleEndian.getShort(buf, offset);
- _info2 = LittleEndian.getShort(buf, offset + LittleEndian.SHORT_SIZE);
+ _info2 = LittleEndian.getShort(buf, offset + LittleEndianConsts.SHORT_SIZE);
}
public Calendar getDate() {
public void serialize(byte[] buf, int offset)
{
LittleEndian.putShort(buf, offset, _info);
- LittleEndian.putShort(buf, offset + LittleEndian.SHORT_SIZE, _info2);
+ LittleEndian.putShort(buf, offset + LittleEndianConsts.SHORT_SIZE, _info2);
}
@Override
import org.apache.poi.common.Duplicatable;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
import org.apache.poi.util.Removal;
/**
public LineSpacingDescriptor(byte[] buf, int offset) {
_dyaLine = LittleEndian.getShort(buf, offset);
- _fMultiLinespace = LittleEndian.getShort(buf, offset + LittleEndian.SHORT_SIZE);
+ _fMultiLinespace = LittleEndian.getShort(buf, offset + LittleEndianConsts.SHORT_SIZE);
}
@Override
public void serialize(byte[] buf, int offset)
{
LittleEndian.putShort(buf, offset, _dyaLine);
- LittleEndian.putShort(buf, offset + LittleEndian.SHORT_SIZE, _fMultiLinespace);
+ LittleEndian.putShort(buf, offset + LittleEndianConsts.SHORT_SIZE, _fMultiLinespace);
}
public void setDyaLine(short dyaLine)
import org.apache.poi.util.DocumentFormatException;
import org.apache.poi.util.Internal;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
import org.apache.poi.util.POILogFactory;
import org.apache.poi.util.POILogger;
CharacterProperties baseChp = ss.getCharacterStyle(styleIndex);
byte[] grpprl = ParagraphSprmCompressor.compressParagraphProperty(props, baseStyle);
- byte[] withIndex = new byte[grpprl.length + LittleEndian.SHORT_SIZE];
+ byte[] withIndex = new byte[grpprl.length + LittleEndianConsts.SHORT_SIZE];
LittleEndian.putShort(withIndex, 0, (short) styleIndex);
- System.arraycopy(grpprl, 0, withIndex, LittleEndian.SHORT_SIZE, grpprl.length);
+ System.arraycopy(grpprl, 0, withIndex, LittleEndianConsts.SHORT_SIZE, grpprl.length);
SprmBuffer buf = new SprmBuffer(withIndex, 2);
_doc.getParagraphTable().insert(_parStart, _start, buf);
CharacterProperties baseChp = ss.getCharacterStyle(styleIndex);
byte[] grpprl = ParagraphSprmCompressor.compressParagraphProperty(props, baseStyle);
- byte[] withIndex = new byte[grpprl.length + LittleEndian.SHORT_SIZE];
+ byte[] withIndex = new byte[grpprl.length + LittleEndianConsts.SHORT_SIZE];
LittleEndian.putShort(withIndex, 0, (short) styleIndex);
- System.arraycopy(grpprl, 0, withIndex, LittleEndian.SHORT_SIZE, grpprl.length);
+ System.arraycopy(grpprl, 0, withIndex, LittleEndianConsts.SHORT_SIZE, grpprl.length);
SprmBuffer buf = new SprmBuffer(withIndex, 2);
_doc.getParagraphTable().insert(_parEnd, _end, buf);
projects / poi.git / commitdiff