/**
* Title: FeatFormulaErr2 (Formula Evaluation Shared Feature) common record part
*
* <p>This record part specifies Formula Evaluation & Error Ignoring data for a sheet, stored as
* part of a Shared Feature. It can be found in records such as {@link FeatRecord}. For the full
* meanings of the flags, see pages 669 and 670 of the Excel binary file format documentation.
*/
public final class FeatFormulaErr2 implements SharedFeature {
static BitField checkCalculationErrors = BitFieldFactory.getInstance(0x01);
static BitField checkEmptyCellRef = BitFieldFactory.getInstance(0x02);
static BitField checkNumbersAsText = BitFieldFactory.getInstance(0x04);
static BitField checkInconsistentRanges = BitFieldFactory.getInstance(0x08);
static BitField checkInconsistentFormulas = BitFieldFactory.getInstance(0x10);
static BitField checkDateTimeFormats = BitFieldFactory.getInstance(0x20);
static BitField checkUnprotectedFormulas = BitFieldFactory.getInstance(0x40);
static BitField performDataValidation = BitFieldFactory.getInstance(0x80);
/** What errors we should ignore */
private int errorCheck;
public FeatFormulaErr2() {}
public FeatFormulaErr2(RecordInputStream in) {
errorCheck = in.readInt();
}
public String toString() {
StringBuffer buffer = new StringBuffer();
buffer.append(" [FEATURE FORMULA ERRORS]\n");
buffer.append(" checkCalculationErrors = ");
buffer.append(" checkEmptyCellRef = ");
buffer.append(" checkNumbersAsText = ");
buffer.append(" checkInconsistentRanges = ");
buffer.append(" checkInconsistentFormulas = ");
buffer.append(" checkDateTimeFormats = ");
buffer.append(" checkUnprotectedFormulas = ");
buffer.append(" performDataValidation = ");
buffer.append(" [/FEATURE FORMULA ERRORS]\n");
return buffer.toString();
}
public void serialize(LittleEndianOutput out) {
out.writeInt(errorCheck);
}
public int getDataSize() {
return 4;
}
public int _getRawErrorCheckValue() {
return errorCheck;
}
public boolean getCheckCalculationErrors() {
return checkCalculationErrors.isSet(errorCheck);
}
public void setCheckCalculationErrors(boolean checkCalculationErrors) {
FeatFormulaErr2.checkCalculationErrors.setBoolean(errorCheck, checkCalculationErrors);
}
public boolean getCheckEmptyCellRef() {
return checkEmptyCellRef.isSet(errorCheck);
}
public void setCheckEmptyCellRef(boolean checkEmptyCellRef) {
FeatFormulaErr2.checkEmptyCellRef.setBoolean(errorCheck, checkEmptyCellRef);
}
public boolean getCheckNumbersAsText() {
return checkNumbersAsText.isSet(errorCheck);
}
public void setCheckNumbersAsText(boolean checkNumbersAsText) {
FeatFormulaErr2.checkNumbersAsText.setBoolean(errorCheck, checkNumbersAsText);
}
public boolean getCheckInconsistentRanges() {
return checkInconsistentRanges.isSet(errorCheck);
}
public void setCheckInconsistentRanges(boolean checkInconsistentRanges) {
FeatFormulaErr2.checkInconsistentRanges.setBoolean(errorCheck, checkInconsistentRanges);
}
public boolean getCheckInconsistentFormulas() {
return checkInconsistentFormulas.isSet(errorCheck);
}
public void setCheckInconsistentFormulas(boolean checkInconsistentFormulas) {
FeatFormulaErr2.checkInconsistentFormulas.setBoolean(errorCheck, checkInconsistentFormulas);
}
public boolean getCheckDateTimeFormats() {
return checkDateTimeFormats.isSet(errorCheck);
}
public void setCheckDateTimeFormats(boolean checkDateTimeFormats) {
FeatFormulaErr2.checkDateTimeFormats.setBoolean(errorCheck, checkDateTimeFormats);
}
public boolean getCheckUnprotectedFormulas() {
return checkUnprotectedFormulas.isSet(errorCheck);
}
public void setCheckUnprotectedFormulas(boolean checkUnprotectedFormulas) {
FeatFormulaErr2.checkUnprotectedFormulas.setBoolean(errorCheck, checkUnprotectedFormulas);
}
public boolean getPerformDataValidation() {
return performDataValidation.isSet(errorCheck);
}
public void setPerformDataValidation(boolean performDataValidation) {
FeatFormulaErr2.performDataValidation.setBoolean(errorCheck, performDataValidation);
}
}
/**
* Title: Unicode String
*
* <p>Description: Unicode String - just standard fields that are in several records. It is
* considered more desirable then repeating it in all of them.
*
* <p>This is often called a XLUnicodeRichExtendedString in MS documentation.
*
* <p>REFERENCE: PG 264 Microsoft Excel 97 Developer's Kit (ISBN: 1-57231-498-2)
*
* <p>REFERENCE: PG 951 Excel Binary File Format (.xls) Structure Specification v20091214
*/
public class UnicodeString
implements Comparable<
UnicodeString> { // TODO - make this final when the compatibility version is removed
private short field_1_charCount;
private byte field_2_optionflags;
private String field_3_string;
private List<FormatRun> field_4_format_runs;
private ExtRst field_5_ext_rst;
private static final BitField highByte = BitFieldFactory.getInstance(0x1);
// 0x2 is reserved
private static final BitField extBit = BitFieldFactory.getInstance(0x4);
private static final BitField richText = BitFieldFactory.getInstance(0x8);
public static class FormatRun implements Comparable<FormatRun> {
final short _character;
short _fontIndex;
public FormatRun(short character, short fontIndex) {
this._character = character;
this._fontIndex = fontIndex;
}
public FormatRun(LittleEndianInput in) {
this(in.readShort(), in.readShort());
}
public short getCharacterPos() {
return _character;
}
public short getFontIndex() {
return _fontIndex;
}
public boolean equals(Object o) {
if (!(o instanceof FormatRun)) {
return false;
}
FormatRun other = (FormatRun) o;
return _character == other._character && _fontIndex == other._fontIndex;
}
public int compareTo(FormatRun r) {
if (_character == r._character && _fontIndex == r._fontIndex) {
return 0;
}
if (_character == r._character) {
return _fontIndex - r._fontIndex;
}
return _character - r._character;
}
public String toString() {
return "character=" + _character + ",fontIndex=" + _fontIndex;
}
public void serialize(LittleEndianOutput out) {
out.writeShort(_character);
out.writeShort(_fontIndex);
}
}
// See page 681
public static class ExtRst implements Comparable<ExtRst> {
private short reserved;
// This is a Phs (see page 881)
private short formattingFontIndex;
private short formattingOptions;
// This is a RPHSSub (see page 894)
private int numberOfRuns;
private String phoneticText;
// This is an array of PhRuns (see page 881)
private PhRun[] phRuns;
// Sometimes there's some cruft at the end
private byte[] extraData;
private void populateEmpty() {
reserved = 1;
phoneticText = "";
phRuns = new PhRun[0];
extraData = new byte[0];
}
protected ExtRst() {
populateEmpty();
}
protected ExtRst(LittleEndianInput in, int expectedLength) {
reserved = in.readShort();
// Old style detection (Reserved = 0xFF)
if (reserved == -1) {
populateEmpty();
return;
}
// Spot corrupt records
if (reserved != 1) {
System.err.println(
"Warning - ExtRst was has wrong magic marker, expecting 1 but found "
+ reserved
+ " - ignoring");
// Grab all the remaining data, and ignore it
for (int i = 0; i < expectedLength - 2; i++) {
in.readByte();
}
// And make us be empty
populateEmpty();
return;
}
// Carry on reading in as normal
short stringDataSize = in.readShort();
formattingFontIndex = in.readShort();
formattingOptions = in.readShort();
// RPHSSub
numberOfRuns = in.readUShort();
short length1 = in.readShort();
// No really. Someone clearly forgot to read
// the docs on their datastructure...
short length2 = in.readShort();
// And sometimes they write out garbage :(
if (length1 == 0 && length2 > 0) {
length2 = 0;
}
if (length1 != length2) {
throw new IllegalStateException(
"The two length fields of the Phonetic Text don't agree! "
+ length1
+ " vs "
+ length2);
}
phoneticText = StringUtil.readUnicodeLE(in, length1);
int runData = stringDataSize - 4 - 6 - (2 * phoneticText.length());
int numRuns = (runData / 6);
phRuns = new PhRun[numRuns];
for (int i = 0; i < phRuns.length; i++) {
phRuns[i] = new PhRun(in);
}
int extraDataLength = runData - (numRuns * 6);
if (extraDataLength < 0) {
System.err.println("Warning - ExtRst overran by " + (0 - extraDataLength) + " bytes");
extraDataLength = 0;
}
extraData = new byte[extraDataLength];
for (int i = 0; i < extraData.length; i++) {
extraData[i] = in.readByte();
}
}
/** Returns our size, excluding our 4 byte header */
protected int getDataSize() {
return 4 + 6 + (2 * phoneticText.length()) + (6 * phRuns.length) + extraData.length;
}
protected void serialize(ContinuableRecordOutput out) {
int dataSize = getDataSize();
out.writeContinueIfRequired(8);
out.writeShort(reserved);
out.writeShort(dataSize);
out.writeShort(formattingFontIndex);
out.writeShort(formattingOptions);
out.writeContinueIfRequired(6);
out.writeShort(numberOfRuns);
out.writeShort(phoneticText.length());
out.writeShort(phoneticText.length());
out.writeContinueIfRequired(phoneticText.length() * 2);
StringUtil.putUnicodeLE(phoneticText, out);
for (int i = 0; i < phRuns.length; i++) {
phRuns[i].serialize(out);
}
out.write(extraData);
}
public boolean equals(Object obj) {
if (!(obj instanceof ExtRst)) {
return false;
}
ExtRst other = (ExtRst) obj;
return (compareTo(other) == 0);
}
public int compareTo(ExtRst o) {
int result;
result = reserved - o.reserved;
if (result != 0) return result;
result = formattingFontIndex - o.formattingFontIndex;
if (result != 0) return result;
result = formattingOptions - o.formattingOptions;
if (result != 0) return result;
result = numberOfRuns - o.numberOfRuns;
if (result != 0) return result;
result = phoneticText.compareTo(o.phoneticText);
if (result != 0) return result;
result = phRuns.length - o.phRuns.length;
if (result != 0) return result;
for (int i = 0; i < phRuns.length; i++) {
result =
phRuns[i].phoneticTextFirstCharacterOffset
- o.phRuns[i].phoneticTextFirstCharacterOffset;
if (result != 0) return result;
result = phRuns[i].realTextFirstCharacterOffset - o.phRuns[i].realTextFirstCharacterOffset;
if (result != 0) return result;
result = phRuns[i].realTextFirstCharacterOffset - o.phRuns[i].realTextLength;
if (result != 0) return result;
}
result = extraData.length - o.extraData.length;
if (result != 0) return result;
// If we get here, it's the same
return 0;
}
protected ExtRst clone() {
ExtRst ext = new ExtRst();
ext.reserved = reserved;
ext.formattingFontIndex = formattingFontIndex;
ext.formattingOptions = formattingOptions;
ext.numberOfRuns = numberOfRuns;
ext.phoneticText = phoneticText;
ext.phRuns = new PhRun[phRuns.length];
for (int i = 0; i < ext.phRuns.length; i++) {
ext.phRuns[i] =
new PhRun(
phRuns[i].phoneticTextFirstCharacterOffset,
phRuns[i].realTextFirstCharacterOffset,
phRuns[i].realTextLength);
}
return ext;
}
public short getFormattingFontIndex() {
return formattingFontIndex;
}
public short getFormattingOptions() {
return formattingOptions;
}
public int getNumberOfRuns() {
return numberOfRuns;
}
public String getPhoneticText() {
return phoneticText;
}
public PhRun[] getPhRuns() {
return phRuns;
}
}
public static class PhRun {
private int phoneticTextFirstCharacterOffset;
private int realTextFirstCharacterOffset;
private int realTextLength;
public PhRun(
int phoneticTextFirstCharacterOffset,
int realTextFirstCharacterOffset,
int realTextLength) {
this.phoneticTextFirstCharacterOffset = phoneticTextFirstCharacterOffset;
this.realTextFirstCharacterOffset = realTextFirstCharacterOffset;
this.realTextLength = realTextLength;
}
private PhRun(LittleEndianInput in) {
phoneticTextFirstCharacterOffset = in.readUShort();
realTextFirstCharacterOffset = in.readUShort();
realTextLength = in.readUShort();
}
private void serialize(ContinuableRecordOutput out) {
out.writeContinueIfRequired(6);
out.writeShort(phoneticTextFirstCharacterOffset);
out.writeShort(realTextFirstCharacterOffset);
out.writeShort(realTextLength);
}
}
private UnicodeString() {
// Used for clone method.
}
public UnicodeString(String str) {
setString(str);
}
public int hashCode() {
int stringHash = 0;
if (field_3_string != null) stringHash = field_3_string.hashCode();
return field_1_charCount + stringHash;
}
/**
* Our handling of equals is inconsistent with compareTo. The trouble is because we don't truely
* understand rich text fields yet it's difficult to make a sound comparison.
*
* @param o The object to compare.
* @return true if the object is actually equal.
*/
public boolean equals(Object o) {
if (!(o instanceof UnicodeString)) {
return false;
}
UnicodeString other = (UnicodeString) o;
// OK lets do this in stages to return a quickly, first check the actual string
boolean eq =
((field_1_charCount == other.field_1_charCount)
&& (field_2_optionflags == other.field_2_optionflags)
&& field_3_string.equals(other.field_3_string));
if (!eq) return false;
// OK string appears to be equal but now lets compare formatting runs
if ((field_4_format_runs == null) && (other.field_4_format_runs == null))
// Strings are equal, and there are not formatting runs.
return true;
if (((field_4_format_runs == null) && (other.field_4_format_runs != null))
|| (field_4_format_runs != null) && (other.field_4_format_runs == null))
// Strings are equal, but one or the other has formatting runs
return false;
// Strings are equal, so now compare formatting runs.
int size = field_4_format_runs.size();
if (size != other.field_4_format_runs.size()) return false;
for (int i = 0; i < size; i++) {
FormatRun run1 = field_4_format_runs.get(i);
FormatRun run2 = other.field_4_format_runs.get(i);
if (!run1.equals(run2)) return false;
}
// Well the format runs are equal as well!, better check the ExtRst data
if (field_5_ext_rst == null && other.field_5_ext_rst == null) {
// Good
} else if (field_5_ext_rst != null && other.field_5_ext_rst != null) {
int extCmp = field_5_ext_rst.compareTo(other.field_5_ext_rst);
if (extCmp == 0) {
// Good
} else {
return false;
}
} else {
return false;
}
// Phew!! After all of that we have finally worked out that the strings
// are identical.
return true;
}
/**
* construct a unicode string record and fill its fields, ID is ignored
*
* @param in the RecordInputstream to read the record from
*/
public UnicodeString(RecordInputStream in) {
field_1_charCount = in.readShort();
field_2_optionflags = in.readByte();
int runCount = 0;
int extensionLength = 0;
// Read the number of rich runs if rich text.
if (isRichText()) {
runCount = in.readShort();
}
// Read the size of extended data if present.
if (isExtendedText()) {
extensionLength = in.readInt();
}
boolean isCompressed = ((field_2_optionflags & 1) == 0);
if (isCompressed) {
field_3_string = in.readCompressedUnicode(getCharCount());
} else {
field_3_string = in.readUnicodeLEString(getCharCount());
}
if (isRichText() && (runCount > 0)) {
field_4_format_runs = new ArrayList<FormatRun>(runCount);
for (int i = 0; i < runCount; i++) {
field_4_format_runs.add(new FormatRun(in));
}
}
if (isExtendedText() && (extensionLength > 0)) {
field_5_ext_rst = new ExtRst(new ContinuableRecordInput(in), extensionLength);
if (field_5_ext_rst.getDataSize() + 4 != extensionLength) {
System.err.println(
"ExtRst was supposed to be "
+ extensionLength
+ " bytes long, but seems to actually be "
+ (field_5_ext_rst.getDataSize() + 4));
}
}
}
/**
* get the number of characters in the string, as an un-wrapped int
*
* @return number of characters
*/
public int getCharCount() {
if (field_1_charCount < 0) {
return field_1_charCount + 65536;
}
return field_1_charCount;
}
/**
* get the number of characters in the string, wrapped as needed to fit within a short
*
* @return number of characters
*/
public short getCharCountShort() {
return field_1_charCount;
}
/**
* set the number of characters in the string
*
* @param cc - number of characters
*/
public void setCharCount(short cc) {
field_1_charCount = cc;
}
/**
* get the option flags which among other things return if this is a 16-bit or 8 bit string
*
* @return optionflags bitmask
*/
public byte getOptionFlags() {
return field_2_optionflags;
}
/**
* set the option flags which among other things return if this is a 16-bit or 8 bit string
*
* @param of optionflags bitmask
*/
public void setOptionFlags(byte of) {
field_2_optionflags = of;
}
/** @return the actual string this contains as a java String object */
public String getString() {
return field_3_string;
}
/**
* set the actual string this contains
*
* @param string the text
*/
public void setString(String string) {
field_3_string = string;
setCharCount((short) field_3_string.length());
// scan for characters greater than 255 ... if any are
// present, we have to use 16-bit encoding. Otherwise, we
// can use 8-bit encoding
boolean useUTF16 = false;
int strlen = string.length();
for (int j = 0; j < strlen; j++) {
if (string.charAt(j) > 255) {
useUTF16 = true;
break;
}
}
if (useUTF16)
// Set the uncompressed bit
field_2_optionflags = highByte.setByte(field_2_optionflags);
else field_2_optionflags = highByte.clearByte(field_2_optionflags);
}
public int getFormatRunCount() {
if (field_4_format_runs == null) return 0;
return field_4_format_runs.size();
}
public FormatRun getFormatRun(int index) {
if (field_4_format_runs == null) {
return null;
}
if (index < 0 || index >= field_4_format_runs.size()) {
return null;
}
return field_4_format_runs.get(index);
}
private int findFormatRunAt(int characterPos) {
int size = field_4_format_runs.size();
for (int i = 0; i < size; i++) {
FormatRun r = field_4_format_runs.get(i);
if (r._character == characterPos) return i;
else if (r._character > characterPos) return -1;
}
return -1;
}
/**
* Adds a font run to the formatted string.
*
* <p>If a font run exists at the current charcter location, then it is replaced with the font run
* to be added.
*/
public void addFormatRun(FormatRun r) {
if (field_4_format_runs == null) {
field_4_format_runs = new ArrayList<FormatRun>();
}
int index = findFormatRunAt(r._character);
if (index != -1) field_4_format_runs.remove(index);
field_4_format_runs.add(r);
// Need to sort the font runs to ensure that the font runs appear in
// character order
Collections.sort(field_4_format_runs);
// Make sure that we now say that we are a rich string
field_2_optionflags = richText.setByte(field_2_optionflags);
}
public Iterator<FormatRun> formatIterator() {
if (field_4_format_runs != null) {
return field_4_format_runs.iterator();
}
return null;
}
public void removeFormatRun(FormatRun r) {
field_4_format_runs.remove(r);
if (field_4_format_runs.size() == 0) {
field_4_format_runs = null;
field_2_optionflags = richText.clearByte(field_2_optionflags);
}
}
public void clearFormatting() {
field_4_format_runs = null;
field_2_optionflags = richText.clearByte(field_2_optionflags);
}
public ExtRst getExtendedRst() {
return this.field_5_ext_rst;
}
void setExtendedRst(ExtRst ext_rst) {
if (ext_rst != null) {
field_2_optionflags = extBit.setByte(field_2_optionflags);
} else {
field_2_optionflags = extBit.clearByte(field_2_optionflags);
}
this.field_5_ext_rst = ext_rst;
}
/**
* Swaps all use in the string of one font index for use of a different font index. Normally only
* called when fonts have been removed / re-ordered
*/
public void swapFontUse(short oldFontIndex, short newFontIndex) {
for (FormatRun run : field_4_format_runs) {
if (run._fontIndex == oldFontIndex) {
run._fontIndex = newFontIndex;
}
}
}
/**
* unlike the real records we return the same as "getString()" rather than debug info
*
* @see #getDebugInfo()
* @return String value of the record
*/
public String toString() {
return getString();
}
/**
* return a character representation of the fields of this record
*
* @return String of output for biffviewer etc.
*/
public String getDebugInfo() {
StringBuffer buffer = new StringBuffer();
buffer.append("[UNICODESTRING]\n");
buffer
.append(" .charcount = ")
.append(Integer.toHexString(getCharCount()))
.append("\n");
buffer
.append(" .optionflags = ")
.append(Integer.toHexString(getOptionFlags()))
.append("\n");
buffer.append(" .string = ").append(getString()).append("\n");
if (field_4_format_runs != null) {
for (int i = 0; i < field_4_format_runs.size(); i++) {
FormatRun r = field_4_format_runs.get(i);
buffer.append(" .format_run" + i + " = ").append(r.toString()).append("\n");
}
}
if (field_5_ext_rst != null) {
buffer.append(" .field_5_ext_rst = ").append("\n");
buffer.append(field_5_ext_rst.toString()).append("\n");
}
buffer.append("[/UNICODESTRING]\n");
return buffer.toString();
}
/**
* Serialises out the String. There are special rules about where we can and can't split onto
* Continue records.
*/
public void serialize(ContinuableRecordOutput out) {
int numberOfRichTextRuns = 0;
int extendedDataSize = 0;
if (isRichText() && field_4_format_runs != null) {
numberOfRichTextRuns = field_4_format_runs.size();
}
if (isExtendedText() && field_5_ext_rst != null) {
extendedDataSize = 4 + field_5_ext_rst.getDataSize();
}
// Serialise the bulk of the String
// The writeString handles tricky continue stuff for us
out.writeString(field_3_string, numberOfRichTextRuns, extendedDataSize);
if (numberOfRichTextRuns > 0) {
// This will ensure that a run does not split a continue
for (int i = 0; i < numberOfRichTextRuns; i++) {
if (out.getAvailableSpace() < 4) {
out.writeContinue();
}
FormatRun r = field_4_format_runs.get(i);
r.serialize(out);
}
}
if (extendedDataSize > 0) {
field_5_ext_rst.serialize(out);
}
}
public int compareTo(UnicodeString str) {
int result = getString().compareTo(str.getString());
// As per the equals method lets do this in stages
if (result != 0) return result;
// OK string appears to be equal but now lets compare formatting runs
if ((field_4_format_runs == null) && (str.field_4_format_runs == null))
// Strings are equal, and there are no formatting runs.
return 0;
if ((field_4_format_runs == null) && (str.field_4_format_runs != null))
// Strings are equal, but one or the other has formatting runs
return 1;
if ((field_4_format_runs != null) && (str.field_4_format_runs == null))
// Strings are equal, but one or the other has formatting runs
return -1;
// Strings are equal, so now compare formatting runs.
int size = field_4_format_runs.size();
if (size != str.field_4_format_runs.size()) return size - str.field_4_format_runs.size();
for (int i = 0; i < size; i++) {
FormatRun run1 = field_4_format_runs.get(i);
FormatRun run2 = str.field_4_format_runs.get(i);
result = run1.compareTo(run2);
if (result != 0) return result;
}
// Well the format runs are equal as well!, better check the ExtRst data
if ((field_5_ext_rst == null) && (str.field_5_ext_rst == null)) return 0;
if ((field_5_ext_rst == null) && (str.field_5_ext_rst != null)) return 1;
if ((field_5_ext_rst != null) && (str.field_5_ext_rst == null)) return -1;
result = field_5_ext_rst.compareTo(str.field_5_ext_rst);
if (result != 0) return result;
// Phew!! After all of that we have finally worked out that the strings
// are identical.
return 0;
}
private boolean isRichText() {
return richText.isSet(getOptionFlags());
}
private boolean isExtendedText() {
return extBit.isSet(getOptionFlags());
}
public Object clone() {
UnicodeString str = new UnicodeString();
str.field_1_charCount = field_1_charCount;
str.field_2_optionflags = field_2_optionflags;
str.field_3_string = field_3_string;
if (field_4_format_runs != null) {
str.field_4_format_runs = new ArrayList<FormatRun>();
for (FormatRun r : field_4_format_runs) {
str.field_4_format_runs.add(new FormatRun(r._character, r._fontIndex));
}
}
if (field_5_ext_rst != null) {
str.field_5_ext_rst = field_5_ext_rst.clone();
}
return str;
}
}
/**
* The axis options record provides unit information and other various tidbits about the axis.
*
* <p>
*
* @author Andrew C. Oliver(acoliver at apache.org)
*/
public final class AxisOptionsRecord extends StandardRecord {
public static final short sid = 0x1062;
private static final BitField defaultMinimum = BitFieldFactory.getInstance(0x01);
private static final BitField defaultMaximum = BitFieldFactory.getInstance(0x02);
private static final BitField defaultMajor = BitFieldFactory.getInstance(0x04);
private static final BitField defaultMinorUnit = BitFieldFactory.getInstance(0x08);
private static final BitField isDate = BitFieldFactory.getInstance(0x10);
private static final BitField defaultBase = BitFieldFactory.getInstance(0x20);
private static final BitField defaultCross = BitFieldFactory.getInstance(0x40);
private static final BitField defaultDateSettings = BitFieldFactory.getInstance(0x80);
private short field_1_minimumCategory;
private short field_2_maximumCategory;
private short field_3_majorUnitValue;
private short field_4_majorUnit;
private short field_5_minorUnitValue;
private short field_6_minorUnit;
private short field_7_baseUnit;
private short field_8_crossingPoint;
private short field_9_options;
public AxisOptionsRecord() {}
public AxisOptionsRecord(RecordInputStream in) {
field_1_minimumCategory = in.readShort();
field_2_maximumCategory = in.readShort();
field_3_majorUnitValue = in.readShort();
field_4_majorUnit = in.readShort();
field_5_minorUnitValue = in.readShort();
field_6_minorUnit = in.readShort();
field_7_baseUnit = in.readShort();
field_8_crossingPoint = in.readShort();
field_9_options = in.readShort();
}
public String toString() {
StringBuffer buffer = new StringBuffer();
buffer.append("[AXCEXT]\n");
buffer
.append(" .minimumCategory = ")
.append("0x")
.append(HexDump.toHex(getMinimumCategory()))
.append(" (")
.append(getMinimumCategory())
.append(" )");
buffer.append(System.getProperty("line.separator"));
buffer
.append(" .maximumCategory = ")
.append("0x")
.append(HexDump.toHex(getMaximumCategory()))
.append(" (")
.append(getMaximumCategory())
.append(" )");
buffer.append(System.getProperty("line.separator"));
buffer
.append(" .majorUnitValue = ")
.append("0x")
.append(HexDump.toHex(getMajorUnitValue()))
.append(" (")
.append(getMajorUnitValue())
.append(" )");
buffer.append(System.getProperty("line.separator"));
buffer
.append(" .majorUnit = ")
.append("0x")
.append(HexDump.toHex(getMajorUnit()))
.append(" (")
.append(getMajorUnit())
.append(" )");
buffer.append(System.getProperty("line.separator"));
buffer
.append(" .minorUnitValue = ")
.append("0x")
.append(HexDump.toHex(getMinorUnitValue()))
.append(" (")
.append(getMinorUnitValue())
.append(" )");
buffer.append(System.getProperty("line.separator"));
buffer
.append(" .minorUnit = ")
.append("0x")
.append(HexDump.toHex(getMinorUnit()))
.append(" (")
.append(getMinorUnit())
.append(" )");
buffer.append(System.getProperty("line.separator"));
buffer
.append(" .baseUnit = ")
.append("0x")
.append(HexDump.toHex(getBaseUnit()))
.append(" (")
.append(getBaseUnit())
.append(" )");
buffer.append(System.getProperty("line.separator"));
buffer
.append(" .crossingPoint = ")
.append("0x")
.append(HexDump.toHex(getCrossingPoint()))
.append(" (")
.append(getCrossingPoint())
.append(" )");
buffer.append(System.getProperty("line.separator"));
buffer
.append(" .options = ")
.append("0x")
.append(HexDump.toHex(getOptions()))
.append(" (")
.append(getOptions())
.append(" )");
buffer.append(System.getProperty("line.separator"));
buffer.append(" .defaultMinimum = ").append(isDefaultMinimum()).append('\n');
buffer.append(" .defaultMaximum = ").append(isDefaultMaximum()).append('\n');
buffer.append(" .defaultMajor = ").append(isDefaultMajor()).append('\n');
buffer
.append(" .defaultMinorUnit = ")
.append(isDefaultMinorUnit())
.append('\n');
buffer.append(" .isDate = ").append(isIsDate()).append('\n');
buffer.append(" .defaultBase = ").append(isDefaultBase()).append('\n');
buffer.append(" .defaultCross = ").append(isDefaultCross()).append('\n');
buffer
.append(" .defaultDateSettings = ")
.append(isDefaultDateSettings())
.append('\n');
buffer.append("[/AXCEXT]\n");
return buffer.toString();
}
public void serialize(LittleEndianOutput out) {
out.writeShort(field_1_minimumCategory);
out.writeShort(field_2_maximumCategory);
out.writeShort(field_3_majorUnitValue);
out.writeShort(field_4_majorUnit);
out.writeShort(field_5_minorUnitValue);
out.writeShort(field_6_minorUnit);
out.writeShort(field_7_baseUnit);
out.writeShort(field_8_crossingPoint);
out.writeShort(field_9_options);
}
protected int getDataSize() {
return 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2;
}
public short getSid() {
return sid;
}
public Object clone() {
AxisOptionsRecord rec = new AxisOptionsRecord();
rec.field_1_minimumCategory = field_1_minimumCategory;
rec.field_2_maximumCategory = field_2_maximumCategory;
rec.field_3_majorUnitValue = field_3_majorUnitValue;
rec.field_4_majorUnit = field_4_majorUnit;
rec.field_5_minorUnitValue = field_5_minorUnitValue;
rec.field_6_minorUnit = field_6_minorUnit;
rec.field_7_baseUnit = field_7_baseUnit;
rec.field_8_crossingPoint = field_8_crossingPoint;
rec.field_9_options = field_9_options;
return rec;
}
/** Get the minimum category field for the AxisOptions record. */
public short getMinimumCategory() {
return field_1_minimumCategory;
}
/** Set the minimum category field for the AxisOptions record. */
public void setMinimumCategory(short field_1_minimumCategory) {
this.field_1_minimumCategory = field_1_minimumCategory;
}
/** Get the maximum category field for the AxisOptions record. */
public short getMaximumCategory() {
return field_2_maximumCategory;
}
/** Set the maximum category field for the AxisOptions record. */
public void setMaximumCategory(short field_2_maximumCategory) {
this.field_2_maximumCategory = field_2_maximumCategory;
}
/** Get the major unit value field for the AxisOptions record. */
public short getMajorUnitValue() {
return field_3_majorUnitValue;
}
/** Set the major unit value field for the AxisOptions record. */
public void setMajorUnitValue(short field_3_majorUnitValue) {
this.field_3_majorUnitValue = field_3_majorUnitValue;
}
/** Get the major unit field for the AxisOptions record. */
public short getMajorUnit() {
return field_4_majorUnit;
}
/** Set the major unit field for the AxisOptions record. */
public void setMajorUnit(short field_4_majorUnit) {
this.field_4_majorUnit = field_4_majorUnit;
}
/** Get the minor unit value field for the AxisOptions record. */
public short getMinorUnitValue() {
return field_5_minorUnitValue;
}
/** Set the minor unit value field for the AxisOptions record. */
public void setMinorUnitValue(short field_5_minorUnitValue) {
this.field_5_minorUnitValue = field_5_minorUnitValue;
}
/** Get the minor unit field for the AxisOptions record. */
public short getMinorUnit() {
return field_6_minorUnit;
}
/** Set the minor unit field for the AxisOptions record. */
public void setMinorUnit(short field_6_minorUnit) {
this.field_6_minorUnit = field_6_minorUnit;
}
/** Get the base unit field for the AxisOptions record. */
public short getBaseUnit() {
return field_7_baseUnit;
}
/** Set the base unit field for the AxisOptions record. */
public void setBaseUnit(short field_7_baseUnit) {
this.field_7_baseUnit = field_7_baseUnit;
}
/** Get the crossing point field for the AxisOptions record. */
public short getCrossingPoint() {
return field_8_crossingPoint;
}
/** Set the crossing point field for the AxisOptions record. */
public void setCrossingPoint(short field_8_crossingPoint) {
this.field_8_crossingPoint = field_8_crossingPoint;
}
/** Get the options field for the AxisOptions record. */
public short getOptions() {
return field_9_options;
}
/** Set the options field for the AxisOptions record. */
public void setOptions(short field_9_options) {
this.field_9_options = field_9_options;
}
/** Sets the default minimum field value. use the default minimum category */
public void setDefaultMinimum(boolean value) {
field_9_options = defaultMinimum.setShortBoolean(field_9_options, value);
}
/**
* use the default minimum category
*
* @return the default minimum field value.
*/
public boolean isDefaultMinimum() {
return defaultMinimum.isSet(field_9_options);
}
/** Sets the default maximum field value. use the default maximum category */
public void setDefaultMaximum(boolean value) {
field_9_options = defaultMaximum.setShortBoolean(field_9_options, value);
}
/**
* use the default maximum category
*
* @return the default maximum field value.
*/
public boolean isDefaultMaximum() {
return defaultMaximum.isSet(field_9_options);
}
/** Sets the default major field value. use the default major unit */
public void setDefaultMajor(boolean value) {
field_9_options = defaultMajor.setShortBoolean(field_9_options, value);
}
/**
* use the default major unit
*
* @return the default major field value.
*/
public boolean isDefaultMajor() {
return defaultMajor.isSet(field_9_options);
}
/** Sets the default minor unit field value. use the default minor unit */
public void setDefaultMinorUnit(boolean value) {
field_9_options = defaultMinorUnit.setShortBoolean(field_9_options, value);
}
/**
* use the default minor unit
*
* @return the default minor unit field value.
*/
public boolean isDefaultMinorUnit() {
return defaultMinorUnit.isSet(field_9_options);
}
/** Sets the isDate field value. this is a date axis */
public void setIsDate(boolean value) {
field_9_options = isDate.setShortBoolean(field_9_options, value);
}
/**
* this is a date axis
*
* @return the isDate field value.
*/
public boolean isIsDate() {
return isDate.isSet(field_9_options);
}
/** Sets the default base field value. use the default base unit */
public void setDefaultBase(boolean value) {
field_9_options = defaultBase.setShortBoolean(field_9_options, value);
}
/**
* use the default base unit
*
* @return the default base field value.
*/
public boolean isDefaultBase() {
return defaultBase.isSet(field_9_options);
}
/** Sets the default cross field value. use the default crossing point */
public void setDefaultCross(boolean value) {
field_9_options = defaultCross.setShortBoolean(field_9_options, value);
}
/**
* use the default crossing point
*
* @return the default cross field value.
*/
public boolean isDefaultCross() {
return defaultCross.isSet(field_9_options);
}
/** Sets the default date settings field value. use default date setttings for this axis */
public void setDefaultDateSettings(boolean value) {
field_9_options = defaultDateSettings.setShortBoolean(field_9_options, value);
}
/**
* use default date setttings for this axis
*
* @return the default date settings field value.
*/
public boolean isDefaultDateSettings() {
return defaultDateSettings.isSet(field_9_options);
}
}
/**
* Describes a chart sheet properties record. SHTPROPS (0x1044)
*
* <p>(As with all chart related records, documentation is lacking. See {@link ChartRecord} for more
* details)
*
* @author Glen Stampoultzis (glens at apache.org)
*/
public final class SheetPropertiesRecord extends StandardRecord {
public static final short sid = 0x1044;
private static final BitField chartTypeManuallyFormatted = BitFieldFactory.getInstance(0x01);
private static final BitField plotVisibleOnly = BitFieldFactory.getInstance(0x02);
private static final BitField doNotSizeWithWindow = BitFieldFactory.getInstance(0x04);
private static final BitField defaultPlotDimensions = BitFieldFactory.getInstance(0x08);
private static final BitField autoPlotArea = BitFieldFactory.getInstance(0x10);
private int field_1_flags;
private int field_2_empty;
public static final byte EMPTY_NOT_PLOTTED = 0;
public static final byte EMPTY_ZERO = 1;
public static final byte EMPTY_INTERPOLATED = 2;
public SheetPropertiesRecord() {
// fields uninitialised
}
public SheetPropertiesRecord(RecordInputStream in) {
field_1_flags = in.readUShort();
field_2_empty = in.readUShort();
}
public String toString() {
StringBuffer buffer = new StringBuffer();
buffer.append("[SHTPROPS]\n");
buffer
.append(" .flags = ")
.append(HexDump.shortToHex(field_1_flags))
.append('\n');
buffer
.append(" .chartTypeManuallyFormatted= ")
.append(isChartTypeManuallyFormatted())
.append('\n');
buffer
.append(" .plotVisibleOnly = ")
.append(isPlotVisibleOnly())
.append('\n');
buffer
.append(" .doNotSizeWithWindow = ")
.append(isDoNotSizeWithWindow())
.append('\n');
buffer
.append(" .defaultPlotDimensions = ")
.append(isDefaultPlotDimensions())
.append('\n');
buffer.append(" .autoPlotArea = ").append(isAutoPlotArea()).append('\n');
buffer
.append(" .empty = ")
.append(HexDump.shortToHex(field_2_empty))
.append('\n');
buffer.append("[/SHTPROPS]\n");
return buffer.toString();
}
public void serialize(LittleEndianOutput out) {
out.writeShort(field_1_flags);
out.writeShort(field_2_empty);
}
protected int getDataSize() {
return 2 + 2;
}
public short getSid() {
return sid;
}
public Object clone() {
SheetPropertiesRecord rec = new SheetPropertiesRecord();
rec.field_1_flags = field_1_flags;
rec.field_2_empty = field_2_empty;
return rec;
}
/** Get the flags field for the SheetProperties record. */
public int getFlags() {
return field_1_flags;
}
/**
* Get the empty field for the SheetProperties record.
*
* @return One of EMPTY_NOT_PLOTTED EMPTY_ZERO EMPTY_INTERPOLATED
*/
public int getEmpty() {
return field_2_empty;
}
/**
* Set the empty field for the SheetProperties record.
*
* @param empty One of EMPTY_NOT_PLOTTED EMPTY_ZERO EMPTY_INTERPOLATED
*/
public void setEmpty(byte empty) {
this.field_2_empty = empty;
}
/**
* Sets the chart type manually formatted field value. Has the chart type been manually formatted?
*/
public void setChartTypeManuallyFormatted(boolean value) {
field_1_flags = chartTypeManuallyFormatted.setBoolean(field_1_flags, value);
}
/**
* Has the chart type been manually formatted?
*
* @return the chart type manually formatted field value.
*/
public boolean isChartTypeManuallyFormatted() {
return chartTypeManuallyFormatted.isSet(field_1_flags);
}
/** Sets the plot visible only field value. Only show visible cells on the chart. */
public void setPlotVisibleOnly(boolean value) {
field_1_flags = plotVisibleOnly.setBoolean(field_1_flags, value);
}
/**
* Only show visible cells on the chart.
*
* @return the plot visible only field value.
*/
public boolean isPlotVisibleOnly() {
return plotVisibleOnly.isSet(field_1_flags);
}
/**
* Sets the do not size with window field value. Do not size the chart when the window changes
* size
*/
public void setDoNotSizeWithWindow(boolean value) {
field_1_flags = doNotSizeWithWindow.setBoolean(field_1_flags, value);
}
/**
* Do not size the chart when the window changes size
*
* @return the do not size with window field value.
*/
public boolean isDoNotSizeWithWindow() {
return doNotSizeWithWindow.isSet(field_1_flags);
}
/**
* Sets the default plot dimensions field value. Indicates that the default area dimensions should
* be used.
*/
public void setDefaultPlotDimensions(boolean value) {
field_1_flags = defaultPlotDimensions.setBoolean(field_1_flags, value);
}
/**
* Indicates that the default area dimensions should be used.
*
* @return the default plot dimensions field value.
*/
public boolean isDefaultPlotDimensions() {
return defaultPlotDimensions.isSet(field_1_flags);
}
/** Sets the auto plot area field value. ?? */
public void setAutoPlotArea(boolean value) {
field_1_flags = autoPlotArea.setBoolean(field_1_flags, value);
}
/**
* ??
*
* @return the auto plot area field value.
*/
public boolean isAutoPlotArea() {
return autoPlotArea.isSet(field_1_flags);
}
}
