What Is poi-scratchpad-5.2.3.jar?
What Is poi-scratchpad-5.2.3.jar?
✍: FYIcenter.com
poi-scratchpad-5.2.3.jar is one of the JAR files for Apache POI 5.2.3, which
provides an API for Microsoft document files of Word, Excel, PowerPoint, and Visio.
poi-scratchpad-5.2.3.jar provides support for older versions of Microsoft document files like Word 97, Excel 97, PowerPoint 97, etc.
poi-scratchpad-5.2.3.jar is distributed as part of the poi-bin-5.2.3-20220909.zip download file.
JAR File Size and Download Location:
JAR name: poi-scratchpad-5.2.3.jar Target JDK version: 9 Dependency: poi.jar File name: poi-scratchpad.jar, poi-scratchpad-5.2.3.jar File size: 1897121 bytes Release date: 09-09-2022 Download: Apache POI Website
Here are Java Source Code files for poi-scratchpad-5.2.3.jar:
⏎ org/apache/poi/hemf/record/emf/HemfText.java
/* ====================================================================
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.emf;
import static java.nio.charset.StandardCharsets.UTF_16LE;
import static org.apache.poi.hemf.record.emf.HemfDraw.readDimensionFloat;
import static org.apache.poi.hemf.record.emf.HemfDraw.readPointL;
import static org.apache.poi.hemf.record.emf.HemfDraw.readRectL;
import static org.apache.poi.hemf.record.emf.HemfRecordIterator.HEADER_SIZE;
import java.awt.geom.Dimension2D;
import java.awt.geom.Rectangle2D;
import java.io.IOException;
import java.nio.charset.Charset;
import java.util.Map;
import java.util.function.Supplier;
import org.apache.poi.hemf.draw.HemfGraphics;
import org.apache.poi.hwmf.draw.HwmfGraphics;
import org.apache.poi.hwmf.record.HwmfText;
import org.apache.poi.hwmf.record.HwmfText.WmfSetTextAlign;
import org.apache.poi.util.Dimension2DDouble;
import org.apache.poi.util.GenericRecordJsonWriter;
import org.apache.poi.util.GenericRecordUtil;
import org.apache.poi.util.IOUtils;
import org.apache.poi.util.Internal;
import org.apache.poi.util.LittleEndianConsts;
import org.apache.poi.util.LittleEndianInputStream;
import org.apache.poi.util.RecordFormatException;
/**
* Container class to gather all text-related commands
* This is starting out as read only, and very little is actually
* implemented at this point!
*/
@Internal
@SuppressWarnings("WeakerAccess")
public class HemfText {
private static final int DEFAULT_MAX_RECORD_LENGTH = 1_000_000;
private static int MAX_RECORD_LENGTH = DEFAULT_MAX_RECORD_LENGTH;
/**
* @param length the max record length allowed for HemfText
*/
public static void setMaxRecordLength(int length) {
MAX_RECORD_LENGTH = length;
}
/**
* @return the max record length allowed for HemfText
*/
public static int getMaxRecordLength() {
return MAX_RECORD_LENGTH;
}
public enum EmfGraphicsMode {
GM_COMPATIBLE, GM_ADVANCED
}
public static class EmfExtTextOutA extends HwmfText.WmfExtTextOut implements HemfRecord {
protected Rectangle2D boundsIgnored = new Rectangle2D.Double();
protected EmfGraphicsMode graphicsMode;
/**
* The scale factor to apply along the X/Y axis to convert from page space units to .01mm units.
* This SHOULD be used only if the graphics mode specified by iGraphicsMode is GM_COMPATIBLE.
*/
protected final Dimension2D scale = new Dimension2DDouble();
public EmfExtTextOutA() {
super(new EmfExtTextOutOptions());
}
@Override
public HemfRecordType getEmfRecordType() {
return HemfRecordType.extTextOutA;
}
@Override
public long init(LittleEndianInputStream leis, long recordSize, long recordId) throws IOException {
if (recordSize < 0 || Integer.MAX_VALUE <= recordSize) {
throw new RecordFormatException("recordSize must be a positive integer (0-0x7FFFFFFF)");
}
// A WMF RectL object. It is not used and MUST be ignored on receipt.
long size = readRectL(leis, boundsIgnored);
// A 32-bit unsigned integer that specifies the graphics mode from the GraphicsMode enumeration
graphicsMode = EmfGraphicsMode.values()[leis.readInt()-1];
size += LittleEndianConsts.INT_SIZE;
size += readDimensionFloat(leis, scale);
// A WMF PointL object that specifies the coordinates of the reference point used to position the string.
// The reference point is defined by the last EMR_SETTEXTALIGN record.
// If no such record has been set, the defaulint alignment is TA_LEFT,TA_TOP.
size += readPointL(leis, reference);
// A 32-bit unsigned integer that specifies the number of characters in the string.
stringLength = (int)leis.readUInt();
// A 32-bit unsigned integer that specifies the offset to the output string, in bytes,
// from the start of the record in which this object is contained.
// This value MUST be 8- or 16-bit aligned, according to the character format.
int offString = (int)leis.readUInt();
size += 2*LittleEndianConsts.INT_SIZE;
size += options.init(leis);
// An optional WMF RectL object that defines a clipping and/or opaquing rectangle in logical units.
// This rectangle is applied to the text output performed by the containing record.
if (options.isClipped() || options.isOpaque()) {
size += readRectL(leis, bounds);
}
// A 32-bit unsigned integer that specifies the offset to an intercharacter spacing array, in bytes,
// from the start of the record in which this object is contained. This value MUST be 32-bit aligned.
int offDx = (int)leis.readUInt();
size += LittleEndianConsts.INT_SIZE;
// handle dx before string and other way round
final String order = (offDx < offString) ? "ds" : "sd";
// the next byte index after the string ends
int strEnd = (int)((offDx <= HEADER_SIZE) ? recordSize : offDx-HEADER_SIZE);
for (char op : order.toCharArray()) {
switch (op) {
case 'd': {
dx.clear();
int undefinedSpace2 = (int) (offDx - (size + HEADER_SIZE));
if (offDx > 0 && undefinedSpace2 >= 0 && offDx-HEADER_SIZE < recordSize) {
leis.skipFully(undefinedSpace2);
size += undefinedSpace2;
// An array of 32-bit unsigned integers that specify the output spacing between the origins of adjacent
// character cells in logical units. The location of this field is specified by the value of offDx
// in bytes from the start of this record. If spacing is defined, this field contains the same number
// of values as characters in the output string.
//
// If the Options field of the EmrText object contains the ETO_PDY flag, then this buffer
// contains twice as many values as there are characters in the output string, one
// horizontal and one vertical offset for each, in that order.
//
// If ETO_RTLREADING is specified, characters are laid right to left instead of left to right.
// No other options affect the interpretation of this field.
final int maxSize = (int)Math.min((offDx < offString) ? (offString-HEADER_SIZE) : recordSize, recordSize);
while (size <= maxSize-LittleEndianConsts.INT_SIZE) {
dx.add((int) leis.readUInt());
size += LittleEndianConsts.INT_SIZE;
}
}
if (dx.size() < stringLength) {
// invalid dx array
dx.clear();
}
strEnd = Math.toIntExact(recordSize);
break;
}
default:
case 's': {
int undefinedSpace1 = Math.toIntExact(offString - (size + HEADER_SIZE));
if (offString > 0 && undefinedSpace1 >= 0 && offString-HEADER_SIZE < recordSize) {
leis.skipFully(undefinedSpace1);
size += undefinedSpace1;
// read all available bytes and not just "stringLength * 1(ansi)/2(unicode)"
// in case we need to deal with surrogate pairs
final int maxSize = Math.toIntExact(Math.min(recordSize, strEnd)-size);
rawTextBytes = IOUtils.safelyAllocate(maxSize, MAX_RECORD_LENGTH);
leis.readFully(rawTextBytes);
size += maxSize;
break;
}
}
}
}
return size;
}
/**
*
* To be implemented! We need to get the current character set
* from the current font for {@link EmfExtTextOutA},
* which has to be tracked in the playback device.
*
* For {@link EmfExtTextOutW}, the charset is "UTF-16LE"
*
* @param charset the charset to be used to decode the character bytes
* @return text from this text element
* @throws IOException if the charset is not compatible to the underlying bytes
*/
public String getText(Charset charset) throws IOException {
return super.getText(charset);
}
public EmfGraphicsMode getGraphicsMode() {
return graphicsMode;
}
public Dimension2D getScale() {
return scale;
}
@Override
public void draw(HwmfGraphics ctx) {
// A 32-bit floating-point value that specifies the scale factor to apply along
// the axis to convert from page space units to .01mm units.
// This SHOULD be used only if the graphics mode specified by iGraphicsMode is GM_COMPATIBLE.
Dimension2D scl = graphicsMode == EmfGraphicsMode.GM_COMPATIBLE ? scale : null;
ctx.setCharsetProvider(charsetProvider);
ctx.drawString(rawTextBytes, stringLength, reference, scl, bounds, options, dx, isUnicode());
}
@Override
public String toString() {
return GenericRecordJsonWriter.marshal(this);
}
@Override
public Map<String, Supplier<?>> getGenericProperties() {
return GenericRecordUtil.getGenericProperties(
"base", super::getGenericProperties,
"boundsIgnored", () -> boundsIgnored,
"graphicsMode", this::getGraphicsMode,
"scale", this::getScale
);
}
@Override
public HemfRecordType getGenericRecordType() {
return getEmfRecordType();
}
}
public static class EmfExtTextOutW extends EmfExtTextOutA {
@Override
public HemfRecordType getEmfRecordType() {
return HemfRecordType.extTextOutW;
}
public String getText() throws IOException {
return getText(UTF_16LE);
}
protected boolean isUnicode() {
return true;
}
}
/**
* The EMR_SETTEXTALIGN record specifies text alignment.
*/
public static class EmfSetTextAlign extends WmfSetTextAlign implements HemfRecord {
@Override
public HemfRecordType getEmfRecordType() {
return HemfRecordType.setTextAlign;
}
@Override
public long init(LittleEndianInputStream leis, long recordSize, long recordId) throws IOException {
// A 32-bit unsigned integer that specifies text alignment by using a mask of text alignment flags.
// These are either WMF TextAlignmentMode Flags for text with a horizontal baseline,
// or WMF VerticalTextAlignmentMode Flags for text with a vertical baseline.
// Only one value can be chosen from those that affect horizontal and vertical alignment.
textAlignmentMode = (int)leis.readUInt();
return LittleEndianConsts.INT_SIZE;
}
@Override
public HemfRecordType getGenericRecordType() {
return getEmfRecordType();
}
}
/**
* The EMR_SETTEXTCOLOR record defines the current text color.
*/
public static class EmfSetTextColor extends HwmfText.WmfSetTextColor implements HemfRecord {
@Override
public HemfRecordType getEmfRecordType() {
return HemfRecordType.setTextColor;
}
@Override
public long init(LittleEndianInputStream leis, long recordSize, long recordId) throws IOException {
return colorRef.init(leis);
}
@Override
public HemfRecordType getGenericRecordType() {
return getEmfRecordType();
}
}
public static class EmfExtCreateFontIndirectW extends HwmfText.WmfCreateFontIndirect
implements HemfRecord {
int fontIdx;
public EmfExtCreateFontIndirectW() {
super(new HemfFont());
}
@Override
public HemfRecordType getEmfRecordType() {
return HemfRecordType.extCreateFontIndirectW;
}
@Override
public long init(LittleEndianInputStream leis, long recordSize, long recordId) throws IOException {
// A 32-bit unsigned integer that specifies the index of the logical font object
// in the EMF Object Table
fontIdx = (int)leis.readUInt();
long size = font.init(leis, (int)(recordSize-LittleEndianConsts.INT_SIZE));
return size+LittleEndianConsts.INT_SIZE;
}
@Override
public void draw(HemfGraphics ctx) {
ctx.addObjectTableEntry(this, fontIdx);
}
@Override
public String toString() {
return GenericRecordJsonWriter.marshal(this);
}
public int getFontIdx() {
return fontIdx;
}
@Override
public Map<String, Supplier<?>> getGenericProperties() {
return GenericRecordUtil.getGenericProperties(
"base", super::getGenericProperties,
"fontIdx", this::getFontIdx
);
}
@Override
public HemfRecordType getGenericRecordType() {
return getEmfRecordType();
}
}
public static class EmfExtTextOutOptions extends HwmfText.WmfExtTextOutOptions {
@Override
public int init(LittleEndianInputStream leis) {
// A 32-bit unsigned integer that specifies how to use the rectangle specified in the Rectangle field.
// This field can be a combination of more than one ExtTextOutOptions enumeration
flags = (int)leis.readUInt();
return LittleEndianConsts.INT_SIZE;
}
}
public static class SetTextJustification extends UnimplementedHemfRecord {
}
/**
* Needs to be implemented. Couldn't find example.
*/
public static class PolyTextOutA extends UnimplementedHemfRecord {
}
/**
* Needs to be implemented. Couldn't find example.
*/
public static class PolyTextOutW extends UnimplementedHemfRecord {
}
}
⏎ org/apache/poi/hemf/record/emf/HemfText.java
Or download all of them as a single archive file:
File name: poi-scratchpad-5.2.3-src.zip File size: 1238744 bytes Release date: 2022-09-09 Download
⇒ What Is poi-examples-5.2.3.jar?
⇐ What Is poi-excelant-5.2.3.jar?
2017-03-22, 34436👍, 0💬
Related Topics: