<action dev="POI-DEVELOPERS" type="add">Created a common interface for handling Excel files, irrespective of if they are .xls or .xlsx</action>
</release>
<release version="3.0.3-beta1" date="2008-04-??">
+ <action dev="POI-DEVELOPERS" type="add">30311 - Conditional Formatting - improved API, added HSSFSheetConditionalFormatting</action>
+ <action dev="POI-DEVELOPERS" type="fix">Update the formula parser code to use a HSSFWorkbook, rather than the low level model.Workbook, to make things cleaner and make supporting XSSF formulas in future much easier</action>
<action dev="POI-DEVELOPERS" type="fix">Fix the logger used by POIFSFileSystem, so that commons-logging isn't required when not used</action>
<action dev="POI-DEVELOPERS" type="add">Update HSLFSlideShow and HSSFWorkbook to take advantage of POIFS updates, and allow reading embeded documents</action>
<action dev="POI-DEVELOPERS" type="add">Improve how POIFS works with directory entries, and update HWPFDocument to support reading an embeded word document</action>
<action dev="POI-DEVELOPERS" type="add">Created a common interface for handling Excel files, irrespective of if they are .xls or .xlsx</action>
</release>
<release version="3.0.3-beta1" date="2008-04-??">
+ <action dev="POI-DEVELOPERS" type="add">30311 - Conditional Formatting - improved API, added HSSFSheetConditionalFormatting</action>
+ <action dev="POI-DEVELOPERS" type="fix">Update the formula parser code to use a HSSFWorkbook, rather than the low level model.Workbook, to make things cleaner and make supporting XSSF formulas in future much easier</action>
<action dev="POI-DEVELOPERS" type="fix">Fix the logger used by POIFSFileSystem, so that commons-logging isn't required when not used</action>
<action dev="POI-DEVELOPERS" type="add">Update HSLFSlideShow and HSSFWorkbook to take advantage of POIFS updates, and allow reading embeded documents</action>
<action dev="POI-DEVELOPERS" type="add">Improve how POIFS works with directory entries, and update HWPFDocument to support reading an embeded word document</action>
import org.apache.poi.poifs.filesystem.POIFSFileSystem;
import org.apache.poi.hssf.record.*;
import org.apache.poi.hssf.record.formula.*;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.model.*;
/**
StringBuffer buf = new StringBuffer();
if (token instanceof ExpPtg) return;
- buf.append(name=((OperationPtg) token).toFormulaString((Workbook)null));
+ buf.append(name=((OperationPtg) token).toFormulaString((HSSFWorkbook)null));
buf.append(sep);
switch (token.getPtgClass()) {
case Ptg.CLASS_REF :
StringBuffer buf = new StringBuffer();
for (int i=0;i<numptgs;i++) {
token = (Ptg) tokens.get(i);
- buf.append( token.toFormulaString((Workbook)null));
+ buf.append( token.toFormulaString((HSSFWorkbook)null));
switch (token.getPtgClass()) {
case Ptg.CLASS_REF :
buf.append("(R)");
private String composeFormula(FormulaRecord record)
{
- return org.apache.poi.hssf.model.FormulaParser.toFormulaString((Workbook)null,record.getParsedExpression());
+ return org.apache.poi.hssf.model.FormulaParser.toFormulaString((HSSFWorkbook)null,record.getParsedExpression());
}
/**
import org.apache.poi.hssf.record.formula.*;
import org.apache.poi.hssf.record.formula.function.FunctionMetadata;
import org.apache.poi.hssf.record.formula.function.FunctionMetadataRegistry;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
/**
* This class parses a formula string into a List of tokens in RPN order.
*/
private char look;
- private Workbook book;
+ private HSSFWorkbook book;
/**
* model.Workbook, then use the convenience method on
* usermodel.HSSFFormulaEvaluator
*/
- public FormulaParser(String formula, Workbook book){
+ public FormulaParser(String formula, HSSFWorkbook book){
formulaString = formula;
pointer=0;
this.book = book;
formulaLength = formulaString.length();
}
- public static Ptg[] parse(String formula, Workbook book) {
+ public static Ptg[] parse(String formula, HSSFWorkbook book) {
FormulaParser fp = new FormulaParser(formula, book);
fp.parse();
return fp.getRPNPtg();
Match('!');
String sheetName = name;
String first = GetName();
- short externIdx = book.checkExternSheet(book.getSheetIndex(sheetName));
+ short externIdx = book.getExternalSheetIndex(book.getSheetIndex(sheetName));
if (look == ':') {
Match(':');
String second=GetName();
return new ReferencePtg(name);
}
- for(int i = 0; i < book.getNumNames(); i++) {
+ for(int i = 0; i < book.getNumberOfNames(); i++) {
// named range name matching is case insensitive
- if(book.getNameRecord(i).getNameText().equalsIgnoreCase(name)) {
+ if(book.getNameAt(i).getNameName().equalsIgnoreCase(name)) {
return new NamePtg(name, book);
}
}
* @param lptgs list of Ptg, can be null or empty
* @return a human readable String
*/
- public static String toFormulaString(Workbook book, List lptgs) {
+ public static String toFormulaString(HSSFWorkbook book, List lptgs) {
String retval = null;
if (lptgs == null || lptgs.size() == 0) return "#NAME";
Ptg[] ptgs = new Ptg[lptgs.size()];
* @param ptgs array of Ptg, can be null or empty
* @return a human readable String
*/
- public static String toFormulaString(Workbook book, Ptg[] ptgs) {
+ public static String toFormulaString(HSSFWorkbook book, Ptg[] ptgs) {
if (ptgs == null || ptgs.length == 0) {
// TODO - what is the justification for returning "#NAME" (which is not "#NAME?", btw)
return "#NAME";
import org.apache.poi.hssf.record.cf.FontFormatting;
import org.apache.poi.hssf.record.cf.PatternFormatting;
import org.apache.poi.hssf.record.formula.Ptg;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.util.BitField;
import org.apache.poi.util.BitFieldFactory;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.StringUtil;
/**
* Conditional Formatting Rule Record.
private int field_5_options;
- private static final BitField modificationBits = bf(0x83FFFFFF); // Bits: font,align,bord,patt,prot
+ private static final BitField modificationBits = bf(0x003FFFFF); // Bits: font,align,bord,patt,prot
private static final BitField alignHor = bf(0x00000001); // 0 = Horizontal alignment modified
private static final BitField alignVer = bf(0x00000002); // 0 = Vertical alignment modified
private static final BitField alignWrap = bf(0x00000004); // 0 = Text wrapped flag modified
/**
* Creates a new comparison operation rule
*/
- public static CFRuleRecord create(Workbook workbook, String formulaText) {
+ public static CFRuleRecord create(HSSFWorkbook workbook, String formulaText) {
Ptg[] formula1 = parseFormula(formulaText, workbook);
return new CFRuleRecord(CONDITION_TYPE_FORMULA, ComparisonOperator.NO_COMPARISON,
formula1, null);
/**
* Creates a new comparison operation rule
*/
- public static CFRuleRecord create(Workbook workbook, byte comparisonOperation,
+ public static CFRuleRecord create(HSSFWorkbook workbook, byte comparisonOperation,
String formulaText1, String formulaText2) {
Ptg[] formula1 = parseFormula(formulaText1, workbook);
Ptg[] formula2 = parseFormula(formulaText2, workbook);
{
StringBuffer buffer = new StringBuffer();
buffer.append("[CFRULE]\n");
+ buffer.append(" OPTION FLAGS=0x"+Integer.toHexString(getOptions()));
+ /*
if( containsFontFormattingBlock())
{
buffer.append(fontFormatting.toString());
{
buffer.append(patternFormatting.toString());
}
- buffer.append("[/CFRULE]\n");
+ buffer.append("[/CFRULE]\n");*/
return buffer.toString();
}
/**
* @return <code>null</code> if <tt>formula</tt> was null.
*/
- private static Ptg[] parseFormula(String formula, Workbook workbook)
+ private static Ptg[] parseFormula(String formula, HSSFWorkbook workbook)
{
if(formula == null) {
return null;
package org.apache.poi.hssf.record;
+import java.util.Iterator;
import java.util.List;
import java.util.Stack;
-import java.util.Iterator;
-import org.apache.poi.hssf.model.Workbook;
-import org.apache.poi.hssf.record.formula.*;
+import org.apache.poi.hssf.record.formula.Area3DPtg;
+import org.apache.poi.hssf.record.formula.DeletedArea3DPtg;
+import org.apache.poi.hssf.record.formula.DeletedRef3DPtg;
+import org.apache.poi.hssf.record.formula.Ptg;
+import org.apache.poi.hssf.record.formula.Ref3DPtg;
+import org.apache.poi.hssf.record.formula.UnionPtg;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.util.AreaReference;
import org.apache.poi.hssf.util.RangeAddress;
import org.apache.poi.util.HexDump;
/** gets the reference , the area only (range)
* @return area reference
*/
- public String getAreaReference(Workbook book){
+ public String getAreaReference(HSSFWorkbook book){
if (field_13_name_definition == null || field_13_name_definition.isEmpty()) return "Error";
Ptg ptg = (Ptg) field_13_name_definition.peek();
String result = "";
* return an empty string if nothing is possible
* for it.
*/
- private String getAreaRefString(Ptg ptg,Workbook book) {
+ private String getAreaRefString(Ptg ptg,HSSFWorkbook book) {
if (ptg.getClass() == Area3DPtg.class){
return ptg.toFormulaString(book);
} else if (ptg.getClass() == Ref3DPtg.class){
package org.apache.poi.hssf.record.formula;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.formula.function.FunctionMetadata;
import org.apache.poi.hssf.record.formula.function.FunctionMetadataRegistry;
return field_2_fnc_index == FUNCTION_INDEX_EXTERNAL;
}
- public String toFormulaString(Workbook book) {
+ public String toFormulaString(HSSFWorkbook book) {
return getName();
}
*/
package org.apache.poi.hssf.record.formula;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.RecordInputStream;
/**
}
/** Implementation of method from Ptg */
- public String toFormulaString(Workbook book)
+ public String toFormulaString(HSSFWorkbook book)
{
return "+";
}
package org.apache.poi.hssf.record.formula;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.RecordInputStream;
import org.apache.poi.hssf.util.AreaReference;
import org.apache.poi.hssf.util.CellReference;
* @return text representation of this area reference that can be used in text
* formulas. The sheet name will get properly delimited if required.
*/
- public String toFormulaString(Workbook book)
+ public String toFormulaString(HSSFWorkbook book)
{
// First do the sheet name
StringBuffer retval = new StringBuffer();
import org.apache.poi.hssf.record.RecordInputStream;
import org.apache.poi.hssf.util.AreaReference;
import org.apache.poi.hssf.util.CellReference;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
/**
* Specifies a rectangular area of cells A1:A4 for instance.
import org.apache.poi.util.LittleEndian;
import org.apache.poi.util.BitField;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.RecordInputStream;
/**
array[offset] = (byte) (sid + ptgClass);
}
- public String toFormulaString(Workbook book)
+ public String toFormulaString(HSSFWorkbook book)
{
return "#REF!";
}
import org.apache.poi.hssf.record.RecordInputStream;
import org.apache.poi.hssf.util.AreaReference;
import org.apache.poi.hssf.util.CellReference;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
/**
* Specifies a rectangular area of cells A1:A4 for instance.
return "AreaNAPtg";
}
- public String toFormulaString(Workbook book)
+ public String toFormulaString(HSSFWorkbook book)
{
throw new RuntimeException("Coding Error: This method should never be called. This ptg should be converted");
}
import org.apache.poi.hssf.record.RecordInputStream;
import org.apache.poi.hssf.util.AreaReference;
import org.apache.poi.hssf.util.CellReference;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
/**
* Specifies a rectangular area of cells A1:A4 for instance.
return "AreaNPtg";
}
- public String toFormulaString(Workbook book)
+ public String toFormulaString(HSSFWorkbook book)
{
throw new RuntimeException("Coding Error: This method should never be called. This ptg should be converted");
}
import org.apache.poi.hssf.record.RecordInputStream;
import org.apache.poi.hssf.util.AreaReference;
import org.apache.poi.hssf.util.CellReference;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
/**
* Specifies a rectangular area of cells A1:A4 for instance.
return "AreaNVPtg";
}
- public String toFormulaString(Workbook book)
+ public String toFormulaString(HSSFWorkbook book)
{
throw new RuntimeException("Coding Error: This method should never be called. This ptg should be converted");
}
import org.apache.poi.hssf.util.AreaReference;
import org.apache.poi.hssf.util.CellReference;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.RecordInputStream;
/**
field_4_last_column = column;
}
- public String toFormulaString(Workbook book)
+ public String toFormulaString(HSSFWorkbook book)
{
return toFormulaString(this, book);
}
- protected static String toFormulaString(AreaI area, Workbook book) {
+ protected static String toFormulaString(AreaI area, HSSFWorkbook book) {
CellReference topLeft = new CellReference(area.getFirstRow(),area.getFirstColumn(),!area.isFirstRowRelative(),!area.isFirstColRelative());
CellReference botRight = new CellReference(area.getLastRow(),area.getLastColumn(),!area.isLastRowRelative(),!area.isLastColRelative());
import org.apache.poi.hssf.record.RecordInputStream;
import org.apache.poi.hssf.util.AreaReference;
import org.apache.poi.hssf.util.CellReference;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
/**
* Specifies a rectangular area of cells A1:A4 for instance.
import org.apache.poi.util.StringUtil;
import org.apache.poi.hssf.util.CellReference;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.RecordFormatException;
import org.apache.poi.hssf.record.RecordInputStream;
import org.apache.poi.hssf.record.SSTRecord;
return size;
}
- public String toFormulaString(Workbook book)
+ public String toFormulaString(HSSFWorkbook book)
{
StringBuffer b = new StringBuffer();
b.append("{");
import org.apache.poi.util.StringUtil;
import org.apache.poi.hssf.util.CellReference;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.RecordFormatException;
import org.apache.poi.hssf.record.RecordInputStream;
import org.apache.poi.hssf.record.SSTRecord;
import org.apache.poi.util.StringUtil;
import org.apache.poi.hssf.util.CellReference;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.RecordFormatException;
import org.apache.poi.hssf.record.RecordInputStream;
import org.apache.poi.hssf.record.SSTRecord;
package org.apache.poi.hssf.record.formula;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.RecordInputStream;
import org.apache.poi.util.LittleEndian;
if(space.isSet(field_1_options)) {
return operands[ 0 ];
} else if (optiIf.isSet(field_1_options)) {
- return toFormulaString((Workbook)null) + "(" + operands[ 0 ] +")";
+ return toFormulaString((HSSFWorkbook)null) + "(" + operands[ 0 ] +")";
} else if (optGoto.isSet(field_1_options)) {
- return toFormulaString((Workbook)null) + operands[0]; //goto isn't a real formula element should not show up
+ return toFormulaString((HSSFWorkbook)null) + operands[0]; //goto isn't a real formula element should not show up
} else {
- return toFormulaString((Workbook)null) + "(" + operands[ 0 ] + ")";
+ return toFormulaString((HSSFWorkbook)null) + "(" + operands[ 0 ] + ")";
}
}
return -1;
}
- public String toFormulaString(Workbook book) {
+ public String toFormulaString(HSSFWorkbook book) {
if(semiVolatile.isSet(field_1_options)) {
return "ATTR(semiVolatile)";
}
package org.apache.poi.hssf.record.formula;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.RecordInputStream;
/**
return SIZE;
}
- public String toFormulaString(Workbook book)
+ public String toFormulaString(HSSFWorkbook book)
{
return field_1_value ? "TRUE" : "FALSE";
}
package org.apache.poi.hssf.record.formula;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.RecordInputStream;
/**
return 2;
}
- public String toFormulaString(Workbook book)
+ public String toFormulaString(HSSFWorkbook book)
{
return CONCAT;
}
package org.apache.poi.hssf.record.formula;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.RecordInputStream;
/**
return 2;
}
- public String toFormulaString(Workbook book)
+ public String toFormulaString(HSSFWorkbook book)
{
return "/";
}
StringBuffer buffer = new StringBuffer();
buffer.append(operands[ 0 ]);
- buffer.append(toFormulaString((Workbook)null));
+ buffer.append(toFormulaString((HSSFWorkbook)null));
buffer.append(operands[ 1 ]);
return buffer.toString();
}
package org.apache.poi.hssf.record.formula;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.RecordInputStream;
/**
return 2;
}
- public String toFormulaString(Workbook book)
+ public String toFormulaString(HSSFWorkbook book)
{
return "=";
}
buffer.append(operands[ 0 ]);
- buffer.append(toFormulaString((Workbook)null));
+ buffer.append(toFormulaString((HSSFWorkbook)null));
buffer.append(operands[ 1 ]);
return buffer.toString();
}
package org.apache.poi.hssf.record.formula;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.RecordInputStream;
import org.apache.poi.hssf.usermodel.HSSFErrorConstants;
array[offset + 1] = (byte)field_1_error_code;
}
- public String toFormulaString(Workbook book) {
+ public String toFormulaString(HSSFWorkbook book) {
return HSSFErrorConstants.getText(field_1_error_code);
}
package org.apache.poi.hssf.record.formula;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.RecordFormatException;
import org.apache.poi.hssf.record.RecordInputStream;
return field_2_first_col;
}
- public String toFormulaString(Workbook book)
+ public String toFormulaString(HSSFWorkbook book)
{
throw new RecordFormatException("Coding Error: Expected ExpPtg to be converted from Shared to Non-Shared Formula by ValueRecordsAggregate, but it wasn't");
}
package org.apache.poi.hssf.record.formula;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.RecordInputStream;
return 2;
}
- public String toFormulaString(Workbook book)
+ public String toFormulaString(HSSFWorkbook book)
{
return ">=";
}
buffer.append(operands[ 0 ]);
- buffer.append(toFormulaString((Workbook)null));
+ buffer.append(toFormulaString((HSSFWorkbook)null));
buffer.append(operands[ 1 ]);
return buffer.toString();
import java.util.List;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.RecordInputStream;
/**
* Implementation of method from Ptg
* @param book the Sheet References
*/
- public String toFormulaString(Workbook book)
+ public String toFormulaString(HSSFWorkbook book)
{
return this.GREATERTHAN;
}
package org.apache.poi.hssf.record.formula;
import org.apache.poi.util.LittleEndian;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.RecordInputStream;
/**
return SIZE;
}
- public String toFormulaString(Workbook book) {
+ public String toFormulaString(HSSFWorkbook book) {
return String.valueOf(getValue());
}
public byte getDefaultOperandClass() {
package org.apache.poi.hssf.record.formula;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.RecordInputStream;
/**
}
/** Implementation of method from Ptg */
- public String toFormulaString(Workbook book)
+ public String toFormulaString(HSSFWorkbook book)
{
return " ";
}
package org.apache.poi.hssf.record.formula;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.RecordInputStream;
return 2;
}
- public String toFormulaString( Workbook book )
+ public String toFormulaString( HSSFWorkbook book )
{
return "<=";
}
{
StringBuffer buffer = new StringBuffer();
buffer.append( operands[0] );
- buffer.append( toFormulaString( (Workbook) null ) );
+ buffer.append( toFormulaString( (HSSFWorkbook) null ) );
buffer.append( operands[1] );
return buffer.toString();
}
import java.util.List;
//POI
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.RecordInputStream;
/**
* Implementation of method from Ptg
* @param book the Sheet References
*/
- public String toFormulaString(Workbook book)
+ public String toFormulaString(HSSFWorkbook book)
{
return this.LESSTHAN;
}
package org.apache.poi.hssf.record.formula;
import org.apache.poi.util.LittleEndian;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.RecordInputStream;
/**
return SIZE;
}
- public String toFormulaString(Workbook book)
+ public String toFormulaString(HSSFWorkbook book)
{
return ""; // TODO: Not sure how to format this. -- DN
}
package org.apache.poi.hssf.record.formula;
import org.apache.poi.util.LittleEndian;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.RecordInputStream;
/**
array[offset] = (byte) (sid + ptgClass);
}
- public String toFormulaString(Workbook book)
+ public String toFormulaString(HSSFWorkbook book)
{
return "ERR#";
}
package org.apache.poi.hssf.record.formula;
import org.apache.poi.util.LittleEndian;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.RecordInputStream;
/**
LittleEndian.putShort( array, offset + 1, (short)field_1_len_ref_subexpression );
}
- public String toFormulaString(Workbook book)
+ public String toFormulaString(HSSFWorkbook book)
{
return "";
}
package org.apache.poi.hssf.record.formula;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.RecordInputStream;
/**
}
- public String toFormulaString(Workbook book)
+ public String toFormulaString(HSSFWorkbook book)
{
return " ";
}
==================================================================== */
package org.apache.poi.hssf.record.formula;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.RecordInputStream;
/**
}
- public String toFormulaString(Workbook book)
+ public String toFormulaString(HSSFWorkbook book)
{
return "*";
}
{
StringBuffer buffer = new StringBuffer();
- buffer.append(operands[ 0 ].toFormulaString((Workbook)null));
+ buffer.append(operands[ 0 ].toFormulaString((HSSFWorkbook)null));
buffer.append("*");
- buffer.append(operands[ 1 ].toFormulaString((Workbook)null));
+ buffer.append(operands[ 1 ].toFormulaString((HSSFWorkbook)null));
return buffer.toString();
}
StringBuffer buffer = new StringBuffer();
buffer.append(operands[ 0 ]);
- buffer.append(toFormulaString((Workbook)null));
+ buffer.append(toFormulaString((HSSFWorkbook)null));
buffer.append(operands[ 1 ]);
return buffer.toString();
}
package org.apache.poi.hssf.record.formula;
import org.apache.poi.util.LittleEndian;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFName;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.NameRecord;
import org.apache.poi.hssf.record.RecordInputStream;
* in the workbook. The search for the name record is case insensitive. If it is not found,
* it gets created.
*/
- public NamePtg(String name, Workbook book) {
+ public NamePtg(String name, HSSFWorkbook book) {
field_1_label_index = (short)(1+getOrCreateNameRecord(book, name)); // convert to 1-based
}
/**
* @return zero based index of the found or newly created defined name record.
*/
- private static final int getOrCreateNameRecord(Workbook book, String name) {
- // perhaps this logic belongs in Workbook
- int countNames = book.getNumNames();
- NameRecord rec;
+ private static final int getOrCreateNameRecord(HSSFWorkbook book, String name) {
+ // perhaps this logic belongs in Workbook?
+ int countNames = book.getNumberOfNames();
for (int i = 0; i < countNames; i++) {
- rec = book.getNameRecord(i);
- if (name.equalsIgnoreCase(rec.getNameText())) {
+ if(name.equalsIgnoreCase( book.getNameName(i) )) {
return i;
}
}
- rec = new NameRecord();
- rec.setNameText(name);
- rec.setNameTextLength((byte) name.length());
- book.addName(rec);
+
+ HSSFName nameObj = book.createName();
+ nameObj.setNameName(name);
+
return countNames;
}
return SIZE;
}
- public String toFormulaString(Workbook book)
+ public String toFormulaString(HSSFWorkbook book)
{
- NameRecord rec = book.getNameRecord(field_1_label_index - 1);
- return rec.getNameText();
+ return book.getNameName(field_1_label_index - 1);
}
public byte getDefaultOperandClass() {return Ptg.CLASS_REF;}
package org.apache.poi.hssf.record.formula;
import org.apache.poi.util.LittleEndian;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.RecordInputStream;
/**
return SIZE;
}
- public String toFormulaString(Workbook book)
+ public String toFormulaString(HSSFWorkbook book)
{
// -1 to convert definedNameIndex from 1-based to zero-based
return book.resolveNameXText(field_1_ixals, field_2_ilbl-1);
package org.apache.poi.hssf.record.formula;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.RecordInputStream;
/**
return 2;
}
- public String toFormulaString( Workbook book )
+ public String toFormulaString( HSSFWorkbook book )
{
return "<>";
}
buffer.append( operands[0] );
- buffer.append( toFormulaString( (Workbook) null ) );
+ buffer.append( toFormulaString( (HSSFWorkbook) null ) );
buffer.append( operands[1] );
return buffer.toString();
package org.apache.poi.hssf.record.formula;
import org.apache.poi.util.LittleEndian;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.RecordInputStream;
/**
return SIZE;
}
- public String toFormulaString(Workbook book)
+ public String toFormulaString(HSSFWorkbook book)
{
return "" + getValue();
}
import java.util.List;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.RecordInputStream;
/**
return 1;
}
- public String toFormulaString(Workbook book)
+ public String toFormulaString(HSSFWorkbook book)
{
return "()";
}
*/
package org.apache.poi.hssf.record.formula;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.RecordInputStream;
/**
}
/** Implementation of method from Ptg */
- public String toFormulaString(Workbook book)
+ public String toFormulaString(HSSFWorkbook book)
{
return "%";
}
import java.util.List;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.RecordInputStream;
/**
return 2;
}
- public String toFormulaString(Workbook book)
+ public String toFormulaString(HSSFWorkbook book)
{
return "^";
}
buffer.append(operands[ 0 ]);
- buffer.append(toFormulaString((Workbook)null));
+ buffer.append(toFormulaString((HSSFWorkbook)null));
buffer.append(operands[ 1 ]);
return buffer.toString();
}
import java.util.ArrayList;
import java.util.Stack;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.RecordInputStream;
/**
/**
* return a string representation of this token alone
*/
- public abstract String toFormulaString(Workbook book);
+ public abstract String toFormulaString(HSSFWorkbook book);
/**
* dump a debug representation (hexdump) to a string
*/
package org.apache.poi.hssf.record.formula;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.RecordInputStream;
/**
}
/** Implementation of method from Ptg */
- public String toFormulaString(Workbook book)
+ public String toFormulaString(HSSFWorkbook book)
{
return ":";
}
package org.apache.poi.hssf.record.formula;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.RecordInputStream;
import org.apache.poi.hssf.util.CellReference;
import org.apache.poi.hssf.util.RangeAddress;
}
// TODO - find a home for this method
- // There is already a method on Workbook called getSheetName but it seems to do something different.
- static String getSheetName(Workbook book, int externSheetIndex) {
+ // There is already a method on HSSFWorkbook called getSheetName but it seems to do something different.
+ static String getSheetName(HSSFWorkbook book, int externSheetIndex) {
// TODO - there are 3 ways this method can return null. Is each valid?
if (book == null) {
return null;
* @return text representation of this cell reference that can be used in text
* formulas. The sheet name will get properly delimited if required.
*/
- public String toFormulaString(Workbook book)
+ public String toFormulaString(HSSFWorkbook book)
{
StringBuffer retval = new StringBuffer();
String sheetName = getSheetName(book, field_1_index_extern_sheet);
import org.apache.poi.util.BitField;
import org.apache.poi.hssf.util.CellReference;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.RecordInputStream;
/**
return SIZE;
}
- public String toFormulaString(Workbook book)
+ public String toFormulaString(HSSFWorkbook book)
{
//TODO -- should we store a cellreference instance in this ptg?? but .. memory is an issue, i believe!
return "#REF!";
import org.apache.poi.hssf.record.RecordInputStream;
import org.apache.poi.hssf.util.CellReference;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
/**
* RefNAPtg
return "RefNAPtg";
}
- public String toFormulaString(Workbook book)
+ public String toFormulaString(HSSFWorkbook book)
{
throw new RuntimeException("Coding Error: This method should never be called. This ptg should be converted");
}
import org.apache.poi.hssf.record.RecordInputStream;
import org.apache.poi.hssf.util.CellReference;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
/**
* RefNPtg
return "RefNPtg";
}
- public String toFormulaString(Workbook book)
+ public String toFormulaString(HSSFWorkbook book)
{
throw new RuntimeException("Coding Error: This method should never be called. This ptg should be converted");
}
import org.apache.poi.hssf.record.RecordInputStream;
import org.apache.poi.hssf.util.CellReference;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
/**
* RefNVPtg
return "RefNVPtg";
}
- public String toFormulaString(Workbook book)
+ public String toFormulaString(HSSFWorkbook book)
{
throw new RuntimeException("Coding Error: This method should never be called. This ptg should be converted");
}
import org.apache.poi.util.BitFieldFactory;
import org.apache.poi.hssf.util.CellReference;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.RecordInputStream;
/**
return SIZE;
}
- public String toFormulaString(Workbook book)
+ public String toFormulaString(HSSFWorkbook book)
{
//TODO -- should we store a cellreference instance in this ptg?? but .. memory is an issue, i believe!
return (new CellReference(getRowAsInt(),getColumn(),!isRowRelative(),!isColRelative())).formatAsString();
package org.apache.poi.hssf.record.formula;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.util.BitField;
import org.apache.poi.util.BitFieldFactory;
import org.apache.poi.util.StringUtil;
}
}
- public String toFormulaString(Workbook book)
+ public String toFormulaString(HSSFWorkbook book)
{
return "\""+getValue()+"\"";
}
package org.apache.poi.hssf.record.formula;
import java.util.List;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.RecordInputStream;
/**
return 2;
}
- public String toFormulaString(Workbook book)
+ public String toFormulaString(HSSFWorkbook book)
{
return "-";
}
import java.util.List;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.RecordInputStream;
/**
}
/** Implementation of method from Ptg */
- public String toFormulaString(Workbook book)
+ public String toFormulaString(HSSFWorkbook book)
{
return "+";
}
import java.util.List;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.RecordInputStream;
/**
}
/** Implementation of method from Ptg */
- public String toFormulaString(Workbook book)
+ public String toFormulaString(HSSFWorkbook book)
{
return "+";
}
package org.apache.poi.hssf.record.formula;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.RecordInputStream;
/**
}
/** Implementation of method from Ptg */
- public String toFormulaString(Workbook book)
+ public String toFormulaString(HSSFWorkbook book)
{
return ",";
}
==================================================================== */
package org.apache.poi.hssf.record.formula;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.record.RecordInputStream;
/**
return size;
}
- public String toFormulaString(Workbook book)
+ public String toFormulaString(HSSFWorkbook book)
{
return "UNKNOWN";
}
package org.apache.poi.hssf.usermodel;
+import org.apache.poi.hssf.record.CFRuleRecord;
import org.apache.poi.hssf.record.cf.BorderFormatting;
/**
public final static short BORDER_SLANTED_DASH_DOT = BorderFormatting.BORDER_SLANTED_DASH_DOT;
+ private final CFRuleRecord cfRuleRecord;
private final BorderFormatting borderFormatting;
- public HSSFBorderFormatting()
+ protected HSSFBorderFormatting(CFRuleRecord cfRuleRecord)
{
- borderFormatting = new BorderFormatting();
+ this.cfRuleRecord = cfRuleRecord;
+ this.borderFormatting = cfRuleRecord.getBorderFormatting();
}
- protected HSSFBorderFormatting(BorderFormatting borderFormatting)
- {
- this.borderFormatting = borderFormatting;
- }
-
protected BorderFormatting getBorderFormattingBlock()
{
return borderFormatting;
public void setBackwardDiagonalOn(boolean on)
{
borderFormatting.setBackwardDiagonalOn(on);
+ if( on )
+ {
+ cfRuleRecord.setTopLeftBottomRightBorderModified(on);
+ }
}
public void setBorderBottom(short border)
{
borderFormatting.setBorderBottom(border);
+ if( border != 0)
+ {
+ cfRuleRecord.setBottomBorderModified(true);
+ }
}
public void setBorderDiagonal(short border)
{
borderFormatting.setBorderDiagonal(border);
+ if( border != 0)
+ {
+ cfRuleRecord.setBottomLeftTopRightBorderModified(true);
+ cfRuleRecord.setTopLeftBottomRightBorderModified(true);
+ }
}
public void setBorderLeft(short border)
{
borderFormatting.setBorderLeft(border);
+ if( border != 0)
+ {
+ cfRuleRecord.setLeftBorderModified(true);
+ }
}
public void setBorderRight(short border)
{
borderFormatting.setBorderRight(border);
+ if( border != 0)
+ {
+ cfRuleRecord.setRightBorderModified(true);
+ }
}
public void setBorderTop(short border)
{
borderFormatting.setBorderTop(border);
+ if( border != 0)
+ {
+ cfRuleRecord.setTopBorderModified(true);
+ }
}
public void setBottomBorderColor(short color)
{
borderFormatting.setBottomBorderColor(color);
+ if( color != 0)
+ {
+ cfRuleRecord.setBottomBorderModified(true);
+ }
}
public void setDiagonalBorderColor(short color)
{
borderFormatting.setDiagonalBorderColor(color);
+ if( color != 0)
+ {
+ cfRuleRecord.setBottomLeftTopRightBorderModified(true);
+ cfRuleRecord.setTopLeftBottomRightBorderModified(true);
+ }
}
public void setForwardDiagonalOn(boolean on)
{
borderFormatting.setForwardDiagonalOn(on);
+ if( on )
+ {
+ cfRuleRecord.setBottomLeftTopRightBorderModified(on);
+ }
}
public void setLeftBorderColor(short color)
{
borderFormatting.setLeftBorderColor(color);
+ if( color != 0)
+ {
+ cfRuleRecord.setLeftBorderModified(true);
+ }
}
public void setRightBorderColor(short color)
{
borderFormatting.setRightBorderColor(color);
+ if( color != 0)
+ {
+ cfRuleRecord.setRightBorderModified(true);
+ }
}
public void setTopBorderColor(short color)
{
borderFormatting.setTopBorderColor(color);
+ if( color != 0)
+ {
+ cfRuleRecord.setTopBorderModified(true);
+ }
}
}
private int cellType;
private HSSFRichTextString stringValue;
private short encoding = ENCODING_UNCHANGED;
- private Workbook book;
+ private HSSFWorkbook book;
private Sheet sheet;
private CellValueRecordInterface record;
private HSSFComment comment;
*/
//protected HSSFCell(Workbook book, Sheet sheet, short row, short col)
- protected HSSFCell(Workbook book, Sheet sheet, int row, short col)
+ protected HSSFCell(HSSFWorkbook book, Sheet sheet, int row, short col)
{
checkBounds(col);
stringValue = null;
*/
//protected HSSFCell(Workbook book, Sheet sheet, short row, short col,
- protected HSSFCell(Workbook book, Sheet sheet, int row, short col,
+ protected HSSFCell(HSSFWorkbook book, Sheet sheet, int row, short col,
int type)
{
checkBounds(col);
*/
//protected HSSFCell(Workbook book, Sheet sheet, short row,
- protected HSSFCell(Workbook book, Sheet sheet, int row,
+ protected HSSFCell(HSSFWorkbook book, Sheet sheet, int row,
CellValueRecordInterface cval)
{
record = cval;
switch (cellType)
{
case CELL_TYPE_STRING :
- stringValue = new HSSFRichTextString(book, (LabelSSTRecord ) cval);
+ stringValue = new HSSFRichTextString(book.getWorkbook(), (LabelSSTRecord ) cval);
break;
case CELL_TYPE_BLANK :
stringValue=new HSSFRichTextString(((FormulaRecordAggregate) cval).getStringValue());
break;
}
- ExtendedFormatRecord xf = book.getExFormatAt(cval.getXFIndex());
+ ExtendedFormatRecord xf = book.getWorkbook().getExFormatAt(cval.getXFIndex());
setCellStyle(new HSSFCellStyle(( short ) cval.getXFIndex(), xf, book));
}
* @return
*/
protected Workbook getBoundWorkbook() {
- return book;
+ return book.getWorkbook();
}
/**
// jmh {
// jmh str.setUncompressedUnicode();
// jmh }
- sst = book.addSSTString(str);
+ sst = book.getWorkbook().addSSTString(str);
lrec.setSSTIndex(sst);
- getRichStringCellValue().setUnicodeString(book.getSSTString(sst));
+ getRichStringCellValue().setUnicodeString(book.getWorkbook().getSSTString(sst));
}
}
record = lrec;
*/
public void setCellValue(Date value)
{
- setCellValue(HSSFDateUtil.getExcelDate(value, this.book.isUsing1904DateWindowing()));
+ setCellValue(HSSFDateUtil.getExcelDate(value, this.book.getWorkbook().isUsing1904DateWindowing()));
}
/**
*/
public void setCellValue(Calendar value)
{
- setCellValue( HSSFDateUtil.getExcelDate(value, this.book.isUsing1904DateWindowing()) );
+ setCellValue( HSSFDateUtil.getExcelDate(value, this.book.getWorkbook().isUsing1904DateWindowing()) );
}
/**
int index = 0;
UnicodeString str = hvalue.getUnicodeString();
- index = book.addSSTString(str);
+ index = book.getWorkbook().addSSTString(str);
(( LabelSSTRecord ) record).setSSTIndex(index);
stringValue = hvalue;
- stringValue.setWorkbookReferences(book, (( LabelSSTRecord ) record));
- stringValue.setUnicodeString(book.getSSTString(index));
+ stringValue.setWorkbookReferences(book.getWorkbook(), (( LabelSSTRecord ) record));
+ stringValue.setUnicodeString(book.getWorkbook().getSSTString(index));
}
public void setCellFormula(String formula) {
"You cannot get a date value from an error cell");
}
double value=this.getNumericCellValue();
- if (book.isUsing1904DateWindowing()) {
+ if (book.getWorkbook().isUsing1904DateWindowing()) {
return HSSFDateUtil.getJavaDate(value,true);
}
else {
public HSSFCellStyle getCellStyle()
{
short styleIndex=record.getXFIndex();
- ExtendedFormatRecord xf = book.getExFormatAt(styleIndex);
+ ExtendedFormatRecord xf = book.getWorkbook().getExFormatAt(styleIndex);
return new HSSFCellStyle(styleIndex, xf, book);
}
==================================================================== */
package org.apache.poi.hssf.usermodel;
-import org.apache.poi.hssf.model.Workbook;
import org.apache.poi.hssf.record.CFHeaderRecord;
import org.apache.poi.hssf.record.CFRuleRecord;
import org.apache.poi.hssf.record.aggregates.CFRecordsAggregate;
* To create a new Conditional Formatting set use the following approach:
*
* <PRE>
+ *
+ * // Define a Conditional Formatting rule, which triggers formatting
+ * // when cell's value is greater or equal than 100.0 and
+ * // applies patternFormatting defined below.
+ * HSSFConditionalFormattingRule rule = sheet.createConditionalFormattingRule(
+ * ComparisonOperator.GE,
+ * "100.0", // 1st formula
+ * null // 2nd formula is not used for comparison operator GE
+ * );
+ *
* // Create pattern with red background
- * HSSFPatternFormatting patternFormatting = new HSSFPatternFormatting();
+ * HSSFPatternFormatting patternFmt = rule.cretePatternFormatting();
* patternFormatting.setFillBackgroundColor(HSSFColor.RED.index);
*
+ * // Define a region containing first column
* Region [] regions =
* {
- * // Define a region containing first column
* new Region(1,(short)1,-1,(short)1)
* };
*
- * HSSFConditionalFormattingRule[] rules =
- * {
- * // Define a Conditional Formatting rule, which triggers formatting
- * // when cell's value is greater or equal than 100.0 and
- * // applies patternFormatting defined above.
- *
- * sheet.createConditionalFormattingRule(
- * HSSFConditionalFormattingRule.COMPARISON_OPERATOR_GE,
- * "100.0", // 1st formula
- * null, // 2nd formula is not used for comparison operator GE
- * null, // do not override Font Formatting
- * null, // do not override Border Formatting
- * patternFormatting
- * )
- * };
- *
- * // Apply Conditional Formatting rules defined above to the regions
- * sheet.addConditionalFormatting(regions, rules);
+ * // Apply Conditional Formatting rule defined above to the regions
+ * sheet.addConditionalFormatting(regions, rule);
* </PRE>
*
* @author Dmitriy Kumshayev
*/
public final class HSSFConditionalFormatting
{
- private final Workbook workbook;
+ private final HSSFWorkbook _workbook;
private final CFRecordsAggregate cfAggregate;
- HSSFConditionalFormatting(HSSFSheet sheet, CFRecordsAggregate cfAggregate)
+ HSSFConditionalFormatting(HSSFWorkbook workbook, CFRecordsAggregate cfAggregate)
{
- if(sheet == null) {
- throw new IllegalArgumentException("sheet must not be null");
+ if(workbook == null) {
+ throw new IllegalArgumentException("workbook must not be null");
}
if(cfAggregate == null) {
throw new IllegalArgumentException("cfAggregate must not be null");
}
- workbook = sheet.workbook.getWorkbook();
+ _workbook = workbook;
this.cfAggregate = cfAggregate;
}
CFRecordsAggregate getCFRecordsAggregate() {
public HSSFConditionalFormattingRule getRule(int idx)
{
CFRuleRecord ruleRecord = cfAggregate.getRule(idx);
- return new HSSFConditionalFormattingRule(workbook, ruleRecord);
+ return new HSSFConditionalFormattingRule(_workbook, ruleRecord);
}
/**
package org.apache.poi.hssf.usermodel;
import org.apache.poi.hssf.model.FormulaParser;
-import org.apache.poi.hssf.model.Workbook;
import org.apache.poi.hssf.record.CFRuleRecord;
import org.apache.poi.hssf.record.CFRuleRecord.ComparisonOperator;
import org.apache.poi.hssf.record.cf.BorderFormatting;
private static final byte CELL_COMPARISON = CFRuleRecord.CONDITION_TYPE_CELL_VALUE_IS;
private final CFRuleRecord cfRuleRecord;
- private final Workbook workbook;
+ private final HSSFWorkbook workbook;
- HSSFConditionalFormattingRule(Workbook pWorkbook, CFRuleRecord pRuleRecord) {
+ HSSFConditionalFormattingRule(HSSFWorkbook pWorkbook, CFRuleRecord pRuleRecord) {
workbook = pWorkbook;
cfRuleRecord = pRuleRecord;
}
- HSSFConditionalFormattingRule(Workbook pWorkbook, CFRuleRecord pRuleRecord,
- HSSFFontFormatting fontFmt, HSSFBorderFormatting bordFmt, HSSFPatternFormatting patternFmt) {
- this(pWorkbook, pRuleRecord);
- setFontFormatting(fontFmt);
- setBorderFormatting(bordFmt);
- setPatternFormatting(patternFmt);
- }
CFRuleRecord getCfRuleRecord()
{
return cfRuleRecord;
}
-
- /**
- * @param fontFmt pass <code>null</code> to signify 'font unchanged'
- */
- public void setFontFormatting(HSSFFontFormatting fontFmt)
+ private HSSFFontFormatting getFontFormatting(boolean create)
{
- FontFormatting block = fontFmt==null ? null : fontFmt.getFontFormattingBlock();
- cfRuleRecord.setFontFormatting(block);
+ FontFormatting fontFormatting = cfRuleRecord.getFontFormatting();
+ if ( fontFormatting != null)
+ {
+ cfRuleRecord.setFontFormatting(fontFormatting);
+ return new HSSFFontFormatting(cfRuleRecord);
+ }
+ else if( create )
+ {
+ fontFormatting = new FontFormatting();
+ cfRuleRecord.setFontFormatting(fontFormatting);
+ return new HSSFFontFormatting(cfRuleRecord);
+ }
+ else
+ {
+ return null;
+ }
}
/**
*/
public HSSFFontFormatting getFontFormatting()
{
- FontFormatting ff = cfRuleRecord.getFontFormatting();
- if ( ff == null ) {
- return null;
- }
- return new HSSFFontFormatting(ff);
+ return getFontFormatting(false);
}
-
/**
- * @param borderFmt pass <code>null</code> to signify 'border unchanged'
+ * create a new font formatting structure if it does not exist,
+ * otherwise just return existing object.
+ * @return - font formatting object, never returns <code>null</code>.
*/
- public void setBorderFormatting(HSSFBorderFormatting borderFmt)
+ public HSSFFontFormatting createFontFormatting()
+ {
+ return getFontFormatting(true);
+ }
+
+ private HSSFBorderFormatting getBorderFormatting(boolean create)
{
- BorderFormatting block = borderFmt==null ? null : borderFmt.getBorderFormattingBlock();
- cfRuleRecord.setBorderFormatting(block);
+ BorderFormatting borderFormatting = cfRuleRecord.getBorderFormatting();
+ if ( borderFormatting != null)
+ {
+ cfRuleRecord.setBorderFormatting(borderFormatting);
+ return new HSSFBorderFormatting(cfRuleRecord);
+ }
+ else if( create )
+ {
+ borderFormatting = new BorderFormatting();
+ cfRuleRecord.setBorderFormatting(borderFormatting);
+ return new HSSFBorderFormatting(cfRuleRecord);
+ }
+ else
+ {
+ return null;
+ }
}
/**
* @return - border formatting object if defined, <code>null</code> otherwise
*/
public HSSFBorderFormatting getBorderFormatting()
{
- BorderFormatting bf = cfRuleRecord.getBorderFormatting();
- if ( bf == null ) {
- return null;
- }
- return new HSSFBorderFormatting(bf);
+ return getBorderFormatting(false);
}
/**
- * @param patternFmt pass <code>null</code> to signify 'pattern unchanged'
+ * create a new border formatting structure if it does not exist,
+ * otherwise just return existing object.
+ * @return - border formatting object, never returns <code>null</code>.
*/
- public void setPatternFormatting(HSSFPatternFormatting patternFmt)
+ public HSSFBorderFormatting createBorderFormatting()
{
- PatternFormatting block = patternFmt==null ? null : patternFmt.getPatternFormattingBlock();
- cfRuleRecord.setPatternFormatting(block);
+ return getBorderFormatting(true);
}
+
+ private HSSFPatternFormatting getPatternFormatting(boolean create)
+ {
+ PatternFormatting patternFormatting = cfRuleRecord.getPatternFormatting();
+ if ( patternFormatting != null)
+ {
+ cfRuleRecord.setPatternFormatting(patternFormatting);
+ return new HSSFPatternFormatting(cfRuleRecord);
+ }
+ else if( create )
+ {
+ patternFormatting = new PatternFormatting();
+ cfRuleRecord.setPatternFormatting(patternFormatting);
+ return new HSSFPatternFormatting(cfRuleRecord);
+ }
+ else
+ {
+ return null;
+ }
+ }
+
/**
* @return - pattern formatting object if defined, <code>null</code> otherwise
*/
public HSSFPatternFormatting getPatternFormatting()
{
- PatternFormatting pf = cfRuleRecord.getPatternFormatting();
- if ( pf == null ) {
- return null;
- }
- return new HSSFPatternFormatting(pf);
+ return getPatternFormatting(false);
+ }
+ /**
+ * create a new pattern formatting structure if it does not exist,
+ * otherwise just return existing object.
+ * @return - pattern formatting object, never returns <code>null</code>.
+ */
+ public HSSFPatternFormatting createPatternFormatting()
+ {
+ return getPatternFormatting(true);
}
public String getFormula1()
package org.apache.poi.hssf.usermodel;
+import org.apache.poi.hssf.record.CFRuleRecord;
import org.apache.poi.hssf.record.cf.FontFormatting;
/**
* High level representation for Font Formatting component
public final static short SS_SUPER = FontFormatting.SS_SUPER;
/** Escapement type - Subscript */
public final static short SS_SUB = FontFormatting.SS_SUB;
-
+
/** Underline type - None */
public final static byte U_NONE = FontFormatting.U_NONE;
- /** Underline type - Single */
+ /** Underline type - Single */
public final static byte U_SINGLE = FontFormatting.U_SINGLE;
- /** Underline type - Double */
+ /** Underline type - Double */
public final static byte U_DOUBLE = FontFormatting.U_DOUBLE;
/** Underline type - Single Accounting */
public final static byte U_SINGLE_ACCOUNTING = FontFormatting.U_SINGLE_ACCOUNTING;
- /** Underline type - Double Accounting */
+ /** Underline type - Double Accounting */
public final static byte U_DOUBLE_ACCOUNTING = FontFormatting.U_DOUBLE_ACCOUNTING;
-
+
private final FontFormatting fontFormatting;
- public HSSFFontFormatting()
- {
- fontFormatting = new FontFormatting();
- }
-
- protected HSSFFontFormatting(FontFormatting ff)
+ protected HSSFFontFormatting(CFRuleRecord cfRuleRecord)
{
- fontFormatting = ff;
+ this.fontFormatting = cfRuleRecord.getFontFormatting();
}
protected FontFormatting getFontFormattingBlock()
import org.apache.poi.hssf.model.FormulaParser;
import org.apache.poi.hssf.record.formula.OperationPtg;
import org.apache.poi.hssf.record.formula.Ptg;
-import org.apache.poi.ss.usermodel.Cell;
-import org.apache.poi.ss.usermodel.CreationHelper;
import org.apache.poi.ss.usermodel.FormulaEvaluator;
-import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
-import org.apache.poi.ss.usermodel.FormulaEvaluator.CellValue;
/**
* @author Amol S. Deshmukh < amolweb at ya hoo dot com >
* formula evaluated.
*/
public static FormulaParser getUnderlyingParser(HSSFWorkbook workbook, String formula) {
- return new FormulaParser(formula, workbook.getWorkbook());
+ return new FormulaParser(formula, workbook);
}
*/
void inspectPtgs(String formula) {
HSSFWorkbook hssfWb = (HSSFWorkbook)workbook;
- FormulaParser fp = new FormulaParser(formula, hssfWb.getWorkbook());
+ FormulaParser fp = new FormulaParser(formula, hssfWb);
fp.parse();
Ptg[] ptgs = fp.getRPNPtg();
System.out.println("<ptg-group>");
*/
public class HSSFName implements Name {
- private Workbook book;
+ private HSSFWorkbook book;
private NameRecord name;
/** Creates new HSSFName - called by HSSFWorkbook to create a sheet from
* @param book lowlevel Workbook object associated with the sheet.
*/
- protected HSSFName(Workbook book, NameRecord name) {
+ protected HSSFName(HSSFWorkbook book, NameRecord name) {
this.book = book;
this.name = name;
}
String result ;
short indexToExternSheet = name.getExternSheetNumber();
- result = book.findSheetNameFromExternSheet(indexToExternSheet);
+ result = book.getWorkbook().findSheetNameFromExternSheet(indexToExternSheet);
return result;
}
public void setNameName(String nameName){
name.setNameText(nameName);
name.setNameTextLength((byte)nameName.length());
+ Workbook wb = book.getWorkbook();
//Check to ensure no other names have the same case-insensitive name
- for ( int i = book.getNumNames()-1; i >=0; i-- )
+ for ( int i = wb.getNumNames()-1; i >=0; i-- )
{
- NameRecord rec = book.getNameRecord(i);
+ NameRecord rec = wb.getNameRecord(i);
if (rec != name) {
if (rec.getNameText().equalsIgnoreCase(getNameName()))
throw new IllegalArgumentException("The workbook already contains this name (case-insensitive)");
private void setSheetName(String sheetName){
int sheetNumber = book.getSheetIndex(sheetName);
- short externSheetNumber = book.checkExternSheet(sheetNumber);
+ short externSheetNumber = book.getExternalSheetIndex(sheetNumber);
name.setExternSheetNumber(externSheetNumber);
// name.setIndexToSheet(externSheetNumber);
package org.apache.poi.hssf.usermodel;
+import org.apache.poi.hssf.record.CFRuleRecord;
import org.apache.poi.hssf.record.cf.PatternFormatting;
/**
/** Least Dots */
public final static short LEAST_DOTS = PatternFormatting.LEAST_DOTS;
- private PatternFormatting patternFormatting;
+ private final CFRuleRecord cfRuleRecord;
+ private final PatternFormatting patternFormatting;
- public HSSFPatternFormatting()
+ protected HSSFPatternFormatting(CFRuleRecord cfRuleRecord)
{
- patternFormatting = new PatternFormatting();
- }
- protected HSSFPatternFormatting(PatternFormatting patternFormatting)
- {
- this.patternFormatting = patternFormatting;
+ this.cfRuleRecord = cfRuleRecord;
+ this.patternFormatting = cfRuleRecord.getPatternFormatting();
}
protected PatternFormatting getPatternFormattingBlock()
public void setFillBackgroundColor(short bg)
{
patternFormatting.setFillBackgroundColor(bg);
+ if( bg != 0)
+ {
+ cfRuleRecord.setPatternBackgroundColorModified(true);
+ }
}
/**
public void setFillForegroundColor(short fg)
{
patternFormatting.setFillForegroundColor(fg);
+ if( fg != 0)
+ {
+ cfRuleRecord.setPatternColorModified(true);
+ }
}
/**
public void setFillPattern(short fp)
{
patternFormatting.setFillPattern(fp);
+ if( fp != 0)
+ {
+ cfRuleRecord.setPatternStyleModified(true);
+ }
}
}
* reference to containing low level Workbook
*/
- private Workbook book;
+ private HSSFWorkbook book;
/**
* reference to containing Sheet
*/
//protected HSSFRow(Workbook book, Sheet sheet, short rowNum)
- protected HSSFRow(Workbook book, Sheet sheet, int rowNum)
+ protected HSSFRow(HSSFWorkbook book, Sheet sheet, int rowNum)
{
this.rowNum = rowNum;
this.book = book;
* @see org.apache.poi.hssf.usermodel.HSSFSheet#createRow(int)
*/
- protected HSSFRow(Workbook book, Sheet sheet, RowRecord record)
+ protected HSSFRow(HSSFWorkbook book, Sheet sheet, RowRecord record)
{
this.book = book;
this.sheet = sheet;
import org.apache.poi.hssf.record.VCenterRecord;
import org.apache.poi.hssf.record.WSBoolRecord;
import org.apache.poi.hssf.record.WindowTwoRecord;
-import org.apache.poi.hssf.record.aggregates.CFRecordsAggregate;
import org.apache.poi.hssf.record.formula.Ptg;
import org.apache.poi.hssf.record.formula.ReferencePtg;
import org.apache.poi.hssf.util.HSSFCellRangeAddress;
*/
public HSSFRow createRow(int rownum)
{
- HSSFRow row = new HSSFRow(book, sheet, rownum);
+ HSSFRow row = new HSSFRow(workbook, sheet, rownum);
addRow(row, true);
return row;
private HSSFRow createRowFromRecord(RowRecord row)
{
- HSSFRow hrow = new HSSFRow(book, sheet, row);
+ HSSFRow hrow = new HSSFRow(workbook, sheet, row);
addRow(hrow, false);
return hrow;
//formula fields ( size and data )
String str_formula = obj_validation.getFirstFormula();
- FormulaParser fp = new FormulaParser(str_formula, book);
+ FormulaParser fp = new FormulaParser(str_formula, workbook);
fp.parse();
Stack ptg_arr = new Stack();
Ptg[] ptg = fp.getRPNPtg();
if ( obj_validation.getSecondFormula() != null )
{
str_formula = obj_validation.getSecondFormula();
- fp = new FormulaParser(str_formula, book);
+ fp = new FormulaParser(str_formula, workbook);
fp.parse();
ptg_arr = new Stack();
ptg = fp.getRPNPtg();
// Since it's a formula cell, process the
// formula string, and look to see if
// it contains any references
- FormulaParser fp = new FormulaParser(c.getCellFormula(), workbook.getWorkbook());
+ FormulaParser fp = new FormulaParser(c.getCellFormula(), workbook);
fp.parse();
// Look for references, and update if needed
return null;
}
-
- /**
- * A factory method allowing to create a conditional formatting rule
- * with a cell comparison operator and
- * formatting rules such as font format, border format and pattern format
- *
- * @param comparisonOperation - a constant value from
- * <tt>{@link HSSFConditionalFormattingRule.ComparisonOperator}</tt>: <p>
- * <ul>
- * <li>BETWEEN</li>
- * <li>NOT_BETWEEN</li>
- * <li>EQUAL</li>
- * <li>NOT_EQUAL</li>
- * <li>GT</li>
- * <li>LT</li>
- * <li>GE</li>
- * <li>LE</li>
- * </ul>
- * </p>
- * @param formula1 - formula for the valued, compared with the cell
- * @param formula2 - second formula (only used with
- * {@link HSSFConditionalFormattingRule#COMPARISON_OPERATOR_BETWEEN}) and
- * {@link HSSFConditionalFormattingRule#COMPARISON_OPERATOR_NOT_BETWEEN} operations)
- * @param fontFmt - font formatting rules (may be <code>null</code>)
- * @param bordFmt - border formatting rules (may be <code>null</code>)
- * @param patternFmt - pattern formatting rules (may be <code>null</code>)
- */
- public HSSFConditionalFormattingRule createConditionalFormattingRule(
- byte comparisonOperation,
- String formula1,
- String formula2,
- HSSFFontFormatting fontFmt,
- HSSFBorderFormatting bordFmt,
- HSSFPatternFormatting patternFmt) {
-
- Workbook wb = workbook.getWorkbook();
- CFRuleRecord rr = CFRuleRecord.create(wb, comparisonOperation, formula1, formula2);
- return new HSSFConditionalFormattingRule(wb, rr, fontFmt, bordFmt, patternFmt);
- }
-
- /**
- * A factory method allowing to create a conditional formatting rule with a formula
- * and formatting rules such as font format, border format and pattern format. <br>
- *
- * The formatting rules are applied by Excel when the value of the formula not equal to 0.
- *
- * @param formula - formula for the valued, compared with the cell
- * @param fontFmt - font formatting rules (may be <code>null</code>)
- * @param bordFmt - border formatting rules (may be <code>null</code>)
- * @param patternFmt - pattern formatting rules (may be <code>null</code>)
- */
- public HSSFConditionalFormattingRule createConditionalFormattingRule(
- String formula,
- HSSFFontFormatting fontFmt,
- HSSFBorderFormatting bordFmt,
- HSSFPatternFormatting patternFmt) {
- Workbook wb = workbook.getWorkbook();
- CFRuleRecord rr = CFRuleRecord.create(wb, formula);
- return new HSSFConditionalFormattingRule(wb, rr, fontFmt, bordFmt, patternFmt);
- }
-
- /**
- * Adds a copy of HSSFConditionalFormatting object to the sheet
- * <p>This method could be used to copy HSSFConditionalFormatting object
- * from one sheet to another. For example:
- * <pre>
- * HSSFConditionalFormatting cf = sheet.getConditionalFormattingAt(index);
- * newSheet.addConditionalFormatting(cf);
- * </pre>
- *
- * @param cf HSSFConditionalFormatting object
- * @return index of the new Conditional Formatting object
- */
- public int addConditionalFormatting( HSSFConditionalFormatting cf ) {
- CFRecordsAggregate cfraClone = cf.getCFRecordsAggregate().cloneCFAggregate();
-
- return sheet.addConditionalFormatting(cfraClone);
- }
-
- /**
- * Allows to add a new Conditional Formatting set to the sheet.
- *
- * @param regions - list of rectangular regions to apply conditional formatting rules
- * @param hcfRules - set of up to three conditional formatting rules
- *
- * @return index of the newly created Conditional Formatting object
- */
-
- public int addConditionalFormatting(Region [] regions, HSSFConditionalFormattingRule [] hcfRules) {
- if (regions == null) {
- throw new IllegalArgumentException("regions must not be null");
- }
- if (hcfRules == null) {
- throw new IllegalArgumentException("hcfRules must not be null");
- }
-
- CFRuleRecord[] rules = new CFRuleRecord[hcfRules.length];
- for (int i = 0; i != hcfRules.length; i++) {
- rules[i] = hcfRules[i].getCfRuleRecord();
- }
- CFRecordsAggregate cfra = new CFRecordsAggregate(regions, rules);
- return sheet.addConditionalFormatting(cfra);
- }
-
- /**
- * gets Conditional Formatting object at a particular index
- *
- * @param index
- * of the Conditional Formatting object to fetch
- * @return Conditional Formatting object
- */
- public HSSFConditionalFormatting getConditionalFormattingAt(int index) {
- CFRecordsAggregate cf = sheet.getCFRecordsAggregateAt(index);
- if (cf == null) {
- return null;
- }
- return new HSSFConditionalFormatting(this,cf);
- }
-
- /**
- * @return number of Conditional Formatting objects of the sheet
- */
- public int getNumConditionalFormattings() {
- return sheet.getNumConditionalFormattings();
- }
-
- /**
- * removes a Conditional Formatting object by index
- * @param index of a Conditional Formatting object to remove
- */
- public void removeConditionalFormatting(int index) {
- sheet.removeConditionalFormatting(index);
+ public HSSFSheetConditionalFormatting getSheetConditionalFormatting() {
+ return new HSSFSheetConditionalFormatting(workbook, sheet);
}
}
--- /dev/null
+/* ====================================================================\r
+ Licensed to the Apache Software Foundation (ASF) under one or more\r
+ contributor license agreements. See the NOTICE file distributed with\r
+ this work for additional information regarding copyright ownership.\r
+ The ASF licenses this file to You under the Apache License, Version 2.0\r
+ (the "License"); you may not use this file except in compliance with\r
+ the License. You may obtain a copy of the License at\r
+\r
+ http://www.apache.org/licenses/LICENSE-2.0\r
+\r
+ Unless required by applicable law or agreed to in writing, software\r
+ distributed under the License is distributed on an "AS IS" BASIS,\r
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ See the License for the specific language governing permissions and\r
+ limitations under the License.\r
+==================================================================== */\r
+\r
+package org.apache.poi.hssf.usermodel;\r
+\r
+import org.apache.poi.hssf.model.Sheet;\r
+import org.apache.poi.hssf.record.CFRuleRecord;\r
+import org.apache.poi.hssf.record.aggregates.CFRecordsAggregate;\r
+import org.apache.poi.ss.util.Region;\r
+\r
+/**\r
+ * The 'Conditional Formatting' facet of <tt>HSSFSheet</tt>\r
+ * \r
+ * @author Dmitriy Kumshayev\r
+ */\r
+public final class HSSFSheetConditionalFormatting {\r
+ \r
+ private final HSSFWorkbook _workbook;\r
+ private final Sheet _sheet;\r
+\r
+ /* package */ HSSFSheetConditionalFormatting(HSSFWorkbook workbook, Sheet sheet) {\r
+ _workbook = workbook;\r
+ _sheet = sheet;\r
+ }\r
+\r
+ /**\r
+ * A factory method allowing to create a conditional formatting rule\r
+ * with a cell comparison operator \r
+ *\r
+ * @param comparisonOperation - a constant value from\r
+ * <tt>{@link HSSFConditionalFormattingRule.ComparisonOperator}</tt>: <p>\r
+ * <ul>\r
+ * <li>BETWEEN</li>\r
+ * <li>NOT_BETWEEN</li>\r
+ * <li>EQUAL</li>\r
+ * <li>NOT_EQUAL</li>\r
+ * <li>GT</li>\r
+ * <li>LT</li>\r
+ * <li>GE</li>\r
+ * <li>LE</li>\r
+ * </ul>\r
+ * </p>\r
+ * @param formula1 - formula for the valued, compared with the cell\r
+ * @param formula2 - second formula (only used with\r
+ * {@link HSSFConditionalFormattingRule#COMPARISON_OPERATOR_BETWEEN}) and\r
+ * {@link HSSFConditionalFormattingRule#COMPARISON_OPERATOR_NOT_BETWEEN} operations)\r
+ */\r
+ public HSSFConditionalFormattingRule createConditionalFormattingRule(\r
+ byte comparisonOperation,\r
+ String formula1,\r
+ String formula2) {\r
+\r
+ HSSFWorkbook wb = _workbook;\r
+ CFRuleRecord rr = CFRuleRecord.create(wb, comparisonOperation, formula1, formula2);\r
+ return new HSSFConditionalFormattingRule(wb, rr);\r
+ }\r
+\r
+ /**\r
+ * A factory method allowing to create a conditional formatting rule with a formula.<br>\r
+ *\r
+ * The formatting rules are applied by Excel when the value of the formula not equal to 0.\r
+ *\r
+ * @param formula - formula for the valued, compared with the cell\r
+ */\r
+ public HSSFConditionalFormattingRule createConditionalFormattingRule(String formula) {\r
+ HSSFWorkbook wb = _workbook;\r
+ CFRuleRecord rr = CFRuleRecord.create(wb, formula);\r
+ return new HSSFConditionalFormattingRule(wb, rr);\r
+ }\r
+\r
+ /**\r
+ * Adds a copy of HSSFConditionalFormatting object to the sheet\r
+ * <p>This method could be used to copy HSSFConditionalFormatting object\r
+ * from one sheet to another. For example:\r
+ * <pre>\r
+ * HSSFConditionalFormatting cf = sheet.getConditionalFormattingAt(index);\r
+ * newSheet.addConditionalFormatting(cf);\r
+ * </pre>\r
+ *\r
+ * @param cf HSSFConditionalFormatting object\r
+ * @return index of the new Conditional Formatting object\r
+ */\r
+ public int addConditionalFormatting( HSSFConditionalFormatting cf ) {\r
+ CFRecordsAggregate cfraClone = cf.getCFRecordsAggregate().cloneCFAggregate();\r
+\r
+ return _sheet.addConditionalFormatting(cfraClone);\r
+ }\r
+\r
+ /**\r
+ * Allows to add a new Conditional Formatting set to the sheet.\r
+ *\r
+ * @param regions - list of rectangular regions to apply conditional formatting rules\r
+ * @param cfRules - set of up to three conditional formatting rules\r
+ *\r
+ * @return index of the newly created Conditional Formatting object\r
+ */\r
+\r
+ public int addConditionalFormatting(Region[] regions, HSSFConditionalFormattingRule[] cfRules) {\r
+ if (regions == null) {\r
+ throw new IllegalArgumentException("regions must not be null");\r
+ }\r
+ if (cfRules == null) {\r
+ throw new IllegalArgumentException("cfRules must not be null");\r
+ }\r
+ if (cfRules.length == 0) {\r
+ throw new IllegalArgumentException("cfRules must not be empty");\r
+ }\r
+ if (cfRules.length > 3) {\r
+ throw new IllegalArgumentException("Number of rules must not exceed 3");\r
+ }\r
+\r
+ CFRuleRecord[] rules = new CFRuleRecord[cfRules.length];\r
+ for (int i = 0; i != cfRules.length; i++) {\r
+ rules[i] = cfRules[i].getCfRuleRecord();\r
+ }\r
+ CFRecordsAggregate cfra = new CFRecordsAggregate(regions, rules);\r
+ return _sheet.addConditionalFormatting(cfra);\r
+ }\r
+\r
+ public int addConditionalFormatting(Region[] regions,\r
+ HSSFConditionalFormattingRule rule1)\r
+ {\r
+ return addConditionalFormatting(regions,\r
+ new HSSFConditionalFormattingRule[]\r
+ {\r
+ rule1\r
+ });\r
+ }\r
+\r
+ public int addConditionalFormatting(Region[] regions,\r
+ HSSFConditionalFormattingRule rule1,\r
+ HSSFConditionalFormattingRule rule2)\r
+ {\r
+ return addConditionalFormatting(regions,\r
+ new HSSFConditionalFormattingRule[]\r
+ {\r
+ rule1, rule2\r
+ });\r
+ }\r
+\r
+ public int addConditionalFormatting(Region[] regions,\r
+ HSSFConditionalFormattingRule rule1,\r
+ HSSFConditionalFormattingRule rule2,\r
+ HSSFConditionalFormattingRule rule3)\r
+ {\r
+ return addConditionalFormatting(regions,\r
+ new HSSFConditionalFormattingRule[]\r
+ {\r
+ rule1, rule2, rule3\r
+ });\r
+ }\r
+\r
+ /**\r
+ * gets Conditional Formatting object at a particular index\r
+ * \r
+ * @param index\r
+ * of the Conditional Formatting object to fetch\r
+ * @return Conditional Formatting object\r
+ */\r
+ public HSSFConditionalFormatting getConditionalFormattingAt(int index) {\r
+ CFRecordsAggregate cf = _sheet.getCFRecordsAggregateAt(index);\r
+ if (cf == null) {\r
+ return null;\r
+ }\r
+ return new HSSFConditionalFormatting(_workbook, cf);\r
+ }\r
+\r
+ /**\r
+ * @return number of Conditional Formatting objects of the sheet\r
+ */\r
+ public int getNumConditionalFormattings() {\r
+ return _sheet.getNumConditionalFormattings();\r
+ }\r
+\r
+ /**\r
+ * removes a Conditional Formatting object by index\r
+ * @param index of a Conditional Formatting object to remove\r
+ */\r
+ public void removeConditionalFormatting(int index) {\r
+ _sheet.removeConditionalFormatting(index);\r
+ }\r
+}\r
import org.apache.poi.hssf.record.formula.MemFuncPtg;
import org.apache.poi.hssf.record.formula.UnionPtg;
import org.apache.poi.hssf.util.CellReference;
+import org.apache.poi.hssf.util.SheetReferences;
import org.apache.poi.poifs.filesystem.DirectoryNode;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;
import org.apache.poi.ss.usermodel.CreationHelper;
}
for (int i = 0 ; i < workbook.getNumNames() ; ++i){
- HSSFName name = new HSSFName(workbook, workbook.getNameRecord(i));
+ HSSFName name = new HSSFName(this, workbook.getNameRecord(i));
names.add(name);
}
}
}
return -1;
}
+
+ /**
+ * Returns the external sheet index of the sheet
+ * with the given internal index, creating one
+ * if needed.
+ * Used by some of the more obscure formula and
+ * named range things.
+ */
+ public short getExternalSheetIndex(int internalSheetIndex) {
+ return workbook.checkExternSheet(internalSheetIndex);
+ }
/**
* create an HSSFSheet for this HSSFWorkbook, adds it to the sheets and returns
}
return retval;
}
+
+ public SheetReferences getSheetReferences() {
+ return workbook.getSheetReferences();
+ }
/**
* removes sheet at the given index
if (isNewRecord)
{
- HSSFName newName = new HSSFName(workbook, nameRecord);
+ HSSFName newName = new HSSFName(this, nameRecord);
names.add(newName);
}
return result;
}
+
+ /**
+ * TODO - make this less cryptic / move elsewhere
+ * @param refIndex Index to REF entry in EXTERNSHEET record in the Link Table
+ * @param definedNameIndex zero-based to DEFINEDNAME or EXTERNALNAME record
+ * @return the string representation of the defined or external name
+ */
+ public String resolveNameXText(int refIndex, int definedNameIndex) {
+ return workbook.resolveNameXText(refIndex, definedNameIndex);
+ }
+
/**
* Sets the printarea for the sheet provided
if (name == null) return null;
//adding one here because 0 indicates a global named region; doesnt make sense for print areas
- return name.getAreaReference(workbook);
+ return name.getAreaReference(this);
}
/**
public HSSFName createName(){
NameRecord nameRecord = workbook.createName();
- HSSFName newName = new HSSFName(workbook, nameRecord);
+ HSSFName newName = new HSSFName(this, nameRecord);
names.add(newName);
TextBox box2 = new TextBox();\r
TextRun tr2 = box2.getTextRun();\r
tr2.setRunType(TextHeaderAtom.BODY_TYPE);\r
+ tr2.getRichTextRuns()[0].setFontSize(32);\r
tr2.setText(\r
"Support for more PowerPoint functionality\r" +\r
"Rendering slides into java.awt.Graphics2D");\r
TextBox box4 = new TextBox();\r
TextRun tr4 = box4.getTextRun();\r
tr4.setRunType(TextHeaderAtom.BODY_TYPE);\r
+ tr4.getRichTextRuns()[0].setFontSize(32);\r
tr4.setText(\r
"Integration with Apache FOP - Formatting Objects Processor");\r
box4.setAnchor(new Rectangle(36, 290, 648, 90));\r
import org.apache.poi.ddf.*;
/**
- * Represents a autoshape in a PowerPoint drawing
+ * Represents an AutoShape.
+ * <p>
+ * AutoShapes are drawing objects with a particular shape that may be customized through smart resizing and adjustments.
+ * See {@link ShapeTypes}
+ * </p>
*
* @author Yegor Kozlov
*/
-public class AutoShape extends SimpleShape {
+public class AutoShape extends TextShape {
protected AutoShape(EscherContainerRecord escherRecord, Shape parent){
super(escherRecord, parent);
}
protected EscherContainerRecord createSpContainer(int shapeType, boolean isChild){
- EscherContainerRecord spcont = super.createSpContainer(isChild);
+ _escherContainer = super.createSpContainer(isChild);
- EscherSpRecord spRecord = spcont.getChildById(EscherSpRecord.RECORD_ID);
- short type = (short)((shapeType << 4) | 0x2);
- spRecord.setOptions(type);
+ setShapeType(shapeType);
//set default properties for an autoshape
- EscherOptRecord opt = (EscherOptRecord)getEscherChild(spcont, EscherOptRecord.RECORD_ID);
+ setEscherProperty(EscherProperties.PROTECTION__LOCKAGAINSTGROUPING, 0x40000);
+ setEscherProperty(EscherProperties.FILL__FILLCOLOR, 0x8000004);
+ setEscherProperty(EscherProperties.FILL__FILLCOLOR, 0x8000004);
+ setEscherProperty(EscherProperties.FILL__FILLBACKCOLOR, 0x8000000);
+ setEscherProperty(EscherProperties.FILL__NOFILLHITTEST, 0x100010);
+ setEscherProperty(EscherProperties.LINESTYLE__COLOR, 0x8000001);
+ setEscherProperty(EscherProperties.LINESTYLE__NOLINEDRAWDASH, 0x80008);
+ setEscherProperty(EscherProperties.SHADOWSTYLE__COLOR, 0x8000002);
- opt.addEscherProperty(new EscherSimpleProperty(EscherProperties.FILL__FILLCOLOR, 0x8000004));
- opt.addEscherProperty(new EscherSimpleProperty(EscherProperties.FILL__FILLBACKCOLOR, 0x8000000));
- opt.addEscherProperty(new EscherSimpleProperty(EscherProperties.FILL__NOFILLHITTEST, 0x100010));
- opt.addEscherProperty(new EscherSimpleProperty(EscherProperties.LINESTYLE__COLOR, 0x8000001));
- opt.addEscherProperty(new EscherSimpleProperty(EscherProperties.LINESTYLE__NOLINEDRAWDASH, 0x80008));
- opt.addEscherProperty(new EscherSimpleProperty(EscherProperties.SHADOWSTYLE__COLOR, 0x8000002));
+ return _escherContainer;
+ }
+
+ protected void setDefaultTextProperties(TextRun _txtrun){
+ setVerticalAlignment(TextBox.AnchorMiddle);
+ setHorizontalAlignment(TextBox.AlignCenter);
+ setWordWrap(TextBox.WrapNone);
+ }
- return spcont;
+ /**
+ * Gets adjust value which controls smart resizing of the auto-shape.
+ *
+ * <p>
+ * The adjustment values are given in shape coordinates:
+ * the origin is at the top-left, positive-x is to the right, positive-y is down.
+ * The region from (0,0) to (S,S) maps to the geometry box of the shape (S=21600 is a constant).
+ * </p>
+ *
+ * @param idx the adjust index in the [0, 9] range
+ * @return the adjustment value
+ */
+ public int getAdjustmentValue(int idx){
+ if(idx < 0 || idx > 9) throw new IllegalArgumentException("The index of an adjustment value must be in the [0, 9] range");
+
+ return getEscherProperty((short)(EscherProperties.GEOMETRY__ADJUSTVALUE + idx));
}
+ /**
+ * Sets adjust value which controls smart resizing of the auto-shape.
+ *
+ * <p>
+ * The adjustment values are given in shape coordinates:
+ * the origin is at the top-left, positive-x is to the right, positive-y is down.
+ * The region from (0,0) to (S,S) maps to the geometry box of the shape (S=21600 is a constant).
+ * </p>
+ *
+ * @param idx the adjust index in the [0, 9] range
+ * @param val the adjustment value
+ */
+ public void setAdjustmentValue(int idx, int val){
+ if(idx < 0 || idx > 9) throw new IllegalArgumentException("The index of an adjustment value must be in the [0, 9] range");
+
+ setEscherProperty((short)(EscherProperties.GEOMETRY__ADJUSTVALUE + idx), val);
+ }
}
}
protected EscherContainerRecord createSpContainer(boolean isChild){
- EscherContainerRecord spcont = super.createSpContainer(isChild);
+ _escherContainer = super.createSpContainer(isChild);
- EscherSpRecord spRecord = spcont.getChildById(EscherSpRecord.RECORD_ID);
+ EscherSpRecord spRecord = _escherContainer.getChildById(EscherSpRecord.RECORD_ID);
short type = (ShapeTypes.Line << 4) | 0x2;
spRecord.setOptions(type);
//set default properties for a line
- EscherOptRecord opt = (EscherOptRecord)getEscherChild(spcont, EscherOptRecord.RECORD_ID);
+ EscherOptRecord opt = (EscherOptRecord)getEscherChild(_escherContainer, EscherOptRecord.RECORD_ID);
//default line properties
setEscherProperty(opt, EscherProperties.GEOMETRY__SHAPEPATH, 4);
setEscherProperty(opt, EscherProperties.LINESTYLE__NOLINEDRAWDASH, 0xA0008);
setEscherProperty(opt, EscherProperties.SHADOWSTYLE__COLOR, 0x8000002);
- return spcont;
+ return _escherContainer;
}
}
--- /dev/null
+/* ====================================================================\r
+ Licensed to the Apache Software Foundation (ASF) under one or more\r
+ contributor license agreements. See the NOTICE file distributed with\r
+ this work for additional information regarding copyright ownership.\r
+ The ASF licenses this file to You under the Apache License, Version 2.0\r
+ (the "License"); you may not use this file except in compliance with\r
+ the License. You may obtain a copy of the License at\r
+\r
+ http://www.apache.org/licenses/LICENSE-2.0\r
+\r
+ Unless required by applicable law or agreed to in writing, software\r
+ distributed under the License is distributed on an "AS IS" BASIS,\r
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ See the License for the specific language governing permissions and\r
+ limitations under the License.\r
+==================================================================== */\r
+\r
+package org.apache.poi.hslf.model;\r
+\r
+import org.apache.poi.hslf.record.FontEntityAtom;\r
+\r
+/**\r
+ * Represents a Font used in a presenation.\r
+ * <p>\r
+ * In PowerPoint Font is a shared resource and can be shared among text object in the presentation.\r
+ * </p>\r
+ * Some commonly used fonts are predefined in static constants. \r
+ *\r
+ * @author Yegor Kozlov\r
+ */\r
+public class PPFont {\r
+ /**\r
+ * ANSI character set\r
+ */\r
+ public final static byte ANSI_CHARSET = 0;\r
+\r
+ /**\r
+ * Default character set.\r
+ */\r
+ public final static byte DEFAULT_CHARSET = 1;\r
+\r
+ /**\r
+ * Symbol character set\r
+ */\r
+ public final static byte SYMBOL_CHARSET = 2;\r
+\r
+\r
+ /**\r
+ * Constants for the pitch and family of the font.\r
+ * The two low-order bits specify the pitch of the font and can be one of the following values\r
+ */\r
+ public final static byte DEFAULT_PITCH = 0;\r
+ public final static byte FIXED_PITCH = 1;\r
+ public final static byte VARIABLE_PITCH = 2;\r
+\r
+ /**\r
+ * Don't care or don't know.\r
+ */\r
+ public final static byte FF_DONTCARE = 0;\r
+ /**\r
+ * Fonts with variable stroke width (proportional) and with serifs. Times New Roman is an example.\r
+ */\r
+ public final static byte FF_ROMAN = 16;\r
+ /**\r
+ * Fonts with variable stroke width (proportional) and without serifs. Arial is an example.\r
+ */\r
+ public final static byte FF_SWISS = 32;\r
+ /**\r
+ * Fonts designed to look like handwriting. Script and Cursive are examples.\r
+ */\r
+ public final static byte FF_SCRIPT = 64;\r
+ /**\r
+ * Fonts with constant stroke width (monospace), with or without serifs.\r
+ * Monospace fonts are usually modern. CourierNew is an example\r
+ */\r
+ public final static byte FF_MODERN = 48;\r
+ /**\r
+ * Novelty fonts. Old English is an example\r
+ */\r
+ public final static byte FF_DECORATIVE = 80;\r
+\r
+\r
+ protected int charset;\r
+ protected int type;\r
+ protected int flags;\r
+ protected int pitch;\r
+ protected String name;\r
+\r
+ /**\r
+ * Creates a new instance of PPFont\r
+ */\r
+ public PPFont(){\r
+\r
+ }\r
+\r
+ /**\r
+ * Creates a new instance of PPFont and initialize it from the supplied font atom\r
+ */\r
+ public PPFont(FontEntityAtom fontAtom){\r
+ name = fontAtom.getFontName();\r
+ charset = fontAtom.getCharSet();\r
+ type = fontAtom.getFontType();\r
+ flags = fontAtom.getFontFlags();\r
+ pitch = fontAtom.getPitchAndFamily();\r
+ }\r
+\r
+ /**\r
+ * set the name for the font (i.e. Arial)\r
+ *\r
+ * @param val String representing the name of the font to use\r
+ */\r
+ public void setFontName(String val){\r
+ name = val;\r
+ }\r
+\r
+ /**\r
+ * get the name for the font (i.e. Arial)\r
+ *\r
+ * @return String representing the name of the font to use\r
+ */\r
+ public String getFontName(){\r
+ return name;\r
+ }\r
+\r
+ /**\r
+ * set the character set\r
+ *\r
+ * @param val - characterset\r
+ */\r
+ public void setCharSet(int val){\r
+ charset = val;\r
+ }\r
+\r
+ /**\r
+ * get the character set\r
+ *\r
+ * @return charset - characterset\r
+ */\r
+ public int getCharSet(){\r
+ return charset;\r
+ }\r
+\r
+ /**\r
+ * set the font flags\r
+ * Bit 1: If set, font is subsetted\r
+ *\r
+ * @param val - the font flags\r
+ */\r
+ public void setFontFlags(int val){\r
+ flags = val;\r
+ }\r
+\r
+ /**\r
+ * get the character set\r
+ * Bit 1: If set, font is subsetted\r
+ *\r
+ * @return the font flags\r
+ */\r
+ public int getFontFlags(){\r
+ return flags;\r
+ }\r
+\r
+ /**\r
+ * set the font type\r
+ * <p>\r
+ * Bit 1: Raster Font\r
+ * Bit 2: Device Font\r
+ * Bit 3: TrueType Font\r
+ * </p>\r
+ *\r
+ * @param val - the font type\r
+ */\r
+ public void setFontType(int val){\r
+ type = val;\r
+ }\r
+\r
+ /**\r
+ * get the font type\r
+ * <p>\r
+ * Bit 1: Raster Font\r
+ * Bit 2: Device Font\r
+ * Bit 3: TrueType Font\r
+ * </p>\r
+ *\r
+ * @return the font type\r
+ */\r
+ public int getFontType(){\r
+ return type;\r
+ }\r
+\r
+ /**\r
+ * set lfPitchAndFamily\r
+ *\r
+ *\r
+ * @param val - Corresponds to the lfPitchAndFamily field of the Win32 API LOGFONT structure\r
+ */\r
+ public void setPitchAndFamily(int val){\r
+ pitch = val;\r
+ }\r
+\r
+ /**\r
+ * get lfPitchAndFamily\r
+ *\r
+ * @return corresponds to the lfPitchAndFamily field of the Win32 API LOGFONT structure\r
+ */\r
+ public int getPitchAndFamily(){\r
+ return pitch;\r
+ }\r
+\r
+ public static final PPFont ARIAL;\r
+ public static final PPFont TIMES_NEW_ROMAN ;\r
+ public static final PPFont COURIER_NEW;\r
+ public static final PPFont WINGDINGS;\r
+ static {\r
+ ARIAL = new PPFont();\r
+ ARIAL.setFontName("Arial");\r
+ ARIAL.setCharSet(ANSI_CHARSET);\r
+ ARIAL.setFontType(4);\r
+ ARIAL.setFontFlags(0);\r
+ ARIAL.setPitchAndFamily(VARIABLE_PITCH | FF_SWISS);\r
+\r
+ TIMES_NEW_ROMAN = new PPFont();\r
+ TIMES_NEW_ROMAN.setFontName("Times New Roman");\r
+ TIMES_NEW_ROMAN.setCharSet(ANSI_CHARSET);\r
+ TIMES_NEW_ROMAN.setFontType(4);\r
+ TIMES_NEW_ROMAN.setFontFlags(0);\r
+ TIMES_NEW_ROMAN.setPitchAndFamily(VARIABLE_PITCH | FF_ROMAN);\r
+\r
+ COURIER_NEW = new PPFont();\r
+ COURIER_NEW.setFontName("Courier New");\r
+ COURIER_NEW.setCharSet(ANSI_CHARSET);\r
+ COURIER_NEW.setFontType(4);\r
+ COURIER_NEW.setFontFlags(0);\r
+ COURIER_NEW.setPitchAndFamily(FIXED_PITCH | FF_MODERN);\r
+\r
+ WINGDINGS = new PPFont();\r
+ WINGDINGS.setFontName("Wingdings");\r
+ WINGDINGS.setCharSet(SYMBOL_CHARSET);\r
+ WINGDINGS.setFontType(4);\r
+ WINGDINGS.setFontFlags(0);\r
+ WINGDINGS.setPitchAndFamily(VARIABLE_PITCH | FF_DONTCARE);\r
+ }\r
+}\r
* @return the create Picture object
*/
protected EscherContainerRecord createSpContainer(int idx, boolean isChild) {
- EscherContainerRecord spContainer = super.createSpContainer(isChild);
- spContainer.setOptions((short)15);
+ _escherContainer = super.createSpContainer(isChild);
+ _escherContainer.setOptions((short)15);
- EscherSpRecord spRecord = spContainer.getChildById(EscherSpRecord.RECORD_ID);
+ EscherSpRecord spRecord = _escherContainer.getChildById(EscherSpRecord.RECORD_ID);
spRecord.setOptions((short)((ShapeTypes.PictureFrame << 4) | 0x2));
//set default properties for a picture
- EscherOptRecord opt = (EscherOptRecord)getEscherChild(spContainer, EscherOptRecord.RECORD_ID);
+ EscherOptRecord opt = (EscherOptRecord)getEscherChild(_escherContainer, EscherOptRecord.RECORD_ID);
setEscherProperty(opt, EscherProperties.PROTECTION__LOCKAGAINSTGROUPING, 8388736);
//another weird feature of powerpoint: for picture id we must add 0x4000.
setEscherProperty(opt, (short)(EscherProperties.BLIP__BLIPTODISPLAY + 0x4000), idx);
- return spContainer;
+ return _escherContainer;
}
/**
* @return the created <code>EscherContainerRecord</code> which holds shape data
*/
protected EscherContainerRecord createSpContainer(boolean isChild){
- EscherContainerRecord spcont = super.createSpContainer(isChild);
+ _escherContainer = super.createSpContainer(isChild);
- EscherSpRecord spRecord = spcont.getChildById(EscherSpRecord.RECORD_ID);
+ EscherSpRecord spRecord = _escherContainer.getChildById(EscherSpRecord.RECORD_ID);
spRecord.setFlags(EscherSpRecord.FLAG_HAVEANCHOR | EscherSpRecord.FLAG_HAVEMASTER);
EscherClientDataRecord cldata = new EscherClientDataRecord();
cldata.setOptions((short)15);
- EscherOptRecord opt = (EscherOptRecord)getEscherChild(spcont, EscherOptRecord.RECORD_ID);
+ EscherOptRecord opt = (EscherOptRecord)getEscherChild(_escherContainer, EscherOptRecord.RECORD_ID);
//Placeholders can't be grouped
setEscherProperty(opt, EscherProperties.PROTECTION__LOCKAGAINSTGROUPING, 262144);
cldata.setRemainingData(out.toByteArray());
//append placeholder container before EscherTextboxRecord
- List lst = spcont.getChildRecords();
+ List lst = _escherContainer.getChildRecords();
for (int i = 0; i < lst.size(); i++) {
EscherRecord rec = (EscherRecord)lst.get(i);
if(rec.getRecordId() == EscherTextboxRecord.RECORD_ID){
}
}
- return spcont;
+ return _escherContainer;
}
}
package org.apache.poi.hslf.model;
import org.apache.poi.ddf.*;
+import org.apache.poi.util.POILogger;
+import org.apache.poi.util.POILogFactory;
+
+import java.util.List;
/**
* Create a <code>Shape</code> object depending on its type
* @author Yegor Kozlov
*/
public class ShapeFactory {
+ // For logging
+ protected static POILogger logger = POILogFactory.getLogger(ShapeFactory.class);
/**
* Create a new shape from the data provided.
*/
public static Shape createShape(EscherContainerRecord spContainer, Shape parent){
if (spContainer.getRecordId() == EscherContainerRecord.SPGR_CONTAINER){
- return new ShapeGroup(spContainer, parent);
+ return createShapeGroup(spContainer, parent);
+ } else {
+ return createSimpeShape(spContainer, parent);
+
+ }
+ }
+
+ public static ShapeGroup createShapeGroup(EscherContainerRecord spContainer, Shape parent){
+ ShapeGroup group = null;
+ UnknownEscherRecord opt = (UnknownEscherRecord)Shape.getEscherChild((EscherContainerRecord)spContainer.getChild(0), (short)0xF122);
+ if(opt != null){
+ try {
+ EscherPropertyFactory f = new EscherPropertyFactory();
+ List props = f.createProperties( opt.getData(), 0, opt.getInstance() );
+ EscherSimpleProperty p = (EscherSimpleProperty)props.get(0);
+ if(p.getPropertyNumber() == 0x39F && p.getPropertyValue() == 1){
+ group = new ShapeGroup(spContainer, parent);
+ } else {
+ group = new ShapeGroup(spContainer, parent);
+ }
+ } catch (Exception e){
+ logger.log(POILogger.WARN, e.getMessage());
+ group = new ShapeGroup(spContainer, parent);
+ }
+ } else {
+ group = new ShapeGroup(spContainer, parent);
}
+ return group;
+ }
+
+ public static Shape createSimpeShape(EscherContainerRecord spContainer, Shape parent){
Shape shape;
EscherSpRecord spRecord = spContainer.getChildById(EscherSpRecord.RECORD_ID);
int type = spRecord.getOptions() >> 4;
switch (type){
case ShapeTypes.TextBox:
- case ShapeTypes.Rectangle:
- EscherTextboxRecord txtbox = (EscherTextboxRecord)Shape.getEscherChild(spContainer, EscherTextboxRecord.RECORD_ID);
- if (txtbox == null)
- shape = new AutoShape(spContainer, parent);
- else
- shape = new TextBox(spContainer, parent);
+ shape = new TextBox(spContainer, parent);
break;
case ShapeTypes.PictureFrame:
shape = new Picture(spContainer, parent);
shape = new Line(spContainer, parent);
break;
case ShapeTypes.NotPrimitive:
- if ((spRecord.getFlags() & EscherSpRecord.FLAG_GROUP) != 0)
- shape = new ShapeGroup(spContainer, parent);
- else
+ EscherOptRecord opt = (EscherOptRecord)Shape.getEscherChild(spContainer, EscherOptRecord.RECORD_ID);
+ EscherProperty prop = Shape.getEscherProperty(opt, EscherProperties.GEOMETRY__VERTICES);
+ if(prop != null)
+ shape = new Freeform(spContainer, parent);
+ else {
+
+ logger.log(POILogger.WARN, "Creating AutoShape for a NotPrimitive shape");
shape = new AutoShape(spContainer, parent);
+ }
break;
default:
shape = new AutoShape(spContainer, parent);
break;
}
return shape;
- }
+ }
}
import org.apache.poi.ddf.*;
import org.apache.poi.util.LittleEndian;
import org.apache.poi.util.POILogger;
+import org.apache.poi.hslf.record.EscherTextboxWrapper;
import java.util.ArrayList;
import java.util.List;
shape.setSheet(sheet);
shape.afterInsert(sheet);
- if(shape instanceof TextBox) {
- TextBox tbox = (TextBox)shape;
- getSheet().getPPDrawing().addTextboxWrapper(tbox._txtbox);
+ if (shape instanceof TextShape) {
+ TextShape tbox = (TextShape) shape;
+ EscherTextboxWrapper txWrapper = tbox.getEscherTextboxWrapper();
+ if(txWrapper != null) getSheet().getPPDrawing().addTextboxWrapper(txWrapper);
}
}
shape.setSheet(this);
shape.afterInsert(this);
- // If it's a TextBox, we need to tell the PPDrawing, as it has to
+ // If it's a TextShape, we need to tell the PPDrawing, as it has to
// track TextboxWrappers specially
- if (shape instanceof TextBox) {
- TextBox tbox = (TextBox) shape;
- ppdrawing.addTextboxWrapper(tbox._txtbox);
+ if (shape instanceof TextShape) {
+ TextShape tbox = (TextShape) shape;
+ EscherTextboxWrapper txWrapper = tbox.getEscherTextboxWrapper();
+ if(txWrapper != null) ppdrawing.addTextboxWrapper(txWrapper);
}
}
* @return the record container which holds this shape
*/
protected EscherContainerRecord createSpContainer(boolean isChild) {
- EscherContainerRecord spContainer = new EscherContainerRecord();
- spContainer.setRecordId( EscherContainerRecord.SP_CONTAINER );
- spContainer.setOptions((short)15);
+ _escherContainer = new EscherContainerRecord();
+ _escherContainer.setRecordId( EscherContainerRecord.SP_CONTAINER );
+ _escherContainer.setOptions((short)15);
EscherSpRecord sp = new EscherSpRecord();
int flags = EscherSpRecord.FLAG_HAVEANCHOR | EscherSpRecord.FLAG_HASSHAPETYPE;
if (isChild) flags |= EscherSpRecord.FLAG_CHILD;
sp.setFlags(flags);
- spContainer.addChildRecord(sp);
+ _escherContainer.addChildRecord(sp);
EscherOptRecord opt = new EscherOptRecord();
opt.setRecordId(EscherOptRecord.RECORD_ID);
- spContainer.addChildRecord(opt);
+ _escherContainer.addChildRecord(opt);
EscherRecord anchor;
if(isChild) anchor = new EscherChildAnchorRecord();
LittleEndian.putInt(header, 4, 8);
anchor.fillFields(header, 0, null);
}
- spContainer.addChildRecord(anchor);
+ _escherContainer.addChildRecord(anchor);
- return spContainer;
+ return _escherContainer;
}
/**
import org.apache.poi.ddf.*;\r
import org.apache.poi.util.LittleEndian;\r
\r
-import java.util.ArrayList;\r
+import java.util.*;\r
import java.util.List;\r
-import java.util.Iterator;\r
import java.awt.*;\r
+import java.awt.geom.Rectangle2D;\r
\r
/**\r
* Represents a table in a PowerPoint presentation\r
\r
}\r
\r
+ protected void initTable(){\r
+ Shape[] sh = getShapes();\r
+ Arrays.sort(sh, new Comparator(){\r
+ public int compare( Object o1, Object o2 ) {\r
+ Rectangle anchor1 = ((Shape)o1).getAnchor();\r
+ Rectangle anchor2 = ((Shape)o2).getAnchor();\r
+ int delta = anchor1.y - anchor2.y;\r
+ if(delta == 0) delta = anchor1.x - anchor2.y;\r
+ return delta;\r
+ }\r
+ });\r
+ int y0 = -1;\r
+ int maxrowlen = 0;\r
+ ArrayList lst = new ArrayList();\r
+ ArrayList row = null;\r
+ for (int i = 0; i < sh.length; i++) {\r
+ if(sh[i] instanceof TextShape){\r
+ Rectangle anchor = sh[i].getAnchor();\r
+ if(anchor.y != y0){\r
+ y0 = anchor.y;\r
+ if(row != null) maxrowlen = Math.max(maxrowlen, row.size());\r
+ row = new ArrayList();\r
+ lst.add(row);\r
+ }\r
+ row.add(sh[i]);\r
+ }\r
+ }\r
+ cells = new TableCell[lst.size()][maxrowlen];\r
+ for (int i = 0; i < lst.size(); i++) {\r
+ row = (ArrayList)lst.get(i);\r
+ for (int j = 0; j < row.size(); j++) {\r
+ TextShape tx = (TextShape)row.get(j);\r
+ cells[i][j] = new TableCell(tx.getSpContainer(), getParent());\r
+ cells[i][j].setSheet(tx.getSheet());\r
+ }\r
+ }\r
+ }\r
+\r
+ /**\r
+ * Assign the <code>SlideShow</code> this shape belongs to\r
+ *\r
+ * @param sheet owner of this shape\r
+ */\r
+ public void setSheet(Sheet sheet){\r
+ super.setSheet(sheet);\r
+ if(cells == null) initTable();\r
+ }\r
+\r
/**\r
* Sets the row height.\r
*\r
}\r
\r
protected EscherContainerRecord createSpContainer(boolean isChild){\r
- EscherContainerRecord spContainer = super.createSpContainer(isChild);\r
- EscherOptRecord opt = (EscherOptRecord)getEscherChild(spContainer, EscherOptRecord.RECORD_ID);\r
+ _escherContainer = super.createSpContainer(isChild);\r
+ EscherOptRecord opt = (EscherOptRecord)getEscherChild(_escherContainer, EscherOptRecord.RECORD_ID);\r
setEscherProperty(opt, EscherProperties.TEXT__TEXTID, 0);\r
setEscherProperty(opt, EscherProperties.TEXT__SIZE_TEXT_TO_FIT_SHAPE, 0x20000);\r
setEscherProperty(opt, EscherProperties.FILL__NOFILLHITTEST, 0x150001);\r
setEscherProperty(opt, EscherProperties.SHADOWSTYLE__SHADOWOBSURED, 0x20000);\r
setEscherProperty(opt, EscherProperties.PROTECTION__LOCKAGAINSTGROUPING, 0x40000);\r
\r
- return spContainer;\r
+ return _escherContainer;\r
}\r
\r
protected void anchorBorder(int type, Line line){\r
*
* @author Yegor Kozlov
*/
-public class TextBox extends SimpleShape {
-
- /**
- * How to anchor the text
- */
- public static final int AnchorTop = 0;
- public static final int AnchorMiddle = 1;
- public static final int AnchorBottom = 2;
- public static final int AnchorTopCentered = 3;
- public static final int AnchorMiddleCentered = 4;
- public static final int AnchorBottomCentered = 5;
- public static final int AnchorTopBaseline = 6;
- public static final int AnchorBottomBaseline = 7;
- public static final int AnchorTopCenteredBaseline = 8;
- public static final int AnchorBottomCenteredBaseline = 9;
-
- /**
- * How to wrap the text
- */
- public static final int WrapSquare = 0;
- public static final int WrapByPoints = 1;
- public static final int WrapNone = 2;
- public static final int WrapTopBottom = 3;
- public static final int WrapThrough = 4;
-
- /**
- * How to align the text
- */
- public static final int AlignLeft = 0;
- public static final int AlignCenter = 1;
- public static final int AlignRight = 2;
- public static final int AlignJustify = 3;
-
- /**
- * Low-level object which holds actual text and format data
- */
- protected TextRun _txtrun;
-
- /**
- * Escher container which holds text attributes such as
- * TextHeaderAtom, TextBytesAtom ot TextCharsAtom, StyleTextPropAtom etc.
- */
- protected EscherTextboxWrapper _txtbox;
-
- /**
- * Is the TextBox missing the text records which actually
- * store the text?
- */
- private boolean _missingTextRecords = false;
+public class TextBox extends TextShape {
/**
* Create a TextBox object and initialize it from the supplied Record container.
protected TextBox(EscherContainerRecord escherRecord, Shape parent){
super(escherRecord, parent);
- EscherTextboxRecord textbox = (EscherTextboxRecord)Shape.getEscherChild(_escherContainer, EscherTextboxRecord.RECORD_ID);
- _txtbox = new EscherTextboxWrapper(textbox);
}
/**
* in a table then the parent is Table.
*/
public TextBox(Shape parent){
- super(null, parent);
- _escherContainer = createSpContainer(parent instanceof ShapeGroup);
+ super(parent);
}
/**
}
/**
- * Create a new textBox and initialize internal structures
+ * Create a new TextBox and initialize its internal structures
*
* @return the created <code>EscherContainerRecord</code> which holds shape data
*/
protected EscherContainerRecord createSpContainer(boolean isChild){
- EscherContainerRecord spcont = super.createSpContainer(isChild);
-
- EscherSpRecord spRecord = spcont.getChildById(EscherSpRecord.RECORD_ID);
- short type = (ShapeTypes.TextBox << 4) | 0x2;
- spRecord.setOptions(type);
-
- //set default properties for a textbox
- EscherOptRecord opt = (EscherOptRecord)getEscherChild(spcont, EscherOptRecord.RECORD_ID);
- setEscherProperty(opt, EscherProperties.TEXT__TEXTID, 0);
-
- setEscherProperty(opt, EscherProperties.FILL__FILLCOLOR, 0x8000004);
- setEscherProperty(opt, EscherProperties.FILL__FILLBACKCOLOR, 0x8000000);
- setEscherProperty(opt, EscherProperties.FILL__NOFILLHITTEST, 0x100000);
- setEscherProperty(opt, EscherProperties.LINESTYLE__COLOR, 0x8000001);
- setEscherProperty(opt, EscherProperties.LINESTYLE__NOLINEDRAWDASH, 0x80000);
- setEscherProperty(opt, EscherProperties.SHADOWSTYLE__COLOR, 0x8000002);
-
- //create EscherTextboxWrapper
- _txtbox = new EscherTextboxWrapper();
-
- TextHeaderAtom tha = new TextHeaderAtom();
- tha.setParentRecord(_txtbox); // TextHeaderAtom is parent aware
- _txtbox.appendChildRecord(tha);
-
- TextCharsAtom tca = new TextCharsAtom();
- _txtbox.appendChildRecord(tca);
-
- StyleTextPropAtom sta = new StyleTextPropAtom(0);
- _txtbox.appendChildRecord(sta);
-
- _txtrun = new TextRun(tha,tca,sta);
- _txtrun.setText("");
- spcont.addChildRecord(_txtbox.getEscherRecord());
-
- return spcont;
- }
-
- /**
- * Returns the text contained in this text frame.
- *
- * @return the text string for this textbox.
- */
- public String getText(){
- return _txtrun == null ? null : _txtrun.getText();
- }
-
- /**
- * Sets the text contained in this text frame.
- *
- * @param text the text string used by this object.
- */
- public void setText(String text){
- _txtrun.setText(text);
- }
-
- /**
- * When a textbox is added to a sheet we need to tell upper-level
- * <code>PPDrawing</code> about it.
- *
- * @param sh the sheet we are adding to
- */
- protected void afterInsert(Sheet sh){
- PPDrawing ppdrawing = sh.getPPDrawing();
- ppdrawing.addTextboxWrapper(_txtbox);
- // Ensure the escher layer knows about the added records
- try {
- _txtbox.writeOut(null);
- } catch (IOException e){
- throw new HSLFException(e);
- }
- if(getAnchor().equals(new java.awt.Rectangle()) && !"".equals(getText())) resizeToFitText();
- }
-
- /**
- * Adjust the size of the TextBox so it encompasses the text inside it.
- */
- public void resizeToFitText(){
- try{
- FontRenderContext frc = new FontRenderContext(null, true, true);
- RichTextRun rt = _txtrun.getRichTextRuns()[0];
- int size = rt.getFontSize();
- int style = 0;
- if (rt.isBold()) style |= Font.BOLD;
- if (rt.isItalic()) style |= Font.ITALIC;
- String fntname = rt.getFontName();
- Font font = new Font(fntname, style, size);
-
- TextLayout layout = new TextLayout(getText(), font, frc);
- int width = Math.round(layout.getAdvance());
- int height = Math.round(layout.getAscent());
-
- Dimension txsize = new Dimension(width, height);
- java.awt.Rectangle anchor = getAnchor();
- anchor.setSize(txsize);
- setAnchor(anchor);
- } catch (Exception e){
- e.printStackTrace();
-
- }
- }
-
- /**
- * Returns the type of vertical alignment for the text.
- * One of the <code>Anchor*</code> constants defined in this class.
- *
- * @return the type of alignment
- */
- public int getVerticalAlignment(){
- EscherOptRecord opt = (EscherOptRecord)getEscherChild(_escherContainer, EscherOptRecord.RECORD_ID);
- EscherSimpleProperty prop = (EscherSimpleProperty)getEscherProperty(opt, EscherProperties.TEXT__ANCHORTEXT);
- int valign;
- if (prop == null){
- int type = getTextRun().getRunType();
- switch (type){
- case TextHeaderAtom.TITLE_TYPE:
- case TextHeaderAtom.CENTER_TITLE_TYPE:
- valign = TextBox.AnchorMiddle;
- break;
- default:
- valign = TextBox.AnchorTop;
- break;
- }
- } else {
- valign = prop.getPropertyValue();
- }
- return valign;
- }
-
- /**
- * Sets the type of vertical alignment for the text.
- * One of the <code>Anchor*</code> constants defined in this class.
- *
- * @param align - the type of alignment
- */
- public void setVerticalAlignment(int align){
- EscherOptRecord opt = (EscherOptRecord)getEscherChild(_escherContainer, EscherOptRecord.RECORD_ID);
- setEscherProperty(opt, EscherProperties.TEXT__ANCHORTEXT, align);
- }
-
- public void setHorizontalAlignment(int align){
- _txtrun.getRichTextRuns()[0].setAlignment(align);
- }
- public int getHorizontalAlignment(){
- return _txtrun.getRichTextRuns()[0].getAlignment();
- }
-
- /**
- * Returns the distance (in points) between the bottom of the text frame
- * and the bottom of the inscribed rectangle of the shape that contains the text.
- * Default value is 1/20 inch.
- *
- * @return the botom margin
- */
- public int getMarginBottom(){
- EscherOptRecord opt = (EscherOptRecord)getEscherChild(_escherContainer, EscherOptRecord.RECORD_ID);
- EscherSimpleProperty prop = (EscherSimpleProperty)getEscherProperty(opt, EscherProperties.TEXT__TEXTBOTTOM);
- int val = prop == null ? EMU_PER_INCH/20 : prop.getPropertyValue();
- return val/EMU_PER_POINT;
- }
-
- /**
- * Sets the botom margin.
- * @see #getMarginBottom()
- *
- * @param margin the bottom margin
- */
- public void setMarginBottom(int margin){
- EscherOptRecord opt = (EscherOptRecord)getEscherChild(_escherContainer, EscherOptRecord.RECORD_ID);
- setEscherProperty(opt, EscherProperties.TEXT__TEXTBOTTOM, margin*EMU_PER_POINT);
- }
-
- /**
- * Returns the distance (in EMUs) between the left edge of the text frame
- * and the left edge of the inscribed rectangle of the shape that contains
- * the text.
- * Default value is 1/10 inch.
- *
- * @return the left margin
- */
- public int getMarginLeft(){
- EscherOptRecord opt = (EscherOptRecord)getEscherChild(_escherContainer, EscherOptRecord.RECORD_ID);
- EscherSimpleProperty prop = (EscherSimpleProperty)getEscherProperty(opt, EscherProperties.TEXT__TEXTBOTTOM);
- int val = prop == null ? EMU_PER_INCH/10 : prop.getPropertyValue();
- return val/EMU_PER_POINT;
- }
+ _escherContainer = super.createSpContainer(isChild);
- /**
- * Sets the left margin.
- * @see #getMarginLeft()
- *
- * @param margin the left margin
- */
- public void setMarginLeft(int margin){
- EscherOptRecord opt = (EscherOptRecord)getEscherChild(_escherContainer, EscherOptRecord.RECORD_ID);
- setEscherProperty(opt, EscherProperties.TEXT__TEXTLEFT, margin*EMU_PER_POINT);
- }
+ setShapeType(ShapeTypes.TextBox);
- /**
- * Returns the distance (in EMUs) between the right edge of the
- * text frame and the right edge of the inscribed rectangle of the shape
- * that contains the text.
- * Default value is 1/10 inch.
- *
- * @return the right margin
- */
- public int getMarginRight(){
- EscherOptRecord opt = (EscherOptRecord)getEscherChild(_escherContainer, EscherOptRecord.RECORD_ID);
- EscherSimpleProperty prop = (EscherSimpleProperty)getEscherProperty(opt, EscherProperties.TEXT__TEXTRIGHT);
- int val = prop == null ? EMU_PER_INCH/10 : prop.getPropertyValue();
- return val/EMU_PER_POINT;
- }
+ //set default properties for a TextBox
+ setEscherProperty(EscherProperties.FILL__FILLCOLOR, 0x8000004);
+ setEscherProperty(EscherProperties.FILL__FILLBACKCOLOR, 0x8000000);
+ setEscherProperty(EscherProperties.FILL__NOFILLHITTEST, 0x100000);
+ setEscherProperty(EscherProperties.LINESTYLE__COLOR, 0x8000001);
+ setEscherProperty(EscherProperties.LINESTYLE__NOLINEDRAWDASH, 0x80000);
+ setEscherProperty(EscherProperties.SHADOWSTYLE__COLOR, 0x8000002);
- /**
- * Sets the right margin.
- * @see #getMarginRight()
- *
- * @param margin the right margin
- */
- public void setMarginRight(int margin){
- EscherOptRecord opt = (EscherOptRecord)getEscherChild(_escherContainer, EscherOptRecord.RECORD_ID);
- setEscherProperty(opt, EscherProperties.TEXT__TEXTRIGHT, margin*EMU_PER_POINT);
- }
+ _txtrun = createTextRun();
- /**
- * Returns the distance (in EMUs) between the top of the text frame
- * and the top of the inscribed rectangle of the shape that contains the text.
- * Default value is 1/20 inch.
- *
- * @return the top margin
- */
- public int getMarginTop(){
- EscherOptRecord opt = (EscherOptRecord)getEscherChild(_escherContainer, EscherOptRecord.RECORD_ID);
- EscherSimpleProperty prop = (EscherSimpleProperty)getEscherProperty(opt, EscherProperties.TEXT__TEXTTOP);
- int val = prop == null ? EMU_PER_INCH/20 : prop.getPropertyValue();
- return val/EMU_PER_POINT;
+ return _escherContainer;
}
- /**
- * Sets the top margin.
- * @see #getMarginTop()
- *
- * @param margin the top margin
- */
- public void setMarginTop(int margin){
- EscherOptRecord opt = (EscherOptRecord)getEscherChild(_escherContainer, EscherOptRecord.RECORD_ID);
- setEscherProperty(opt, EscherProperties.TEXT__TEXTTOP, margin*EMU_PER_POINT);
+ protected void setDefaultTextProperties(TextRun _txtrun){
+ setVerticalAlignment(TextBox.AnchorTop);
+ setEscherProperty(EscherProperties.TEXT__SIZE_TEXT_TO_FIT_SHAPE, 0x20002);
}
-
- /**
- * Returns the value indicating word wrap.
- * One of the <code>Wrap*</code> constants defined in this class.
- *
- * @return the value indicating word wrap
- */
- public int getWordWrap(){
- EscherOptRecord opt = (EscherOptRecord)getEscherChild(_escherContainer, EscherOptRecord.RECORD_ID);
- EscherSimpleProperty prop = (EscherSimpleProperty)getEscherProperty(opt, EscherProperties.TEXT__WRAPTEXT);
- return prop == null ? WrapSquare : prop.getPropertyValue();
- }
-
- /**
- * Specifies how the text should be wrapped
- *
- * @param wrap the value indicating how the text should be wrapped
- */
- public void setWordWrap(int wrap){
- EscherOptRecord opt = (EscherOptRecord)getEscherChild(_escherContainer, EscherOptRecord.RECORD_ID);
- setEscherProperty(opt, EscherProperties.TEXT__WRAPTEXT, wrap);
- }
-
- /**
- * @return id for the text.
- */
- public int getTextId(){
- EscherOptRecord opt = (EscherOptRecord)getEscherChild(_escherContainer, EscherOptRecord.RECORD_ID);
- EscherSimpleProperty prop = (EscherSimpleProperty)getEscherProperty(opt, EscherProperties.TEXT__TEXTID);
- return prop == null ? 0 : prop.getPropertyValue();
- }
-
- /**
- * Sets text ID
- *
- * @param id of the text
- */
- public void setTextId(int id){
- EscherOptRecord opt = (EscherOptRecord)getEscherChild(_escherContainer, EscherOptRecord.RECORD_ID);
- setEscherProperty(opt, EscherProperties.TEXT__TEXTID, id);
- }
-
- /**
- * The color used to fill this shape.
- *
- * @param color the background color
- */
- public void setBackgroundColor(Color color){
- EscherOptRecord opt = (EscherOptRecord)getEscherChild(_escherContainer, EscherOptRecord.RECORD_ID);
- int rgb = new Color(color.getBlue(), color.getGreen(), color.getRed(), 0).getRGB();
- setEscherProperty(opt, EscherProperties.FILL__FILLBACKCOLOR, rgb);
- }
-
- /**
- * @return the TextRun object for this text box
- */
- public TextRun getTextRun(){
- return _txtrun;
- }
-
- public void setSheet(Sheet sheet){
- _sheet = sheet;
-
- // Initialize _txtrun object.
- // (We can't do it in the constructor because the sheet
- // is not assigned then, it's only built once we have
- // all the records)
- if(_txtrun == null) initTextRun();
- if(_txtrun == null) {
- // No text records found, skip
- _missingTextRecords = true;
- return;
- } else {
- _missingTextRecords = false;
- }
-
- // Supply the sheet to our child RichTextRuns
- _txtrun.setSheet(sheet);
- RichTextRun[] rt = _txtrun.getRichTextRuns();
- for (int i = 0; i < rt.length; i++) {
- rt[i].supplySlideShow(_sheet.getSlideShow());
- }
- }
-
- private void initTextRun(){
- OutlineTextRefAtom ota = null;
-
- // Find the interesting child records
- Record[] child = _txtbox.getChildRecords();
- for (int i = 0; i < child.length; i++) {
- if (child[i] instanceof OutlineTextRefAtom) {
- ota = (OutlineTextRefAtom)child[i];
- break;
- }
- }
-
- Sheet sheet = getSheet();
- TextRun[] runs = sheet.getTextRuns();
- if (ota != null) {
- int idx = ota.getTextIndex();
- for (int i = 0; i < runs.length; i++) {
- if(runs[i].getIndex() == idx){
- _txtrun = runs[i];
- }
- }
- if(_txtrun == null) {
- logger.log(POILogger.WARN, "text run not found for OutlineTextRefAtom.TextIndex=" + idx);
- }
- } else {
- int shapeId = _escherContainer.getChildById(EscherSpRecord.RECORD_ID).getShapeId();
- if(runs != null) for (int i = 0; i < runs.length; i++) {
- if(runs[i].getShapeId() == shapeId){
- _txtrun = runs[i];
- break;
- }
- }
- }
-
- }
}
import java.util.Vector;
import org.apache.poi.hslf.model.textproperties.TextPropCollection;
-import org.apache.poi.hslf.record.Record;
-import org.apache.poi.hslf.record.RecordContainer;
-import org.apache.poi.hslf.record.StyleTextPropAtom;
-import org.apache.poi.hslf.record.TextBytesAtom;
-import org.apache.poi.hslf.record.TextCharsAtom;
-import org.apache.poi.hslf.record.TextHeaderAtom;
+import org.apache.poi.hslf.record.*;
import org.apache.poi.hslf.usermodel.RichTextRun;
import org.apache.poi.hslf.usermodel.SlideShow;
import org.apache.poi.util.StringUtil;
protected TextBytesAtom _byteAtom;
protected TextCharsAtom _charAtom;
protected StyleTextPropAtom _styleAtom;
+ protected TextSpecInfoAtom _specAtom;
protected boolean _isUnicode;
protected RichTextRun[] _rtRuns;
private SlideShow slideShow;
// Recreate rich text run with no styling
_rtRuns[0] = new RichTextRun(this,0,s.length());
}
+
+ /**
+ * If TextSpecInfoAtom is present, we must update the text size,
+ * otherwise the ppt will be corrupted
+ */
+ if(_records != null) for (int i = 0; i < _records.length; i++) {
+ if(_records[i] instanceof TextSpecInfoAtom){
+ TextSpecInfoAtom specAtom = (TextSpecInfoAtom)_records[i];
+ specAtom.setTextSize(s.length());
+ }
+
+ }
}
/**
--- /dev/null
+\r
+/* ====================================================================\r
+ Licensed to the Apache Software Foundation (ASF) under one or more\r
+ contributor license agreements. See the NOTICE file distributed with\r
+ this work for additional information regarding copyright ownership.\r
+ The ASF licenses this file to You under the Apache License, Version 2.0\r
+ (the "License"); you may not use this file except in compliance with\r
+ the License. You may obtain a copy of the License at\r
+\r
+ http://www.apache.org/licenses/LICENSE-2.0\r
+\r
+ Unless required by applicable law or agreed to in writing, software\r
+ distributed under the License is distributed on an "AS IS" BASIS,\r
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ See the License for the specific language governing permissions and\r
+ limitations under the License.\r
+==================================================================== */\r
+\r
+package org.apache.poi.hslf.model;\r
+\r
+import org.apache.poi.ddf.*;\r
+import org.apache.poi.hslf.record.*;\r
+import org.apache.poi.hslf.usermodel.RichTextRun;\r
+import org.apache.poi.hslf.exceptions.HSLFException;\r
+import org.apache.poi.util.POILogger;\r
+\r
+import java.awt.*;\r
+import java.awt.geom.Rectangle2D;\r
+import java.awt.geom.AffineTransform;\r
+import java.awt.font.FontRenderContext;\r
+import java.awt.font.TextLayout;\r
+import java.io.IOException;\r
+\r
+/**\r
+ * A common superclass of all shapes that can hold text.\r
+ *\r
+ * @author Yegor Kozlov\r
+ */\r
+public abstract class TextShape extends SimpleShape {\r
+\r
+ /**\r
+ * How to anchor the text\r
+ */\r
+ public static final int AnchorTop = 0;\r
+ public static final int AnchorMiddle = 1;\r
+ public static final int AnchorBottom = 2;\r
+ public static final int AnchorTopCentered = 3;\r
+ public static final int AnchorMiddleCentered = 4;\r
+ public static final int AnchorBottomCentered = 5;\r
+ public static final int AnchorTopBaseline = 6;\r
+ public static final int AnchorBottomBaseline = 7;\r
+ public static final int AnchorTopCenteredBaseline = 8;\r
+ public static final int AnchorBottomCenteredBaseline = 9;\r
+\r
+ /**\r
+ * How to wrap the text\r
+ */\r
+ public static final int WrapSquare = 0;\r
+ public static final int WrapByPoints = 1;\r
+ public static final int WrapNone = 2;\r
+ public static final int WrapTopBottom = 3;\r
+ public static final int WrapThrough = 4;\r
+\r
+ /**\r
+ * How to align the text\r
+ */\r
+ public static final int AlignLeft = 0;\r
+ public static final int AlignCenter = 1;\r
+ public static final int AlignRight = 2;\r
+ public static final int AlignJustify = 3;\r
+\r
+ /**\r
+ * TextRun object which holds actual text and format data\r
+ */\r
+ protected TextRun _txtrun;\r
+\r
+ /**\r
+ * Escher container which holds text attributes such as\r
+ * TextHeaderAtom, TextBytesAtom ot TextCharsAtom, StyleTextPropAtom etc.\r
+ */\r
+ protected EscherTextboxWrapper _txtbox;\r
+\r
+ /**\r
+ * Used to calculate text bounds\r
+ */\r
+ protected static final FontRenderContext _frc = new FontRenderContext(null, true, true);\r
+\r
+ /**\r
+ * Create a TextBox object and initialize it from the supplied Record container.\r
+ * \r
+ * @param escherRecord <code>EscherSpContainer</code> container which holds information about this shape\r
+ * @param parent the parent of the shape\r
+ */\r
+ protected TextShape(EscherContainerRecord escherRecord, Shape parent){\r
+ super(escherRecord, parent);\r
+\r
+ }\r
+\r
+ /**\r
+ * Create a new TextBox. This constructor is used when a new shape is created.\r
+ *\r
+ * @param parent the parent of this Shape. For example, if this text box is a cell\r
+ * in a table then the parent is Table.\r
+ */\r
+ public TextShape(Shape parent){\r
+ super(null, parent);\r
+ _escherContainer = createSpContainer(parent instanceof ShapeGroup);\r
+ }\r
+\r
+ /**\r
+ * Create a new TextBox. This constructor is used when a new shape is created.\r
+ *\r
+ */\r
+ public TextShape(){\r
+ this(null);\r
+ }\r
+\r
+ public TextRun createTextRun(){\r
+ _txtbox = getEscherTextboxWrapper();\r
+ if(_txtbox == null) _txtbox = new EscherTextboxWrapper();\r
+\r
+ _txtrun = getTextRun();\r
+ if(_txtrun == null){\r
+ TextHeaderAtom tha = new TextHeaderAtom();\r
+ tha.setParentRecord(_txtbox);\r
+ _txtbox.appendChildRecord(tha);\r
+\r
+ TextCharsAtom tca = new TextCharsAtom();\r
+ _txtbox.appendChildRecord(tca);\r
+\r
+ StyleTextPropAtom sta = new StyleTextPropAtom(0);\r
+ _txtbox.appendChildRecord(sta);\r
+\r
+ _txtrun = new TextRun(tha,tca,sta);\r
+ _txtrun.setText("");\r
+\r
+ _escherContainer.addChildRecord(_txtbox.getEscherRecord());\r
+\r
+ setDefaultTextProperties(_txtrun);\r
+ }\r
+\r
+ return _txtrun;\r
+ }\r
+\r
+ /**\r
+ * Set default properties for the TextRun.\r
+ * Depending on the text and shape type the defaults are different:\r
+ * TextBox: align=left, valign=top\r
+ * AutoShape: align=center, valign=middle\r
+ *\r
+ */\r
+ protected void setDefaultTextProperties(TextRun _txtrun){\r
+\r
+ }\r
+\r
+ /**\r
+ * Returns the text contained in this text frame.\r
+ *\r
+ * @return the text string for this textbox.\r
+ */\r
+ public String getText(){\r
+ TextRun tx = getTextRun();\r
+ return tx == null ? null : tx.getText();\r
+ }\r
+\r
+ /**\r
+ * Sets the text contained in this text frame.\r
+ *\r
+ * @param text the text string used by this object.\r
+ */\r
+ public void setText(String text){\r
+ TextRun tx = getTextRun();\r
+ if(tx == null){\r
+ tx = createTextRun();\r
+ }\r
+ tx.setText(text);\r
+ setTextId(text.hashCode());\r
+ }\r
+\r
+ /**\r
+ * When a textbox is added to a sheet we need to tell upper-level\r
+ * <code>PPDrawing</code> about it.\r
+ *\r
+ * @param sh the sheet we are adding to\r
+ */\r
+ protected void afterInsert(Sheet sh){\r
+ EscherTextboxWrapper _txtbox = getEscherTextboxWrapper();\r
+ if(_txtbox != null){\r
+ PPDrawing ppdrawing = sh.getPPDrawing();\r
+ ppdrawing.addTextboxWrapper(_txtbox);\r
+ // Ensure the escher layer knows about the added records\r
+ try {\r
+ _txtbox.writeOut(null);\r
+ } catch (IOException e){\r
+ throw new HSLFException(e);\r
+ }\r
+ if(getAnchor().equals(new Rectangle()) && !"".equals(getText())) resizeToFitText();\r
+ }\r
+ }\r
+\r
+ protected EscherTextboxWrapper getEscherTextboxWrapper(){\r
+ if(_txtbox == null){\r
+ EscherTextboxRecord textRecord = (EscherTextboxRecord)Shape.getEscherChild(_escherContainer, EscherTextboxRecord.RECORD_ID);\r
+ if(textRecord != null) _txtbox = new EscherTextboxWrapper(textRecord);\r
+ }\r
+ return _txtbox;\r
+ }\r
+ /**\r
+ * Adjust the size of the TextShape so it encompasses the text inside it.\r
+ *\r
+ * @return a <code>Rectangle2D</code> that is the bounds of this <code>TextShape</code>.\r
+ */\r
+ public Rectangle2D resizeToFitText(){\r
+ String txt = getText();\r
+ if(txt == null || txt.length() == 0) return new Rectangle2D.Float();\r
+\r
+ RichTextRun rt = getTextRun().getRichTextRuns()[0];\r
+ int size = rt.getFontSize();\r
+ int style = 0;\r
+ if (rt.isBold()) style |= Font.BOLD;\r
+ if (rt.isItalic()) style |= Font.ITALIC;\r
+ String fntname = rt.getFontName();\r
+ Font font = new Font(fntname, style, size);\r
+\r
+ float width = 0, height = 0;\r
+ String[] lines = txt.split("\r");\r
+ for (int i = 0; i < lines.length; i++) {\r
+ if(lines[i].length() == 0) continue;\r
+\r
+ TextLayout layout = new TextLayout(lines[i], font, _frc);\r
+\r
+ width = Math.max(width, layout.getAdvance());\r
+\r
+ /**\r
+ * Even if top and bottom margins are set to 0 PowerPoint\r
+ * always sets extra space between the text and its bounding box.\r
+ *\r
+ * The approximation height = ascent*2 works good enough in most cases\r
+ */\r
+ height = Math.max(height, 2*layout.getAscent());\r
+ }\r
+\r
+ width += getMarginLeft() + getMarginRight();\r
+ height += getMarginTop() + getMarginBottom();\r
+\r
+ Rectangle2D anchor = getAnchor2D();\r
+ anchor.setRect(anchor.getX(), anchor.getY(), width, height);\r
+ setAnchor(anchor);\r
+\r
+ return anchor;\r
+ }\r
+\r
+ /**\r
+ * Returns the type of vertical alignment for the text.\r
+ * One of the <code>Anchor*</code> constants defined in this class.\r
+ *\r
+ * @return the type of alignment\r
+ */\r
+ public int getVerticalAlignment(){\r
+ EscherOptRecord opt = (EscherOptRecord)getEscherChild(_escherContainer, EscherOptRecord.RECORD_ID);\r
+ EscherSimpleProperty prop = (EscherSimpleProperty)getEscherProperty(opt, EscherProperties.TEXT__ANCHORTEXT);\r
+ int valign;\r
+ if (prop == null){\r
+ int type = getTextRun().getRunType();\r
+ switch (type){\r
+ case TextHeaderAtom.TITLE_TYPE:\r
+ case TextHeaderAtom.CENTER_TITLE_TYPE:\r
+ valign = TextShape.AnchorMiddle;\r
+ break;\r
+ default:\r
+ valign = TextShape.AnchorTop;\r
+ break;\r
+ }\r
+ } else {\r
+ valign = prop.getPropertyValue();\r
+ }\r
+ return valign;\r
+ }\r
+\r
+ /**\r
+ * Sets the type of vertical alignment for the text.\r
+ * One of the <code>Anchor*</code> constants defined in this class.\r
+ *\r
+ * @param align - the type of alignment\r
+ */\r
+ public void setVerticalAlignment(int align){\r
+ setEscherProperty(EscherProperties.TEXT__ANCHORTEXT, align);\r
+ }\r
+\r
+ /**\r
+ * Sets the type of horizontal alignment for the text.\r
+ * One of the <code>Align*</code> constants defined in this class.\r
+ *\r
+ * @param align - the type of horizontal alignment\r
+ */\r
+ public void setHorizontalAlignment(int align){\r
+ TextRun tx = getTextRun();\r
+ if(tx != null) tx.getRichTextRuns()[0].setAlignment(align);\r
+ }\r
+\r
+ /**\r
+ * Gets the type of horizontal alignment for the text.\r
+ * One of the <code>Align*</code> constants defined in this class.\r
+ *\r
+ * @return align - the type of horizontal alignment\r
+ */\r
+ public int getHorizontalAlignment(){\r
+ TextRun tx = getTextRun();\r
+ return tx == null ? -1 : tx.getRichTextRuns()[0].getAlignment();\r
+ }\r
+\r
+ /**\r
+ * Returns the distance (in points) between the bottom of the text frame\r
+ * and the bottom of the inscribed rectangle of the shape that contains the text.\r
+ * Default value is 1/20 inch.\r
+ *\r
+ * @return the botom margin\r
+ */\r
+ public float getMarginBottom(){\r
+ EscherOptRecord opt = (EscherOptRecord)getEscherChild(_escherContainer, EscherOptRecord.RECORD_ID);\r
+ EscherSimpleProperty prop = (EscherSimpleProperty)getEscherProperty(opt, EscherProperties.TEXT__TEXTBOTTOM);\r
+ int val = prop == null ? EMU_PER_INCH/20 : prop.getPropertyValue();\r
+ return (float)val/EMU_PER_POINT;\r
+ }\r
+\r
+ /**\r
+ * Sets the botom margin.\r
+ * @see #getMarginBottom()\r
+ *\r
+ * @param margin the bottom margin\r
+ */\r
+ public void setMarginBottom(float margin){\r
+ setEscherProperty(EscherProperties.TEXT__TEXTBOTTOM, (int)(margin*EMU_PER_POINT));\r
+ }\r
+\r
+ /**\r
+ * Returns the distance (in points) between the left edge of the text frame\r
+ * and the left edge of the inscribed rectangle of the shape that contains\r
+ * the text.\r
+ * Default value is 1/10 inch.\r
+ *\r
+ * @return the left margin\r
+ */\r
+ public float getMarginLeft(){\r
+ EscherOptRecord opt = (EscherOptRecord)getEscherChild(_escherContainer, EscherOptRecord.RECORD_ID);\r
+ EscherSimpleProperty prop = (EscherSimpleProperty)getEscherProperty(opt, EscherProperties.TEXT__TEXTBOTTOM);\r
+ int val = prop == null ? EMU_PER_INCH/10 : prop.getPropertyValue();\r
+ return (float)val/EMU_PER_POINT;\r
+ }\r
+\r
+ /**\r
+ * Sets the left margin.\r
+ * @see #getMarginLeft()\r
+ *\r
+ * @param margin the left margin\r
+ */\r
+ public void setMarginLeft(float margin){\r
+ setEscherProperty(EscherProperties.TEXT__TEXTLEFT, (int)(margin*EMU_PER_POINT));\r
+ }\r
+\r
+ /**\r
+ * Returns the distance (in points) between the right edge of the\r
+ * text frame and the right edge of the inscribed rectangle of the shape\r
+ * that contains the text.\r
+ * Default value is 1/10 inch.\r
+ *\r
+ * @return the right margin\r
+ */\r
+ public float getMarginRight(){\r
+ EscherOptRecord opt = (EscherOptRecord)getEscherChild(_escherContainer, EscherOptRecord.RECORD_ID);\r
+ EscherSimpleProperty prop = (EscherSimpleProperty)getEscherProperty(opt, EscherProperties.TEXT__TEXTRIGHT);\r
+ int val = prop == null ? EMU_PER_INCH/10 : prop.getPropertyValue();\r
+ return (float)val/EMU_PER_POINT;\r
+ }\r
+\r
+ /**\r
+ * Sets the right margin.\r
+ * @see #getMarginRight()\r
+ *\r
+ * @param margin the right margin\r
+ */\r
+ public void setMarginRight(float margin){\r
+ setEscherProperty(EscherProperties.TEXT__TEXTRIGHT, (int)(margin*EMU_PER_POINT));\r
+ }\r
+\r
+ /**\r
+ * Returns the distance (in points) between the top of the text frame\r
+ * and the top of the inscribed rectangle of the shape that contains the text.\r
+ * Default value is 1/20 inch.\r
+ *\r
+ * @return the top margin\r
+ */\r
+ public float getMarginTop(){\r
+ EscherOptRecord opt = (EscherOptRecord)getEscherChild(_escherContainer, EscherOptRecord.RECORD_ID);\r
+ EscherSimpleProperty prop = (EscherSimpleProperty)getEscherProperty(opt, EscherProperties.TEXT__TEXTTOP);\r
+ int val = prop == null ? EMU_PER_INCH/20 : prop.getPropertyValue();\r
+ return (float)val/EMU_PER_POINT;\r
+ }\r
+\r
+ /**\r
+ * Sets the top margin.\r
+ * @see #getMarginTop()\r
+ *\r
+ * @param margin the top margin\r
+ */\r
+ public void setMarginTop(float margin){\r
+ setEscherProperty(EscherProperties.TEXT__TEXTTOP, (int)(margin*EMU_PER_POINT));\r
+ }\r
+\r
+\r
+ /**\r
+ * Returns the value indicating word wrap.\r
+ *\r
+ * @return the value indicating word wrap.\r
+ * Must be one of the <code>Wrap*</code> constants defined in this class.\r
+ */\r
+ public int getWordWrap(){\r
+ EscherOptRecord opt = (EscherOptRecord)getEscherChild(_escherContainer, EscherOptRecord.RECORD_ID);\r
+ EscherSimpleProperty prop = (EscherSimpleProperty)getEscherProperty(opt, EscherProperties.TEXT__WRAPTEXT);\r
+ return prop == null ? WrapSquare : prop.getPropertyValue();\r
+ }\r
+\r
+ /**\r
+ * Specifies how the text should be wrapped\r
+ *\r
+ * @param wrap the value indicating how the text should be wrapped.\r
+ * Must be one of the <code>Wrap*</code> constants defined in this class.\r
+ */\r
+ public void setWordWrap(int wrap){\r
+ setEscherProperty(EscherProperties.TEXT__WRAPTEXT, wrap);\r
+ }\r
+\r
+ /**\r
+ * @return id for the text.\r
+ */\r
+ public int getTextId(){\r
+ EscherOptRecord opt = (EscherOptRecord)getEscherChild(_escherContainer, EscherOptRecord.RECORD_ID);\r
+ EscherSimpleProperty prop = (EscherSimpleProperty)getEscherProperty(opt, EscherProperties.TEXT__TEXTID);\r
+ return prop == null ? 0 : prop.getPropertyValue();\r
+ }\r
+\r
+ /**\r
+ * Sets text ID\r
+ *\r
+ * @param id of the text\r
+ */\r
+ public void setTextId(int id){\r
+ setEscherProperty(EscherProperties.TEXT__TEXTID, id);\r
+ }\r
+\r
+ /**\r
+ * @return the TextRun object for this text box\r
+ */\r
+ public TextRun getTextRun(){\r
+ if(_txtrun == null) initTextRun();\r
+ return _txtrun;\r
+ }\r
+\r
+ public void setSheet(Sheet sheet) {\r
+ _sheet = sheet;\r
+\r
+ // Initialize _txtrun object.\r
+ // (We can't do it in the constructor because the sheet\r
+ // is not assigned then, it's only built once we have\r
+ // all the records)\r
+ TextRun tx = getTextRun();\r
+ if (tx != null) {\r
+ // Supply the sheet to our child RichTextRuns\r
+ tx.setSheet(_sheet);\r
+ RichTextRun[] rt = tx.getRichTextRuns();\r
+ for (int i = 0; i < rt.length; i++) {\r
+ rt[i].supplySlideShow(_sheet.getSlideShow());\r
+ }\r
+ }\r
+\r
+ }\r
+\r
+ protected void initTextRun(){\r
+ EscherTextboxWrapper txtbox = getEscherTextboxWrapper();\r
+ Sheet sheet = getSheet();\r
+\r
+ if(sheet == null || txtbox == null) return;\r
+\r
+ OutlineTextRefAtom ota = null;\r
+\r
+ Record[] child = txtbox.getChildRecords();\r
+ for (int i = 0; i < child.length; i++) {\r
+ if (child[i] instanceof OutlineTextRefAtom) {\r
+ ota = (OutlineTextRefAtom)child[i];\r
+ break;\r
+ }\r
+ }\r
+\r
+ TextRun[] runs = _sheet.getTextRuns();\r
+ if (ota != null) {\r
+ int idx = ota.getTextIndex();\r
+ for (int i = 0; i < runs.length; i++) {\r
+ if(runs[i].getIndex() == idx){\r
+ _txtrun = runs[i];\r
+ break;\r
+ }\r
+ }\r
+ if(_txtrun == null) {\r
+ logger.log(POILogger.WARN, "text run not found for OutlineTextRefAtom.TextIndex=" + idx);\r
+ }\r
+ } else {\r
+ int shapeId = _escherContainer.getChildById(EscherSpRecord.RECORD_ID).getShapeId();\r
+ if(runs != null) for (int i = 0; i < runs.length; i++) {\r
+ if(runs[i].getShapeId() == shapeId){\r
+ _txtrun = runs[i];\r
+ break;\r
+ }\r
+ }\r
+ }\r
+ }\r
+}\r
* @return zero based index of the font in the collection
*/
public int addFont(String name) {
- for (int i = 0; i < fonts.size(); i++) {
- if(fonts.get(i).equals(name)){
- //if the font is already present return its index
- return i;
- }
- }
+ int idx = getFontIndex(name);
+ if(idx != -1) return idx;
+ return addFont(name, 0, 0, 4, 34);
+ }
+
+ public int addFont(String name, int charset, int flags, int type, int pitch) {
FontEntityAtom fnt = new FontEntityAtom();
fnt.setFontIndex(fonts.size() << 4);
fnt.setFontName(name);
+ fnt.setCharSet(charset);
+ fnt.setFontFlags(flags);
+ fnt.setFontType(type);
+ fnt.setPitchAndFamily(pitch);
fonts.add(name);
// Append new child to the end
return fonts.size()-1; //the added font is the last in the list
}
-
- /**
+
+ /**
+ * @return zero based index of the font in the collection or -1 if not found
+ */
+ public int getFontIndex(String name) {
+ for (int i = 0; i < fonts.size(); i++) {
+ if(fonts.get(i).equals(name)){
+ //if the font is already present return its index
+ return i;
+ }
+ }
+ return -1;
+ }
+
+ public int getNumberOfFonts() {
+ return fonts.size();
+ }
+
+ /**
* Get the name of the font at the given ID, or null if there is
* no font at that ID.
* @param id
/**
* Create a new instance of <code>FontEntityAtom</code>
*/
- protected FontEntityAtom() {
+ public FontEntityAtom() {
_recdata = new byte[68];
_header = new byte[8];
}
}
- protected void setFontIndex(int idx){
+ public void setFontIndex(int idx){
LittleEndian.putShort(_header, 0, (short)idx);
}
- protected int getFontIndex(){
- return LittleEndian.getShort(_header, 0);
+ public int getFontIndex(){
+ return LittleEndian.getShort(_header, 0) >> 4;
}
- /**
+ /**
+ * set the character set
+ *
+ * @param charset - characterset
+ */
+ public void setCharSet(int charset){
+ _recdata[64] = (byte)charset;
+ }
+
+ /**
+ * get the character set
+ *
+ * @return charset - characterset
+ */
+ public int getCharSet(){
+ return _recdata[64];
+ }
+
+ /**
+ * set the font flags
+ * Bit 1: If set, font is subsetted
+ *
+ * @param flags - the font flags
+ */
+ public void setFontFlags(int flags){
+ _recdata[65] = (byte)flags;
+ }
+
+ /**
+ * get the character set
+ * Bit 1: If set, font is subsetted
+ *
+ * @return the font flags
+ */
+ public int getFontFlags(){
+ return _recdata[65];
+ }
+
+ /**
+ * set the font type
+ * <p>
+ * Bit 1: Raster Font
+ * Bit 2: Device Font
+ * Bit 3: TrueType Font
+ * </p>
+ *
+ * @param type - the font type
+ */
+ public void setFontType(int type){
+ _recdata[66] = (byte)type;
+ }
+
+ /**
+ * get the font type
+ * <p>
+ * Bit 1: Raster Font
+ * Bit 2: Device Font
+ * Bit 3: TrueType Font
+ * </p>
+ *
+ * @return the font type
+ */
+ public int getFontType(){
+ return _recdata[66];
+ }
+
+ /**
+ * set lfPitchAndFamily
+ *
+ *
+ * @param val - Corresponds to the lfPitchAndFamily field of the Win32 API LOGFONT structure
+ */
+ public void setPitchAndFamily(int val){
+ _recdata[67] = (byte)val;
+ }
+
+ /**
+ * get lfPitchAndFamily
+ *
+ * @return corresponds to the lfPitchAndFamily field of the Win32 API LOGFONT structure
+ */
+ public int getPitchAndFamily(){
+ return _recdata[67];
+ }
+
+ /**
* Write the contents of the record back, so it can be written to disk
*/
public void writeOut(OutputStream out) throws IOException {
public static final Type TextBookmarkAtom = new Type(4007,null);
public static final Type TextBytesAtom = new Type(4008,TextBytesAtom.class);
public static final Type TxSIStyleAtom = new Type(4009,null);
- public static final Type TextSpecInfoAtom = new Type(4010,null);
+ public static final Type TextSpecInfoAtom = new Type(4010, TextSpecInfoAtom.class);
public static final Type DefaultRulerAtom = new Type(4011,null);
public static final Type FontEntityAtom = new Type(4023,FontEntityAtom.class);
public static final Type FontEmbeddedData = new Type(4024,null);
--- /dev/null
+/* ====================================================================\r
+ Licensed to the Apache Software Foundation (ASF) under one or more\r
+ contributor license agreements. See the NOTICE file distributed with\r
+ this work for additional information regarding copyright ownership.\r
+ The ASF licenses this file to You under the Apache License, Version 2.0\r
+ (the "License"); you may not use this file except in compliance with\r
+ the License. You may obtain a copy of the License at\r
+\r
+ http://www.apache.org/licenses/LICENSE-2.0\r
+\r
+ Unless required by applicable law or agreed to in writing, software\r
+ distributed under the License is distributed on an "AS IS" BASIS,\r
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ See the License for the specific language governing permissions and\r
+ limitations under the License.\r
+==================================================================== */\r
+package org.apache.poi.hslf.record;\r
+\r
+import org.apache.poi.util.LittleEndian;\r
+\r
+import java.io.OutputStream;\r
+import java.io.IOException;\r
+\r
+/**\r
+ * The special info runs contained in this text.\r
+ * Special info runs consist of character properties which don?t follow styles.\r
+ * \r
+ * @author Yegor Kozlov\r
+ */\r
+public class TextSpecInfoAtom extends RecordAtom {\r
+ /**\r
+ * Record header.\r
+ */\r
+ private byte[] _header;\r
+\r
+ /**\r
+ * Record data.\r
+ */\r
+ private byte[] _data;\r
+\r
+ /**\r
+ * Constructs the link related atom record from its\r
+ * source data.\r
+ *\r
+ * @param source the source data as a byte array.\r
+ * @param start the start offset into the byte array.\r
+ * @param len the length of the slice in the byte array.\r
+ */\r
+ protected TextSpecInfoAtom(byte[] source, int start, int len) {\r
+ // Get the header.\r
+ _header = new byte[8];\r
+ System.arraycopy(source,start,_header,0,8);\r
+\r
+ // Get the record data.\r
+ _data = new byte[len-8];\r
+ System.arraycopy(source,start+8,_data,0,len-8);\r
+\r
+ }\r
+ /**\r
+ * Gets the record type.\r
+ * @return the record type.\r
+ */\r
+ public long getRecordType() { return RecordTypes.TextSpecInfoAtom.typeID; }\r
+\r
+ /**\r
+ * Write the contents of the record back, so it can be written\r
+ * to disk\r
+ *\r
+ * @param out the output stream to write to.\r
+ * @throws java.io.IOException if an error occurs.\r
+ */\r
+ public void writeOut(OutputStream out) throws IOException {\r
+ out.write(_header);\r
+ out.write(_data);\r
+ }\r
+\r
+ /**\r
+ * Update the text length\r
+ *\r
+ * @param size the text length\r
+ */\r
+ public void setTextSize(int size){\r
+ LittleEndian.putInt(_data, 0, size);\r
+ }\r
+}\r
}
return addPicture(data, format);
}
+
+ /**
+ * Add a font in this presentation
+ *
+ * @param font the font to add
+ * @return 0-based index of the font
+ */
+ public int addFont(PPFont font) {
+ FontCollection fonts = getDocumentRecord().getEnvironment().getFontCollection();
+ int idx = fonts.getFontIndex(font.getFontName());
+ if(idx == -1){
+ idx = fonts.addFont(font.getFontName(), font.getCharSet(), font.getFontFlags(), font.getFontType(), font.getPitchAndFamily());
+ }
+ return idx;
+ }
+
+ /**
+ * Get a font by index
+ *
+ * @param idx 0-based index of the font
+ * @return of an instance of <code>PPFont</code> or <code>null</code> if not found
+ */
+ public PPFont getFont(int idx) {
+ PPFont font = null;
+ FontCollection fonts = getDocumentRecord().getEnvironment().getFontCollection();
+ Record[] ch = fonts.getChildRecords();
+ for (int i = 0; i < ch.length; i++) {
+ if(ch[i] instanceof FontEntityAtom) {
+ FontEntityAtom atom = (FontEntityAtom)ch[i];
+ if(atom.getFontIndex() == idx){
+ font = new PPFont(atom);
+ break;
+ }
+ }
+ }
+ return font;
+ }
+
+ /**
+ * get the number of fonts in the presentation
+ *
+ * @return number of fonts
+ */
+ public int getNumberOfFonts() {
+ return getDocumentRecord().getEnvironment().getFontCollection().getNumberOfFonts();
+ }
}
--- /dev/null
+\r
+/* ====================================================================\r
+ Licensed to the Apache Software Foundation (ASF) under one or more\r
+ contributor license agreements. See the NOTICE file distributed with\r
+ this work for additional information regarding copyright ownership.\r
+ The ASF licenses this file to You under the Apache License, Version 2.0\r
+ (the "License"); you may not use this file except in compliance with\r
+ the License. You may obtain a copy of the License at\r
+\r
+ http://www.apache.org/licenses/LICENSE-2.0\r
+\r
+ Unless required by applicable law or agreed to in writing, software\r
+ distributed under the License is distributed on an "AS IS" BASIS,\r
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ See the License for the specific language governing permissions and\r
+ limitations under the License.\r
+==================================================================== */\r
+\r
+package org.apache.poi.hslf.model;\r
+\r
+import junit.framework.TestCase;\r
+import org.apache.poi.hslf.usermodel.SlideShow;\r
+\r
+import java.io.IOException;\r
+\r
+/**\r
+ * Test adding fonts to the presenataion resources\r
+ * \r
+ * @author Yegor Kozlov\r
+ */\r
+public class TestPPFont extends TestCase{\r
+\r
+ public void testCreate() throws IOException {\r
+ SlideShow ppt = new SlideShow();\r
+ assertEquals(1, ppt.getNumberOfFonts());\r
+ assertEquals("Arial", ppt.getFont(0).getFontName());\r
+\r
+ //adding the same font twice\r
+ assertEquals(0, ppt.addFont(PPFont.ARIAL));\r
+ assertEquals(1, ppt.getNumberOfFonts());\r
+\r
+ assertEquals(1, ppt.addFont(PPFont.TIMES_NEW_ROMAN));\r
+ assertEquals(2, ppt.addFont(PPFont.COURIER_NEW));\r
+ assertEquals(3, ppt.addFont(PPFont.WINGDINGS));\r
+\r
+ assertEquals(4, ppt.getNumberOfFonts());\r
+\r
+ assertEquals(PPFont.TIMES_NEW_ROMAN.getFontName(), ppt.getFont(1).getFontName());\r
+ assertEquals(PPFont.COURIER_NEW.getFontName(), ppt.getFont(2).getFontName());\r
+\r
+ PPFont font3 = ppt.getFont(3);\r
+ assertEquals(PPFont.WINGDINGS.getFontName(), font3.getFontName());\r
+ assertEquals(PPFont.SYMBOL_CHARSET, font3.getCharSet());\r
+ assertEquals(PPFont.VARIABLE_PITCH, font3.getPitchAndFamily());\r
+ }\r
+}\r
ArrayList lst2 = new ArrayList();
Shape[] sh = sl[k].getShapes();
for (int i = 0; i < sh.length; i++) {
- if (sh[i] instanceof TextBox){
- TextBox tbox = (TextBox)sh[i];
+ if (sh[i] instanceof TextShape){
+ TextShape tbox = (TextShape)sh[i];
lst2.add(tbox.getText());
}
}
--- /dev/null
+\r
+/* ====================================================================\r
+ Licensed to the Apache Software Foundation (ASF) under one or more\r
+ contributor license agreements. See the NOTICE file distributed with\r
+ this work for additional information regarding copyright ownership.\r
+ The ASF licenses this file to You under the Apache License, Version 2.0\r
+ (the "License"); you may not use this file except in compliance with\r
+ the License. You may obtain a copy of the License at\r
+\r
+ http://www.apache.org/licenses/LICENSE-2.0\r
+\r
+ Unless required by applicable law or agreed to in writing, software\r
+ distributed under the License is distributed on an "AS IS" BASIS,\r
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ See the License for the specific language governing permissions and\r
+ limitations under the License.\r
+==================================================================== */\r
+\r
+\r
+package org.apache.poi.hslf.model;\r
+\r
+import junit.framework.TestCase;\r
+\r
+import java.io.*;\r
+import java.util.ArrayList;\r
+\r
+import org.apache.poi.hslf.usermodel.SlideShow;\r
+import org.apache.poi.hslf.record.TextHeaderAtom;\r
+\r
+/**\r
+ * Verify behavior of <code>TextShape</code> and its sub-classes\r
+ * \r
+ * @author Yegor Kozlov\r
+ */\r
+public class TestTextShape extends TestCase {\r
+ protected String cwd = System.getProperty("HSLF.testdata.path");\r
+\r
+ public void testCreateAutoShape(){\r
+ TextShape shape = new AutoShape(ShapeTypes.Trapezoid);\r
+ assertNull(shape.getTextRun());\r
+ assertNull(shape.getText());\r
+ assertNull(shape.getEscherTextboxWrapper());\r
+\r
+ TextRun run = shape.createTextRun();\r
+ assertNotNull(run);\r
+ assertNotNull(shape.getTextRun());\r
+ assertNotNull(shape.getEscherTextboxWrapper());\r
+ assertEquals("", shape.getText());\r
+ assertSame(run, shape.createTextRun());\r
+\r
+ }\r
+\r
+ public void testCreateTextBox(){\r
+ TextShape shape = new TextBox();\r
+ TextRun run = shape.getTextRun();\r
+ assertNotNull(run);\r
+ assertNotNull(shape.getText());\r
+ assertNotNull(shape.getEscherTextboxWrapper());\r
+\r
+ assertSame(run, shape.createTextRun());\r
+ assertNotNull(shape.getTextRun());\r
+ assertNotNull(shape.getEscherTextboxWrapper());\r
+ assertEquals("", shape.getText());\r
+\r
+ }\r
+\r
+ /**\r
+ * Verify we can get text from TextShape in the following cases:\r
+ * - placeholders\r
+ * - normal TextBox object\r
+ * - text in auto-shapes\r
+ */\r
+ public void testRead() throws IOException {\r
+ FileInputStream is = new FileInputStream(new File(cwd, "text_shapes.ppt"));\r
+ SlideShow ppt = new SlideShow(is);\r
+ is.close();\r
+\r
+ ArrayList lst1 = new ArrayList();\r
+ Slide slide = ppt.getSlides()[0];\r
+ Shape[] shape = slide.getShapes();\r
+ for (int i = 0; i < shape.length; i++) {\r
+ assertTrue("Expected TextShape but found " + shape[i].getClass().getName(), shape[i] instanceof TextShape);\r
+ TextShape tx = (TextShape)shape[i];\r
+ TextRun run = tx.getTextRun();\r
+ assertNotNull(run);\r
+ int runType = run.getRunType();\r
+\r
+ int type = shape[i].getShapeType();\r
+ switch (type){\r
+ case ShapeTypes.TextBox:\r
+ assertEquals("Text in a TextBox", run.getText());\r
+ break;\r
+ case ShapeTypes.Rectangle:\r
+ if(runType == TextHeaderAtom.OTHER_TYPE)\r
+ assertEquals("Rectangle", run.getText());\r
+ else if(runType == TextHeaderAtom.TITLE_TYPE)\r
+ assertEquals("Title Placeholder", run.getText());\r
+ break;\r
+ case ShapeTypes.Octagon:\r
+ assertEquals("Octagon", run.getText());\r
+ break;\r
+ case ShapeTypes.Ellipse:\r
+ assertEquals("Ellipse", run.getText());\r
+ break;\r
+ case ShapeTypes.RoundRectangle:\r
+ assertEquals("RoundRectangle", run.getText());\r
+ break;\r
+ default:\r
+ fail("Unexpected shape: " + shape[i].getShapeName());\r
+\r
+ }\r
+ lst1.add(run.getText());\r
+ }\r
+\r
+ ArrayList lst2 = new ArrayList();\r
+ TextRun[] run = slide.getTextRuns();\r
+ for (int i = 0; i < run.length; i++) {\r
+ lst2.add(run[i].getText());\r
+ }\r
+\r
+ assertTrue(lst1.containsAll(lst2));\r
+ }\r
+\r
+ public void testReadWrite() throws IOException {\r
+ SlideShow ppt = new SlideShow();\r
+ Slide slide = ppt.createSlide();\r
+\r
+ TextShape shape1 = new TextBox();\r
+ TextRun run1 = shape1.createTextRun();\r
+ run1.setText("Hello, World!");\r
+ slide.addShape(shape1);\r
+\r
+ shape1.moveTo(100, 100);\r
+\r
+ TextShape shape2 = new AutoShape(ShapeTypes.Arrow);\r
+ TextRun run2 = shape2.createTextRun();\r
+ run2.setText("Testing TextShape");\r
+ slide.addShape(shape2);\r
+ shape2.moveTo(300, 300);\r
+\r
+ ByteArrayOutputStream out = new ByteArrayOutputStream();\r
+ ppt.write(out);\r
+ out.close();\r
+\r
+ ppt = new SlideShow(new ByteArrayInputStream(out.toByteArray()));\r
+ slide = ppt.getSlides()[0];\r
+ Shape[] shape = slide.getShapes();\r
+\r
+ assertTrue(shape[0] instanceof TextShape);\r
+ shape1 = (TextShape)shape[0];\r
+ assertEquals(ShapeTypes.TextBox, shape1.getShapeType());\r
+ assertEquals("Hello, World!", shape1.getTextRun().getText());\r
+\r
+ assertTrue(shape[1] instanceof TextShape);\r
+ shape1 = (TextShape)shape[1];\r
+ assertEquals(ShapeTypes.Arrow, shape1.getShapeType());\r
+ assertEquals("Testing TextShape", shape1.getTextRun().getText());\r
+ }\r
+\r
+}\r
ArrayList lst = new ArrayList();\r
Shape[] shape = slide.getShapes();\r
for (int i = 0; i < shape.length; i++) {\r
- if( shape[i] instanceof TextBox){\r
- TextRun textRun = ((TextBox)shape[i]).getTextRun();\r
+ if( shape[i] instanceof TextShape){\r
+ TextRun textRun = ((TextShape)shape[i]).getTextRun();\r
if(textRun != null) lst.add(textRun);\r
}\r
\r
assertEquals(true, flag.getValue());
assertEquals("Y", y.getValue());
assertEquals("N", n.getValue());
- assertEquals("IF", funif.toFormulaString((Workbook) null));
+ assertEquals("IF", funif.toFormulaString((HSSFWorkbook) null));
assertTrue("Goto ptg exists", goto1.isGoto());
}
}
public void testMacroFunction() {
- Workbook w = Workbook.createWorkbook();
+ HSSFWorkbook w = new HSSFWorkbook();
FormulaParser fp = new FormulaParser("FOO()", w);
fp.parse();
Ptg[] ptg = fp.getRPNPtg();
* a formula consisting of a single no-arg function got rendered without the function braces
*/
public void testToFormulaStringZeroArgFunction() {
-
- Workbook book = Workbook.createWorkbook(); // not really used in this test
+ HSSFWorkbook book = new HSSFWorkbook();
Ptg[] ptgs = {
new FuncPtg(10, 0),
}
}
public void testFuncPtgSelection() {
- Workbook book = Workbook.createWorkbook();
+ HSSFWorkbook book = new HSSFWorkbook();
Ptg[] ptgs;
ptgs = FormulaParser.parse("countif(A1:A2, 1)", book);
assertEquals(3, ptgs.length);
import junit.framework.TestCase;
-import org.apache.poi.hssf.model.Workbook;
import org.apache.poi.hssf.record.CFRuleRecord.ComparisonOperator;
import org.apache.poi.hssf.record.cf.BorderFormatting;
import org.apache.poi.hssf.record.cf.FontFormatting;
import org.apache.poi.hssf.record.cf.PatternFormatting;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.util.HSSFColor;
import org.apache.poi.util.LittleEndian;
public void testCreateCFRuleRecord ()
{
- Workbook workbook = Workbook.createWorkbook();
+ HSSFWorkbook workbook = new HSSFWorkbook();
CFRuleRecord record = CFRuleRecord.create(workbook, "7");
testCFRuleRecord(record);
}
public void testWrite() {
- Workbook workbook = Workbook.createWorkbook();
+ HSSFWorkbook workbook = new HSSFWorkbook();
CFRuleRecord rr = CFRuleRecord.create(workbook, ComparisonOperator.BETWEEN, "5", "10");
PatternFormatting patternFormatting = new PatternFormatting();
int flags = LittleEndian.getInt(data, 10);
assertEquals("unused flags should be 111", 0x00380000, flags & 0x00380000);
assertEquals("undocumented flags should be 0000", 0, flags & 0x03C00000); // Otherwise Excel gets unhappy
- assertEquals(0xA03FFFFF, flags);
+ // check all remaining flag bits (some are not well understood yet)
+ assertEquals(0x203FFFFF, flags);
}
import junit.framework.TestCase;
-import org.apache.poi.hssf.model.Workbook;
import org.apache.poi.hssf.record.CFHeaderRecord;
import org.apache.poi.hssf.record.CFRuleRecord;
import org.apache.poi.hssf.record.RecordFactory;
import org.apache.poi.hssf.record.CFRuleRecord.ComparisonOperator;
import org.apache.poi.hssf.record.cf.CellRange;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
/**
* Tests the serialization and deserialization of the CFRecordsAggregate
public void testCFRecordsAggregate()
{
- Workbook workbook = Workbook.createWorkbook();
+ HSSFWorkbook workbook = new HSSFWorkbook();
List recs = new ArrayList();
CFHeaderRecord header = new CFHeaderRecord();
CFRuleRecord rule1 = CFRuleRecord.create(workbook, "7");
/**
* Creates a new Workbook and adds one sheet with the specified name
*/
- protected static final Workbook createWorkbookWithSheet(String sheetName) {
-
- Workbook book = Workbook.createWorkbook();
- // this creates sheet if it doesn't exist
- book.checkExternSheet(0);
- // TODO - this call alone does not create the sheet even though the javadoc says it does
- book.setSheetName(0, sheetName);
+ protected static final HSSFWorkbook createWorkbookWithSheet(String sheetName) {
+ HSSFWorkbook book = new HSSFWorkbook();
+ book.createSheet(sheetName);
return book;
}
}
package org.apache.poi.hssf.record.formula;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
/**
* Tests for Area3DPtg
Area3DPtg target = new Area3DPtg("A1:B1", (short)0);
String sheetName = "my sheet";
- Workbook book = createWorkbookWithSheet(sheetName);
+ HSSFWorkbook book = createWorkbookWithSheet(sheetName);
assertEquals("'my sheet'!A1:B1", target.toFormulaString(book));
book.setSheetName(0, "Sheet1");
book.setSheetName(0, "C64");
assertEquals("'C64'!A1:B1", target.toFormulaString(book));
}
-
-
-
}
package org.apache.poi.hssf.record.formula;
-import org.apache.poi.hssf.model.Workbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
/**
* Tests for Ref3DPtg
Ref3DPtg target = new Ref3DPtg("A1", (short)0);
- Workbook book = createWorkbookWithSheet("my sheet");
+ HSSFWorkbook book = createWorkbookWithSheet("my sheet");
assertEquals("'my sheet'!A1", target.toFormulaString(book));
import org.apache.poi.hssf.record.formula.FuncPtg;
import org.apache.poi.hssf.record.formula.FuncVarPtg;
import org.apache.poi.hssf.record.formula.Ptg;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
/**
* Tests parsing of some built-in functions that were not properly
* registered in POI as bug #44675, #44733 (March/April 2008).
public final class TestParseMissingBuiltInFuncs extends TestCase {
private static Ptg[] parse(String formula) {
- Workbook book = Workbook.createWorkbook();
+ HSSFWorkbook book = new HSSFWorkbook();
return FormulaParser.parse(formula, book);
}
private static void confirmFunc(String formula, int expPtgArraySize, boolean isVarArgFunc, int funcIx) {
assertEquals(expCls, ptgF.getClass());
// check that parsed Ptg array converts back to formula text OK
- Workbook book = Workbook.createWorkbook();
+ HSSFWorkbook book = new HSSFWorkbook();
String reRenderedFormula = FormulaParser.toFormulaString(book, ptgs);
assertEquals(formula, reRenderedFormula);
}
assertEquals(2, ptg.getLastColumn());
assertEquals(0, ptg.getFirstRow());
assertEquals(65535, ptg.getLastRow());
- assertEquals("C:C", ptg.toFormulaString(wb.getWorkbook()));
+ assertEquals("C:C", ptg.toFormulaString(wb));
// Will show as C:C, but won't know how many
// rows it covers as we don't have the sheet
HSSFSheet sheet = workbook.createSheet();
String formula = "7";
- HSSFFontFormatting fontFmt = new HSSFFontFormatting();
+ HSSFSheetConditionalFormatting sheetCF = sheet.getSheetConditionalFormatting();
+
+ HSSFConditionalFormattingRule rule1 = sheetCF.createConditionalFormattingRule(formula);
+ HSSFFontFormatting fontFmt = rule1.createFontFormatting();
fontFmt.setFontStyle(true, false);
- HSSFBorderFormatting bordFmt = new HSSFBorderFormatting();
+ HSSFBorderFormatting bordFmt = rule1.createBorderFormatting();
bordFmt.setBorderBottom(HSSFBorderFormatting.BORDER_THIN);
bordFmt.setBorderTop(HSSFBorderFormatting.BORDER_THICK);
bordFmt.setBorderLeft(HSSFBorderFormatting.BORDER_DASHED);
bordFmt.setBorderRight(HSSFBorderFormatting.BORDER_DOTTED);
- HSSFPatternFormatting patternFmt = new HSSFPatternFormatting();
- patternFmt.setFillBackgroundColor(HSSFColor.RED.index);
+ HSSFPatternFormatting patternFmt = rule1.createPatternFormatting();
+ patternFmt.setFillBackgroundColor(HSSFColor.YELLOW.index);
+
+ HSSFConditionalFormattingRule rule2 = sheetCF.createConditionalFormattingRule(ComparisonOperator.BETWEEN, "1", "2");
HSSFConditionalFormattingRule [] cfRules =
{
- sheet.createConditionalFormattingRule(formula, fontFmt, bordFmt, patternFmt),
- sheet.createConditionalFormattingRule(ComparisonOperator.BETWEEN, "1", "2", fontFmt, bordFmt, patternFmt)
+ rule1, rule2
};
short col = 1;
new Region(0,col,65535,col)
};
- sheet.addConditionalFormatting(regions, cfRules);
- sheet.addConditionalFormatting(regions, cfRules);
+ sheetCF.addConditionalFormatting(regions, cfRules);
+ sheetCF.addConditionalFormatting(regions, cfRules);
// Verification
- assertEquals(2, sheet.getNumConditionalFormattings());
- sheet.removeConditionalFormatting(1);
- assertEquals(1, sheet.getNumConditionalFormattings());
- HSSFConditionalFormatting cf = sheet.getConditionalFormattingAt(0);
+ assertEquals(2, sheetCF.getNumConditionalFormattings());
+ sheetCF.removeConditionalFormatting(1);
+ assertEquals(1, sheetCF.getNumConditionalFormattings());
+ HSSFConditionalFormatting cf = sheetCF.getConditionalFormattingAt(0);
assertNotNull(cf);
regions = cf.getFormattingRegions();
assertEquals(2, cf.getNumberOfRules());
- HSSFConditionalFormattingRule rule1 = cf.getRule(0);
+ rule1 = cf.getRule(0);
assertEquals("7",rule1.getFormula1());
assertNull(rule1.getFormula2());
HSSFPatternFormatting r1pf = rule1.getPatternFormatting();
assertNotNull(r1pf);
- assertEquals(HSSFColor.RED.index,r1pf.getFillBackgroundColor());
+ assertEquals(HSSFColor.YELLOW.index,r1pf.getFillBackgroundColor());
- HSSFConditionalFormattingRule rule2 = cf.getRule(1);
+ rule2 = cf.getRule(1);
assertEquals("2",rule2.getFormula2());
assertEquals("1",rule2.getFormula1());
}
-
}
Area3DPtg ptgB = (Area3DPtg)def.get(1);
Area3DPtg ptgC = (Area3DPtg)def.get(2);
UnionPtg ptgD = (UnionPtg)def.get(3);
- assertEquals("", ptgA.toFormulaString(workbook));
- assertEquals(refA, ptgB.toFormulaString(workbook));
- assertEquals(refB, ptgC.toFormulaString(workbook));
- assertEquals(",", ptgD.toFormulaString(workbook));
+ assertEquals("", ptgA.toFormulaString(wb));
+ assertEquals(refA, ptgB.toFormulaString(wb));
+ assertEquals(refB, ptgC.toFormulaString(wb));
+ assertEquals(",", ptgD.toFormulaString(wb));
- assertEquals(ref, nr.getAreaReference(workbook));
+ assertEquals(ref, nr.getAreaReference(wb));
// Check the high level definition
int idx = wb.getNameIndex("test");
projects / poi.git / commitdiff