moparisthebest
/
poi
1
0
Fork 0
Code Issues Pull Requests Releases 1 Wiki Activity

Patch from Dmitriy from bug #30311 - Support for conditional formatting records 

git-svn-id: https://svn.apache.org/repos/asf/poi/trunk@638812 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Nick Burch 2008-03-19 12:28:56 +00:00
parent 870c5e1889
commit f7e7b20f2e
22 changed files with 4841 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/documentation/content/xdocs/changes.xml
View File

@ -36,6 +36,7 @@
<!-- Don't forget to update status.xml too! -->
<release version="3.1-beta1" date="2008-??-??">
<action dev="POI-DEVELOPERS" type="add">30311 - Initial support for Conditional Formatting</action>
<action dev="POI-DEVELOPERS" type="fix">44609 - Handle leading spaces in formulas, such as '= 4'</action>
<action dev="POI-DEVELOPERS" type="add">44608 - Support for PercentPtg in the formula evaluator</action>
<action dev="POI-DEVELOPERS" type="fix">44606 - Support calculated string values for evaluated formulas</action>

1
src/documentation/content/xdocs/status.xml
View File

@ -33,6 +33,7 @@
<!-- Don't forget to update changes.xml too! -->
<changes>
<release version="3.1-beta1" date="2008-??-??">
<action dev="POI-DEVELOPERS" type="add">30311 - Initial support for Conditional Formatting</action>
<action dev="POI-DEVELOPERS" type="fix">44609 - Handle leading spaces in formulas, such as '= 4'</action>
<action dev="POI-DEVELOPERS" type="add">44608 - Support for PercentPtg in the formula evaluator</action>
<action dev="POI-DEVELOPERS" type="fix">44606 - Support calculated string values for evaluated formulas</action>

73
src/java/org/apache/poi/hssf/model/Sheet.java
View File

@ -24,6 +24,7 @@ import org.apache.poi.hssf.record.aggregates.ColumnInfoRecordsAggregate;
import org.apache.poi.hssf.record.aggregates.FormulaRecordAggregate;
import org.apache.poi.hssf.record.aggregates.RowRecordsAggregate;
import org.apache.poi.hssf.record.aggregates.ValueRecordsAggregate;
import org.apache.poi.hssf.record.aggregates.CFRecordsAggregate;
import org.apache.poi.hssf.record.formula.Ptg;
import org.apache.poi.hssf.util.PaneInformation;
@ -96,6 +97,7 @@ public class Sheet implements Model
protected ObjectProtectRecord objprotect = null;
protected ScenarioProtectRecord scenprotect = null;
protected PasswordRecord password = null;
protected List condFormatting = new ArrayList();;
/** Add an UncalcedRecord if not true indicating formulas have not been calculated */
protected boolean uncalced = false;
@ -184,6 +186,17 @@ public class Sheet implements Model
retval.merged = ( MergeCellsRecord ) rec;
retval.numMergedRegions += retval.merged.getNumAreas();
}
else if ( rec.getSid() == CFHeaderRecord.sid )
{
CFRecordsAggregate cfAgg = CFRecordsAggregate.createCFAggregate(recs, k);
retval.condFormatting.add(cfAgg);
rec = cfAgg;
}
else if ( rec.getSid() == CFRuleRecord.sid )
{
// Skip it since it is processed by CFRecordsAggregate
rec = null;
}
else if (rec.getSid() == ColumnInfoRecord.sid)
{
ColumnInfoRecord col = (ColumnInfoRecord)rec;
@ -604,6 +617,66 @@ public class Sheet implements Model
{
return numMergedRegions;
}
// Find correct position to add new CF record
private int findConditionalFormattingPosition()
{
// This is default.
// If the algorithm does not find the right position,
// this one will be used (this is a position before EOF record)
int index = records.size()-2;
for( int i=index; i>=0; i-- )
{
Record rec = (Record)records.get(i);
short sid = rec.getSid();
// CFRecordsAggregate records already exist, just add to the end
if (rec instanceof CFRecordsAggregate) { return i+1; }
if( sid == (short)0x00ef ) { return i+1; }// PHONETICPR
if( sid == (short)0x015f ) { return i+1; }// LABELRANGES
if( sid == MergeCellsRecord.sid ) { return i+1; }
if( sid == (short)0x0099 ) { return i+1; }// STANDARDWIDTH
if( sid == SelectionRecord.sid ) { return i+1; }
if( sid == PaneRecord.sid ) { return i+1; }
if( sid == SCLRecord.sid ) { return i+1; }
if( sid == WindowTwoRecord.sid ) { return i+1; }
}
return index;
}
public int addConditionalFormatting(CFRecordsAggregate cfAggregate)
{
int index = findConditionalFormattingPosition();
records.add(index, cfAggregate);
condFormatting.add(cfAggregate);
return condFormatting.size()-1;
}
public void removeConditionalFormatting(int index)
{
if (index >= 0 && index <= condFormatting.size()-1 )
{
CFRecordsAggregate cfAggregate = getCFRecordsAggregateAt(index);
records.remove(cfAggregate);
condFormatting.remove(index);
}
}
public CFRecordsAggregate getCFRecordsAggregateAt(int index)
{
if (index >= 0 && index <= condFormatting.size()-1 )
{
return (CFRecordsAggregate) condFormatting.get(index);
}
return null;
}
public int getNumConditionalFormattings()
{
return condFormatting.size();
}
/**
* Returns the number of low level binary records in this sheet. This adjusts things for the so called

223
src/java/org/apache/poi/hssf/record/CFHeaderRecord.java Normal file
View File

@ -0,0 +1,223 @@
/* ====================================================================
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==================================================================== */
/*
* ConditionalFormattingHeaderRecord.java
*
* Created on January 17, 2008, 3:05 AM
*/
package org.apache.poi.hssf.record;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.apache.poi.hssf.record.cf.CellRange;
import org.apache.poi.util.LittleEndian;
/**
* Conditional Formatting Header record (CFHEADER)
*
* @author Dmitriy Kumshayev
*/
public class CFHeaderRecord extends Record
{
public static final short sid = 0x1B0;
private int field_1_numcf;
private int field_2_need_recalculation;
private CellRange field_3_enclosing_cell_range;
private List field_4_cell_ranges;
/** Creates new CFHeaderRecord */
public CFHeaderRecord()
{
field_4_cell_ranges = new ArrayList(5);
}
public CFHeaderRecord(RecordInputStream in)
{
super(in);
}
protected void fillFields(RecordInputStream in)
{
field_1_numcf = in.readShort();
field_2_need_recalculation = in.readShort();
field_3_enclosing_cell_range = new CellRange(in.readShort(),in.readShort(),in.readShort(),in.readShort());
int numCellRanges = in.readShort();
field_4_cell_ranges = new ArrayList(5);
for( int i=0; i<numCellRanges; i++)
{
field_4_cell_ranges.add(new CellRange(in.readShort(),in.readShort(),in.readShort(),in.readShort()));
}
}
public int getNumberOfConditionalFormats()
{
return field_1_numcf;
}
public void setNumberOfConditionalFormats(int n)
{
field_1_numcf=n;
}
public boolean getNeedRecalculation()
{
return field_2_need_recalculation==1?true:false;
}
public void setNeedRecalculation(boolean b)
{
field_2_need_recalculation=b?1:0;
}
public CellRange getEnclosingCellRange()
{
return field_3_enclosing_cell_range;
}
public void setEnclosingCellRange( CellRange cr)
{
field_3_enclosing_cell_range = cr.cloneCellRange();
}
/**
* Set cell ranges list to a single cell range and
* modify the enclosing cell range accordingly.
* @param List cellRanges - list of CellRange objects
*/
public void setCellRanges( List cellRanges )
{
field_4_cell_ranges.clear();
if(cellRanges!=null)
{
field_3_enclosing_cell_range=null;
for( int i=0; i<cellRanges.size(); i++)
{
field_4_cell_ranges.add(cellRanges.get(i));
recalculateEnclosingRange((CellRange)cellRanges.get(i));
}
}
}
private void recalculateEnclosingRange(CellRange cellRange)
{
field_3_enclosing_cell_range = cellRange.createEnclosingCellRange(field_3_enclosing_cell_range);
}
public List getCellRanges()
{
return field_4_cell_ranges;
}
public String toString()
{
StringBuffer buffer = new StringBuffer();
buffer.append("[CFHEADER]\n");
buffer.append(" .id = ").append(Integer.toHexString(sid)).append("\n");
buffer.append(" .numCF = ").append(getNumberOfConditionalFormats()).append("\n");
buffer.append(" .needRecalc = ").append(getNeedRecalculation()).append("\n");
buffer.append(" .enclosingCellRange= ").append(getEnclosingCellRange()).append("\n");
if( field_4_cell_ranges.size()>0)
{
buffer.append(" .cfranges=[");
for( int i=0; i<field_4_cell_ranges.size(); i++)
{
buffer.append(i==0?"":",").append(field_4_cell_ranges.get(i));
}
buffer.append("]\n");
}
buffer.append("[/CFHEADER]\n");
return buffer.toString();
}
/**
* @return byte array containing instance data
*/
public int serialize(int offset, byte[] data)
{
int recordsize = getRecordSize();
LittleEndian.putShort(data, 0 + offset, sid);
LittleEndian.putShort(data, 2 + offset, (short) (recordsize-4));
LittleEndian.putShort(data, 4 + offset, (short) field_1_numcf);
LittleEndian.putShort(data, 6 + offset, (short) field_2_need_recalculation);
LittleEndian.putShort(data, 8 + offset, (short) field_3_enclosing_cell_range.getFirstRow());
LittleEndian.putShort(data, 10 + offset, (short) field_3_enclosing_cell_range.getLastRow());
LittleEndian.putShort(data, 12 + offset, (short) field_3_enclosing_cell_range.getFirstColumn());
LittleEndian.putShort(data, 14 + offset, (short) field_3_enclosing_cell_range.getLastColumn());
LittleEndian.putShort(data, 16 + offset, (short) field_4_cell_ranges.size());
for( int i=0 ; i!=field_4_cell_ranges.size(); i++)
{
LittleEndian.putShort(data, 18 + 0 + 8 * i + offset,
(short) ((CellRange) field_4_cell_ranges.get(i)).getFirstRow());
LittleEndian.putShort(data, 18 + 2 + 8 * i + offset,
(short) ((CellRange) field_4_cell_ranges.get(i)).getLastRow());
LittleEndian.putShort(data, 18 + 4 + 8 * i + offset,
(short) ((CellRange) field_4_cell_ranges.get(i)).getFirstColumn());
LittleEndian.putShort(data, 18 + 6 + 8 * i + offset,
(short) ((CellRange) field_4_cell_ranges.get(i)).getLastColumn());
}
return getRecordSize();
}
public int getRecordSize()
{
return 18+8*field_4_cell_ranges.size();
}
/**
* called by constructor, should throw runtime exception in the event of a
* record passed with a differing ID.
*
* @param id alleged id for this record
*/
protected void validateSid(short id)
{
if (id != sid)
{
throw new RecordFormatException(
"NOT A ConditionalFormattingHeaderRecord RECORD");
}
}
public short getSid()
{
return sid;
}
public Object clone()
{
CFHeaderRecord rec = new CFHeaderRecord();
rec.field_1_numcf = field_1_numcf;
rec.field_2_need_recalculation = field_2_need_recalculation;
rec.field_3_enclosing_cell_range = field_3_enclosing_cell_range;
rec.field_4_cell_ranges = new ArrayList(field_4_cell_ranges.size());
Iterator iterator = field_4_cell_ranges.iterator();
while (iterator.hasNext())
{
CellRange oldRange = (CellRange)iterator.next();
rec.field_4_cell_ranges.add(oldRange.cloneCellRange());
}
return rec;
}
}

657
src/java/org/apache/poi/hssf/record/CFRuleRecord.java Normal file
View File

@ -0,0 +1,657 @@
/* ====================================================================
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==================================================================== */
/*
* ConditionalFormattingRuleRecord.java
*
* Created on January 23, 2008, 9:56 AM
*/
package org.apache.poi.hssf.record;
import java.util.List;
import java.util.Stack;
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.record.formula.Ptg;
import org.apache.poi.util.BitField;
import org.apache.poi.util.BitFieldFactory;
import org.apache.poi.util.LittleEndian;
/**
* Conditional Formatting Rule Record.
* @author Dmitriy Kumshayev
*/
public class CFRuleRecord extends Record
{
public static final short sid = 0x01B1;
private byte field_1_condition_type;
public static final byte CONDITION_TYPE_NO_CONDITION_TYPE = 0;
public static final byte CONDITION_TYPE_CELL_VALUE_IS = 1;
public static final byte CONDITION_TYPE_FORMULA = 2;
private byte field_2_comparison_operator;
public static final byte COMPARISON_OPERATOR_NO_COMPARISON = 0;
public static final byte COMPARISON_OPERATOR_BETWEEN = 1;
public static final byte COMPARISON_OPERATOR_NOT_BETWEEN = 2;
public static final byte COMPARISON_OPERATOR_EQUAL = 3;
public static final byte COMPARISON_OPERATOR_NOT_EQUAL = 4;
public static final byte COMPARISON_OPERATOR_GT = 5;
public static final byte COMPARISON_OPERATOR_LT = 6;
public static final byte COMPARISON_OPERATOR_GE = 7;
public static final byte COMPARISON_OPERATOR_LE = 8;
private short field_3_formula1_len;
private short field_4_formula2_len;
private int field_5_options;
private static final BitField modificationBits = BitFieldFactory.getInstance(0x83FFFFFF); // Bits: font,align,bord,patt,prot
private static final BitField alignHor = BitFieldFactory.getInstance(0x00000001); // 0 = Horizontal alignment modified
private static final BitField alignVer = BitFieldFactory.getInstance(0x00000002); // 0 = Vertical alignment modified
private static final BitField alignWrap = BitFieldFactory.getInstance(0x00000004); // 0 = Text wrapped flag modified
private static final BitField alignRot = BitFieldFactory.getInstance(0x00000008); // 0 = Text rotation modified
private static final BitField alignJustLast = BitFieldFactory.getInstance(0x00000010); // 0 = Justify last line flag modified
private static final BitField alignIndent = BitFieldFactory.getInstance(0x00000020); // 0 = Indentation modified
private static final BitField alignShrink = BitFieldFactory.getInstance(0x00000040); // 0 = Shrink to fit flag modified
private static final BitField notUsed1 = BitFieldFactory.getInstance(0x00000080); // Always 1
private static final BitField protLocked = BitFieldFactory.getInstance(0x00000100); // 0 = Cell locked flag modified
private static final BitField protHidden = BitFieldFactory.getInstance(0x00000200); // 0 = Cell hidden flag modified
private static final BitField bordLeft = BitFieldFactory.getInstance(0x00000400); // 0 = Left border style and colour modified
private static final BitField bordRight = BitFieldFactory.getInstance(0x00000800); // 0 = Right border style and colour modified
private static final BitField bordTop = BitFieldFactory.getInstance(0x00001000); // 0 = Top border style and colour modified
private static final BitField bordBot = BitFieldFactory.getInstance(0x00002000); // 0 = Bottom border style and colour modified
private static final BitField bordTlBr = BitFieldFactory.getInstance(0x00004000); // 0 = Top-left to bottom-right border flag modified
private static final BitField bordBlTr = BitFieldFactory.getInstance(0x00008000); // 0 = Bottom-left to top-right border flag modified
private static final BitField pattStyle = BitFieldFactory.getInstance(0x00010000); // 0 = Pattern style modified
private static final BitField pattCol = BitFieldFactory.getInstance(0x00020000); // 0 = Pattern colour modified
private static final BitField pattBgCol = BitFieldFactory.getInstance(0x00040000); // 0 = Pattern background colour modified
private static final BitField notUsed2 = BitFieldFactory.getInstance(0x00380000); // Always 111
private static final BitField undocumented = BitFieldFactory.getInstance(0x03C00000); // Undocumented bits
private static final BitField fmtBlockBits = BitFieldFactory.getInstance(0x7C000000); // Bits: font,align,bord,patt,prot
private static final BitField font = BitFieldFactory.getInstance(0x04000000); // 1 = Record contains font formatting block
private static final BitField align = BitFieldFactory.getInstance(0x08000000); // 1 = Record contains alignment formatting block
private static final BitField bord = BitFieldFactory.getInstance(0x10000000); // 1 = Record contains border formatting block
private static final BitField patt = BitFieldFactory.getInstance(0x20000000); // 1 = Record contains pattern formatting block
private static final BitField prot = BitFieldFactory.getInstance(0x40000000); // 1 = Record contains protection formatting block
private static final BitField alignTextDir = BitFieldFactory.getInstance(0x80000000); // 0 = Text direction modified
private short field_6_not_used;
private FontFormatting fontFormatting;
private byte field_8_align_text_break;
private byte field_9_align_text_rotation_angle;
private short field_10_align_indentation;
private short field_11_relative_indentation;
private short field_12_not_used;
private BorderFormatting borderFormatting;
private PatternFormatting patternFormatting;
private Stack field_17_formula1;
private Stack field_18_formula2;
/** Creates new CFRuleRecord */
public CFRuleRecord()
{
field_1_condition_type=CONDITION_TYPE_NO_CONDITION_TYPE;
field_2_comparison_operator=COMPARISON_OPERATOR_NO_COMPARISON;
setExpression1Length((short)0);
setExpression2Length((short)0);
// Set modification flags to 1: by default options are not modified
setOptions(modificationBits.setValue(field_5_options, -1));
// Set formatting block flags to 0 (no formatting blocks)
setOptions(fmtBlockBits.setValue(field_5_options, 0));
field_6_not_used = 0;
fontFormatting=null;
field_8_align_text_break = 0;
field_9_align_text_rotation_angle = 0;
field_10_align_indentation = 0;
field_11_relative_indentation = 0;
field_12_not_used = 0;
borderFormatting=null;
patternFormatting=null;
field_17_formula1=null;
field_18_formula2=null;
}
/**
* Constructs a Formula record and sets its fields appropriately.
* Note - id must be 0x06 (NOT 0x406 see MSKB #Q184647 for an
* "explanation of this bug in the documentation) or an exception
* will be throw upon validation
*
* @param in the RecordInputstream to read the record from
*/
public CFRuleRecord(RecordInputStream in)
{
super(in);
}
protected void fillFields(RecordInputStream in)
{
try {
field_1_condition_type = in.readByte();
field_2_comparison_operator = in.readByte();
field_3_formula1_len = in.readShort();
field_4_formula2_len = in.readShort();
field_5_options = in.readInt();
field_6_not_used = in.readShort();
if(containsFontFormattingBlock())
{
fontFormatting = new FontFormatting(in);
}
if(containsBorderFormattingBlock())
{
borderFormatting = new BorderFormatting(in);
}
if( containsPatternFormattingBlock())
{
patternFormatting = new PatternFormatting(in);
}
if(field_3_formula1_len>0)
{
field_17_formula1 = Ptg.createParsedExpressionTokens(field_3_formula1_len, in);
// Now convert any fields as required
field_17_formula1 = SharedFormulaRecord.convertSharedFormulas(
field_17_formula1, 0, 0
);
}
if(field_4_formula2_len>0)
{
field_18_formula2 = Ptg.createParsedExpressionTokens(field_4_formula2_len, in);
// Now convert any fields as required
field_18_formula2 = SharedFormulaRecord.convertSharedFormulas(
field_18_formula2, 0, 0
);
}
} catch (java.lang.UnsupportedOperationException uoe) {
throw new RecordFormatException(uoe);
}
}
public void setConditionType(byte conditionType)
{
field_1_condition_type =
conditionType == CONDITION_TYPE_CELL_VALUE_IS ?
CONDITION_TYPE_CELL_VALUE_IS :
CONDITION_TYPE_FORMULA;
}
public byte getConditionType()
{
return field_1_condition_type;
}
/**
* set the option flags
*
* @param options bitmask
*/
public void setOptions(int options)
{
field_5_options = options;
}
public boolean containsFontFormattingBlock()
{
return getOptionFlag(font);
}
public void setFontFormatting(FontFormatting fontFormatting)
{
this.fontFormatting = fontFormatting;
setOptionFlag(true,font);
}
public void setFontFormattingUnchanged()
{
setOptionFlag(false,font);
}
public boolean containsAlignFormattingBlock()
{
return getOptionFlag(align);
}
public void setAlignFormattingUnchanged()
{
setOptionFlag(false,align);
}
public boolean containsBorderFormattingBlock()
{
return getOptionFlag(bord);
}
public void setBorderFormatting(BorderFormatting borderFormatting)
{
this.borderFormatting = borderFormatting;
setOptionFlag(true,bord);
}
public void setBorderFormattingUnchanged()
{
setOptionFlag(false,bord);
}
public boolean containsPatternFormattingBlock()
{
return getOptionFlag(patt);
}
public void setPatternFormatting(PatternFormatting patternFormatting)
{
this.patternFormatting = patternFormatting;
setOptionFlag(true,patt);
}
public void setPatternFormattingUnchanged()
{
setOptionFlag(false,patt);
}
public boolean containsProtectionFormattingBlock()
{
return getOptionFlag(prot);
}
public void setProtectionFormattingUnchanged()
{
setOptionFlag(false,prot);
}
public void setComparisonOperation(byte operation)
{
field_2_comparison_operator = operation;
}
public byte getComparisonOperation()
{
return field_2_comparison_operator;
}
/**
* set the length (in number of tokens) of the expression 1
* @param len length
*/
private void setExpression1Length(short len)
{
field_3_formula1_len = len;
}
/**
* get the length (in number of tokens) of the expression 1
* @return expression length
*/
public short getExpression1Length()
{
return field_3_formula1_len;
}
/**
* set the length (in number of tokens) of the expression 2
* @param len length
*/
private void setExpression2Length(short len)
{
field_4_formula2_len = len;
}
/**
* get the length (in number of tokens) of the expression 2
* @return expression length
*/
public short getExpression2Length()
{
return field_4_formula2_len;
}
/**
* get the option flags
*
* @return bit mask
*/
public int getOptions()
{
return field_5_options;
}
private boolean isModified(BitField field)
{
return !field.isSet(field_5_options);
}
private void setModified(boolean modified, BitField field)
{
field_5_options = field.setBoolean(field_5_options, !modified);
}
public boolean isLeftBorderModified()
{
return isModified(bordLeft);
}
public void setLeftBorderModified(boolean modified)
{
setModified(modified,bordLeft);
}
public boolean isRightBorderModified()
{
return isModified(bordRight);
}
public void setRightBorderModified(boolean modified)
{
setModified(modified,bordRight);
}
public boolean isTopBorderModified()
{
return isModified(bordTop);
}
public void setTopBorderModified(boolean modified)
{
setModified(modified,bordTop);
}
public boolean isBottomBorderModified()
{
return isModified(bordBot);
}
public void setBottomBorderModified(boolean modified)
{
setModified(modified,bordBot);
}
public boolean isTopLeftBottomRightBorderModified()
{
return isModified(bordTlBr);
}
public void setTopLeftBottomRightBorderModified(boolean modified)
{
setModified(modified,bordTlBr);
}
public boolean isBottomLeftTopRightBorderModified()
{
return isModified(bordBlTr);
}
public void setBottomLeftTopRightBorderModified(boolean modified)
{
setModified(modified,bordBlTr);
}
public boolean isPatternStyleModified()
{
return isModified(pattStyle);
}
public void setPatternStyleModified(boolean modified)
{
setModified(modified,pattStyle);
}
public boolean isPatternColorModified()
{
return isModified(pattCol);
}
public void setPatternColorModified(boolean modified)
{
setModified(modified,pattCol);
}
public boolean isPatternBackgroundColorModified()
{
return isModified(pattBgCol);
}
public void setPatternBackgroundColorModified(boolean modified)
{
setModified(modified,pattBgCol);
}
private boolean getOptionFlag(BitField field)
{
return field.isSet(field_5_options);
}
private void setOptionFlag(boolean flag, BitField field)
{
field_5_options = field.setBoolean(field_5_options, flag);
}
/**
* get the stack of the 1st expression as a list
*
* @return list of tokens (casts stack to a list and returns it!)
* this method can return null is we are unable to create Ptgs from
* existing excel file
* callers should check for null!
*/
public List getParsedExpression1()
{
return field_17_formula1;
}
/**
* get the stack of the 2nd expression as a list
*
* @return list of tokens (casts stack to a list and returns it!)
* this method can return null is we are unable to create Ptgs from
* existing excel file
* callers should check for null!
*/
public List getParsedExpression2()
{
return field_18_formula2;
}
public void setParsedExpression1(Stack ptgs) {
setExpression1Length(getTotalPtgSize(field_17_formula1 = ptgs));
}
public void setParsedExpression2(Stack ptgs) {
setExpression1Length(getTotalPtgSize(field_18_formula2 = ptgs));
}
/**
* called by constructor, should throw runtime exception in the event of a
* record passed with a differing ID.
*
* @param id alleged id for this record
*/
protected void validateSid(short id)
{
if (id != sid)
{
throw new RecordFormatException("NOT A CFRULE RECORD");
}
}
public short getSid()
{
return sid;
}
/**
* called by the class that is responsible for writing this sucker.
* Subclasses should implement this so that their data is passed back in a
* byte array.
*
* @param offset to begin writing at
* @param data byte array containing instance data
* @return number of bytes written
*/
public int serialize(int offset, byte [] data)
{
int recordsize = getRecordSize();
LittleEndian.putShort(data, 0 + offset, sid);
LittleEndian.putShort(data, 2 + offset, (short)(recordsize-4));
data[4 + offset] = field_1_condition_type;
data[5 + offset] = field_2_comparison_operator;
LittleEndian.putShort(data, 6 + offset, field_3_formula1_len);
LittleEndian.putShort(data, 8 + offset, field_4_formula2_len);
LittleEndian.putInt(data, 10 + offset, field_5_options);
LittleEndian.putShort(data,14 + offset, field_6_not_used);
offset += 16;
if( containsFontFormattingBlock() )
{
byte[] fontFormattingRawRecord = fontFormatting.getRawRecord();
System.arraycopy(fontFormattingRawRecord, 0, data, offset, fontFormattingRawRecord.length);
offset += fontFormattingRawRecord.length;
}
if( containsBorderFormattingBlock())
{
offset += borderFormatting.serialize(offset, data);
}
if( containsPatternFormattingBlock() )
{
offset += patternFormatting.serialize(offset, data);
}
if (getExpression1Length()>0)
{
Ptg.serializePtgStack(this.field_17_formula1, data, offset);
offset += getExpression1Length();
}
if (getExpression2Length()>0)
{
Ptg.serializePtgStack(this.field_18_formula2, data, offset);
offset += getExpression2Length();
}
return recordsize;
}
public int getRecordSize()
{
int retval =16+
(containsFontFormattingBlock()?fontFormatting.getRawRecord().length:0)+
(containsBorderFormattingBlock()?8:0)+
(containsPatternFormattingBlock()?4:0)+
getExpression1Length()+
getExpression2Length()
;
return retval;
}
private short getTotalPtgSize(List list)
{
short retval = 0;
if( list!=null)
{
for (int k = 0; k < list.size(); k++)
{
Ptg ptg = ( Ptg ) list.get(k);
retval += ptg.getSize();
}
}
return retval;
}
public String toString()
{
StringBuffer buffer = new StringBuffer();
buffer.append("[CFRULE]\n");
if( containsFontFormattingBlock())
{
buffer.append(fontFormatting.toString());
}
if( containsBorderFormattingBlock())
{
buffer.append(borderFormatting.toString());
}
if( containsPatternFormattingBlock())
{
buffer.append(patternFormatting.toString());
}
buffer.append("[/CFRULE]\n");
return buffer.toString();
}
public Object clone() {
CFRuleRecord rec = new CFRuleRecord();
rec.field_1_condition_type= field_1_condition_type;
rec.field_2_comparison_operator = field_2_comparison_operator;
rec.field_3_formula1_len = field_3_formula1_len;
rec.field_4_formula2_len = field_4_formula2_len;
rec.field_5_options = field_5_options;
rec.field_6_not_used = field_6_not_used;
if( containsFontFormattingBlock())
{
rec.fontFormatting = (FontFormatting)fontFormatting.clone();
}
if( containsBorderFormattingBlock())
{
rec.borderFormatting = (BorderFormatting)borderFormatting.clone();
}
if( containsPatternFormattingBlock())
{
rec.patternFormatting = (PatternFormatting)patternFormatting.clone();
}
if( field_3_formula1_len>0)
{
rec.field_17_formula1 = (Stack)field_17_formula1.clone();
}
if( field_4_formula2_len>0)
{
rec.field_18_formula2 = (Stack)field_18_formula2.clone();
}
return rec;
}
public FontFormatting getFontFormatting()
{
return fontFormatting;
}
}

2
src/java/org/apache/poi/hssf/record/RecordFactory.java
View File

@ -82,6 +82,8 @@ public class RecordFactory
SupBookRecord.class,
CRNCountRecord.class,
CRNRecord.class,
CFHeaderRecord.class,
CFRuleRecord.class,
};
}
private static Map recordsMap = recordsToMap(records);

42
src/java/org/apache/poi/hssf/record/SharedFormulaRecord.java
View File

@ -180,19 +180,17 @@ public final class SharedFormulaRecord extends Record {
return ((getFirstRow() <= formulaRow) && (getLastRow() >= formulaRow) &&
(getFirstColumn() <= formulaColumn) && (getLastColumn() >= formulaColumn));
}
/** Creates a non shared formula from the shared formula counter part*/
public void convertSharedFormulaRecord(FormulaRecord formula) {
//Sanity checks
final int formulaRow = formula.getRow();
final int formulaColumn = formula.getColumn();
if (isFormulaInShared(formula)) {
formula.setExpressionLength(getExpressionLength());
/**
* Creates a non shared formula from the shared formula
* counter part
*/
protected static Stack convertSharedFormulas(Stack ptgs, int formulaRow, int formulaColumn) {
Stack newPtgStack = new Stack();
if (field_7_parsed_expr != null)
for (int k = 0; k < field_7_parsed_expr.size(); k++) {
Ptg ptg = (Ptg) field_7_parsed_expr.get(k);
if (ptgs != null)
for (int k = 0; k < ptgs.size(); k++) {
Ptg ptg = (Ptg) ptgs.get(k);
if (ptg instanceof RefNPtg) {
RefNPtg refNPtg = (RefNPtg)ptg;
ptg = new ReferencePtg(fixupRelativeRow(formulaRow,refNPtg.getRow(),refNPtg.isRowRelative()),
@ -243,7 +241,23 @@ public final class SharedFormulaRecord extends Record {
areaNAPtg.isLastColRelative());
}
newPtgStack.add(ptg);
}
}
return newPtgStack;
}
/**
* Creates a non shared formula from the shared formula
* counter part
*/
public void convertSharedFormulaRecord(FormulaRecord formula) {
//Sanity checks
final int formulaRow = formula.getRow();
final int formulaColumn = formula.getColumn();
if (isFormulaInShared(formula)) {
formula.setExpressionLength(getExpressionLength());
Stack newPtgStack =
convertSharedFormulas(field_7_parsed_expr, formulaRow, formulaColumn);
formula.setParsedExpression(newPtgStack);
//Now its not shared!
formula.setSharedFormula(false);
@ -252,7 +266,7 @@ public final class SharedFormulaRecord extends Record {
}
}
private int fixupRelativeColumn(int currentcolumn, int column, boolean relative) {
private static int fixupRelativeColumn(int currentcolumn, int column, boolean relative) {
if(relative) {
// mask out upper bits to produce 'wrapping' at column 256 ("IV")
return (column + currentcolumn) & 0x00FF;
@ -260,7 +274,7 @@ public final class SharedFormulaRecord extends Record {
return column;
}
private int fixupRelativeRow(int currentrow, int row, boolean relative) {
private static int fixupRelativeRow(int currentrow, int row, boolean relative) {
if(relative) {
// mask out upper bits to produce 'wrapping' at row 65536
return (row+currentrow) & 0x00FFFF;

224
src/java/org/apache/poi/hssf/record/aggregates/CFRecordsAggregate.java Normal file
View File

@ -0,0 +1,224 @@
/* ====================================================================
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==================================================================== */
package org.apache.poi.hssf.record.aggregates;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.apache.poi.hssf.record.CFHeaderRecord;
import org.apache.poi.hssf.record.CFRuleRecord;
import org.apache.poi.hssf.record.Record;
import org.apache.poi.hssf.record.RecordInputStream;
import org.apache.poi.util.POILogFactory;
import org.apache.poi.util.POILogger;
/**
* CFRecordsAggregate - aggregates Conditional Formatting records CFHeaderRecord
* and number of up to three CFRuleRecord records together to simplify
* access to them.
*
* @author Dmitriy Kumshayev
*
*/
public class CFRecordsAggregate extends Record
{
public final static short sid = -2008;
private static POILogger log = POILogFactory.getLogger(CFRecordsAggregate.class);
private CFHeaderRecord header;
// List of CFRuleRecord objects
private List rules;
public CFRecordsAggregate()
{
header = null;
rules = new ArrayList(3);
}
/**
* Create CFRecordsAggregate from a list of CF Records
* @param recs - list of {@link Record} objects
* @param offset - position of {@link CFHeaderRecord} object in the list of Record objects
* @return CFRecordsAggregate object
*/
public static CFRecordsAggregate createCFAggregate(List recs, int offset)
{
CFRecordsAggregate cfRecords = new CFRecordsAggregate();
ArrayList records = new ArrayList(4);
int count = 0;
Record rec = ( Record ) recs.get(offset++);
if (rec.getSid() == CFHeaderRecord.sid)
{
records.add(rec);
cfRecords.header = (CFHeaderRecord)rec;
int nRules = cfRecords.header.getNumberOfConditionalFormats();
int rulesCount = 0;
while( offset<recs.size() &&
(rec = (Record)recs.get(offset++)).getSid() == CFRuleRecord.sid &&
rec instanceof CFRuleRecord &&
rulesCount++ < nRules
)
{
records.add(rec);
cfRecords.rules.add(rec);
}
if (nRules != cfRecords.rules.size())
{
if (log.check(POILogger.DEBUG))
{
log.log(POILogger.DEBUG, "Expected " + nRules + " Conditional Formats, "
+ "but found " + cfRecords.rules.size() + " rules");
}
cfRecords.header.setNumberOfConditionalFormats(nRules);
}
}
return cfRecords;
}
/**
* Create a deep clone of the record
* @return
*/
public CFRecordsAggregate cloneCFAggregate()
{
ArrayList records = new ArrayList(this.rules.size()+1);
records.add(this.header.clone());
for (int i=0; i<this.rules.size();i++)
{
Record rec = (Record)((Record)this.rules.get(i)).clone();
records.add(rec);
}
return createCFAggregate(records, 0);
}
/** You never fill an aggregate */
protected void fillFields(RecordInputStream in)
{
}
public short getSid()
{
return sid;
}
/**
* called by the class that is responsible for writing this sucker.
* Subclasses should implement this so that their data is passed back in a
* byte array.
*
* @param offset to begin writing at
* @param data byte array containing instance data
* @return number of bytes written
*/
public int serialize(int offset, byte[] data)
{
int pos = offset;
if( header != null && rules.size()>0 )
{
header.setNumberOfConditionalFormats(rules.size());
pos += (( Record ) header).serialize(pos, data);
for(Iterator itr = rules.iterator(); itr.hasNext();)
{
pos += (( Record ) itr.next()).serialize(pos, data);
}
}
return pos - offset;
}
protected void validateSid(short id)
{
// do nothing here
}
/**
* @return the header
*/
public CFHeaderRecord getHeader()
{
return header;
}
/**
* @return the rules
*/
public List getRules()
{
return rules;
}
/**
* @return sum of sizes of all aggregated records
*/
public int getRecordSize()
{
int size = 0;
if( header != null)
{
size += header.getRecordSize();
}
if( rules != null)
{
for(Iterator irecs = rules.iterator(); irecs.hasNext(); )
{
size += (( Record ) irecs.next()).getRecordSize();
}
}
return size;
}
/**
* String representation of CFRecordsAggregate
*/
public String toString()
{
StringBuffer buffer = new StringBuffer();
buffer.append("[CF]\n");
if( header != null )
{
buffer.append(header.toString());
}
if( rules != null )
{
for(int i=0; i<rules.size(); i++)
{
CFRuleRecord cfRule = (CFRuleRecord)rules.get(i);
if(cfRule!=null)
{
buffer.append(cfRule.toString());
}
}
}
buffer.append("[/CF]\n");
return buffer.toString();
}
}

560
src/java/org/apache/poi/hssf/record/cf/BorderFormatting.java Normal file
View File

@ -0,0 +1,560 @@
/* ====================================================================
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==================================================================== */
/*
* FontFormatting.java
*
* Created on January 22, 2008, 10:05 PM
*/
package org.apache.poi.hssf.record.cf;
import org.apache.poi.hssf.record.RecordInputStream;
import org.apache.poi.util.BitField;
import org.apache.poi.util.BitFieldFactory;
import org.apache.poi.util.LittleEndian;
/**
* Border Formatting Block of the Conditional Formatting Rule Record.
*
* @author Dmitriy Kumshayev
*/
public class BorderFormatting
{
/**
* No border
*/
public final static short BORDER_NONE = 0x0;
/**
* Thin border
*/
public final static short BORDER_THIN = 0x1;
/**
* Medium border
*/
public final static short BORDER_MEDIUM = 0x2;
/**
* dash border
*/
public final static short BORDER_DASHED = 0x3;
/**
* dot border
*/
public final static short BORDER_HAIR = 0x4;
/**
* Thick border
*/
public final static short BORDER_THICK = 0x5;
/**
* double-line border
*/
public final static short BORDER_DOUBLE = 0x6;
/**
* hair-line border
*/
public final static short BORDER_DOTTED = 0x7;
/**
* Medium dashed border
*/
public final static short BORDER_MEDIUM_DASHED = 0x8;
/**
* dash-dot border
*/
public final static short BORDER_DASH_DOT = 0x9;
/**
* medium dash-dot border
*/
public final static short BORDER_MEDIUM_DASH_DOT = 0xA;
/**
* dash-dot-dot border
*/
public final static short BORDER_DASH_DOT_DOT = 0xB;
/**
* medium dash-dot-dot border
*/
public final static short BORDER_MEDIUM_DASH_DOT_DOT = 0xC;
/**
* slanted dash-dot border
*/
public final static short BORDER_SLANTED_DASH_DOT = 0xD;
public BorderFormatting()
{
field_13_border_styles1 = (short)0;
field_14_border_styles2 = (short)0;
}
/** Creates new FontFormatting */
public BorderFormatting(RecordInputStream in)
{
field_13_border_styles1 = in.readInt();
field_14_border_styles2 = in.readInt();
}
// BORDER FORMATTING BLOCK
// For Border Line Style codes see HSSFCellStyle.BORDER_XXXXXX
private int field_13_border_styles1;
private static final BitField bordLeftLineStyle = BitFieldFactory.getInstance(0x0000000F);
private static final BitField bordRightLineStyle = BitFieldFactory.getInstance(0x000000F0);
private static final BitField bordTopLineStyle = BitFieldFactory.getInstance(0x00000F00);
private static final BitField bordBottomLineStyle= BitFieldFactory.getInstance(0x0000F000);
private static final BitField bordLeftLineColor = BitFieldFactory.getInstance(0x007F0000);
private static final BitField bordRightLineColor = BitFieldFactory.getInstance(0x3F800000);
private static final BitField bordTlBrLineOnOff = BitFieldFactory.getInstance(0x40000000);
private static final BitField bordBlTrtLineOnOff = BitFieldFactory.getInstance(0x80000000);
private int field_14_border_styles2;
private static final BitField bordTopLineColor = BitFieldFactory.getInstance(0x0000007F);
private static final BitField bordBottomLineColor= BitFieldFactory.getInstance(0x00003f80);
private static final BitField bordDiagLineColor = BitFieldFactory.getInstance(0x001FC000);
private static final BitField bordDiagLineStyle = BitFieldFactory.getInstance(0x01E00000);
/**
* set the type of border to use for the left border of the cell
* @param border type
* @see #BORDER_NONE
* @see #BORDER_THIN
* @see #BORDER_MEDIUM
* @see #BORDER_DASHED
* @see #BORDER_DOTTED
* @see #BORDER_THICK
* @see #BORDER_DOUBLE
* @see #BORDER_HAIR
* @see #BORDER_MEDIUM_DASHED
* @see #BORDER_DASH_DOT
* @see #BORDER_MEDIUM_DASH_DOT
* @see #BORDER_DASH_DOT_DOT
* @see #BORDER_MEDIUM_DASH_DOT_DOT
* @see #BORDER_SLANTED_DASH_DOT
*/
public void setBorderLeft(short border)
{
field_13_border_styles1 = bordLeftLineStyle.setValue(field_13_border_styles1, border);
}
/**
* get the type of border to use for the left border of the cell
* @return border type
* @see #BORDER_NONE
* @see #BORDER_THIN
* @see #BORDER_MEDIUM
* @see #BORDER_DASHED
* @see #BORDER_DOTTED
* @see #BORDER_THICK
* @see #BORDER_DOUBLE
* @see #BORDER_HAIR
* @see #BORDER_MEDIUM_DASHED
* @see #BORDER_DASH_DOT
* @see #BORDER_MEDIUM_DASH_DOT
* @see #BORDER_DASH_DOT_DOT
* @see #BORDER_MEDIUM_DASH_DOT_DOT
* @see #BORDER_SLANTED_DASH_DOT
*/
public short getBorderLeft()
{
return (short)bordLeftLineStyle.getValue(field_13_border_styles1);
}
/**
* set the type of border to use for the right border of the cell
* @param border type
* @see #BORDER_NONE
* @see #BORDER_THIN
* @see #BORDER_MEDIUM
* @see #BORDER_DASHED
* @see #BORDER_DOTTED
* @see #BORDER_THICK
* @see #BORDER_DOUBLE
* @see #BORDER_HAIR
* @see #BORDER_MEDIUM_DASHED
* @see #BORDER_DASH_DOT
* @see #BORDER_MEDIUM_DASH_DOT
* @see #BORDER_DASH_DOT_DOT
* @see #BORDER_MEDIUM_DASH_DOT_DOT
* @see #BORDER_SLANTED_DASH_DOT
*/
public void setBorderRight(short border)
{
field_13_border_styles1 = bordRightLineStyle.setValue(field_13_border_styles1, border);
}
/**
* get the type of border to use for the right border of the cell
* @return border type
* @see #BORDER_NONE
* @see #BORDER_THIN
* @see #BORDER_MEDIUM
* @see #BORDER_DASHED
* @see #BORDER_DOTTED
* @see #BORDER_THICK
* @see #BORDER_DOUBLE
* @see #BORDER_HAIR
* @see #BORDER_MEDIUM_DASHED
* @see #BORDER_DASH_DOT
* @see #BORDER_MEDIUM_DASH_DOT
* @see #BORDER_DASH_DOT_DOT
* @see #BORDER_MEDIUM_DASH_DOT_DOT
* @see #BORDER_SLANTED_DASH_DOT
*/
public short getBorderRight()
{
return (short)bordRightLineStyle.getValue(field_13_border_styles1);
}
/**
* set the type of border to use for the top border of the cell
* @param border type
* @see #BORDER_NONE
* @see #BORDER_THIN
* @see #BORDER_MEDIUM
* @see #BORDER_DASHED
* @see #BORDER_DOTTED
* @see #BORDER_THICK
* @see #BORDER_DOUBLE
* @see #BORDER_HAIR
* @see #BORDER_MEDIUM_DASHED
* @see #BORDER_DASH_DOT
* @see #BORDER_MEDIUM_DASH_DOT
* @see #BORDER_DASH_DOT_DOT
* @see #BORDER_MEDIUM_DASH_DOT_DOT
* @see #BORDER_SLANTED_DASH_DOT
*/
public void setBorderTop(short border)
{
field_13_border_styles1 = bordTopLineStyle.setValue(field_13_border_styles1, border);
}
/**
* get the type of border to use for the top border of the cell
* @return border type
* @see #BORDER_NONE
* @see #BORDER_THIN
* @see #BORDER_MEDIUM
* @see #BORDER_DASHED
* @see #BORDER_DOTTED
* @see #BORDER_THICK
* @see #BORDER_DOUBLE
* @see #BORDER_HAIR
* @see #BORDER_MEDIUM_DASHED
* @see #BORDER_DASH_DOT
* @see #BORDER_MEDIUM_DASH_DOT
* @see #BORDER_DASH_DOT_DOT
* @see #BORDER_MEDIUM_DASH_DOT_DOT
* @see #BORDER_SLANTED_DASH_DOT
*/
public short getBorderTop()
{
return (short)bordTopLineStyle.getValue(field_13_border_styles1);
}
/**
* set the type of border to use for the bottom border of the cell
* @param border type
* @see #BORDER_NONE
* @see #BORDER_THIN
* @see #BORDER_MEDIUM
* @see #BORDER_DASHED
* @see #BORDER_DOTTED
* @see #BORDER_THICK
* @see #BORDER_DOUBLE
* @see #BORDER_HAIR
* @see #BORDER_MEDIUM_DASHED
* @see #BORDER_DASH_DOT
* @see #BORDER_MEDIUM_DASH_DOT
* @see #BORDER_DASH_DOT_DOT
* @see #BORDER_MEDIUM_DASH_DOT_DOT
* @see #BORDER_SLANTED_DASH_DOT
*/
public void setBorderBottom(short border)
{
field_13_border_styles1 = bordBottomLineStyle.setValue(field_13_border_styles1, border);
}
/**
* get the type of border to use for the bottom border of the cell
* @return border type
* @see #BORDER_NONE
* @see #BORDER_THIN
* @see #BORDER_MEDIUM
* @see #BORDER_DASHED
* @see #BORDER_DOTTED
* @see #BORDER_THICK
* @see #BORDER_DOUBLE
* @see #BORDER_HAIR
* @see #BORDER_MEDIUM_DASHED
* @see #BORDER_DASH_DOT
* @see #BORDER_MEDIUM_DASH_DOT
* @see #BORDER_DASH_DOT_DOT
* @see #BORDER_MEDIUM_DASH_DOT_DOT
* @see #BORDER_SLANTED_DASH_DOT
*/
public short getBorderBottom()
{
return (short)bordBottomLineStyle.getValue(field_13_border_styles1);
}
/**
* set the type of border to use for the diagonal border of the cell
* @param border type
* @see #BORDER_NONE
* @see #BORDER_THIN
* @see #BORDER_MEDIUM
* @see #BORDER_DASHED
* @see #BORDER_DOTTED
* @see #BORDER_THICK
* @see #BORDER_DOUBLE
* @see #BORDER_HAIR
* @see #BORDER_MEDIUM_DASHED
* @see #BORDER_DASH_DOT
* @see #BORDER_MEDIUM_DASH_DOT
* @see #BORDER_DASH_DOT_DOT
* @see #BORDER_MEDIUM_DASH_DOT_DOT
* @see #BORDER_SLANTED_DASH_DOT
*/
public void setBorderDiagonal(short border)
{
field_14_border_styles2 = bordDiagLineStyle.setValue(field_14_border_styles2, border);
}
/**
* get the type of border to use for the diagonal border of the cell
* @return border type
* @see #BORDER_NONE
* @see #BORDER_THIN
* @see #BORDER_MEDIUM
* @see #BORDER_DASHED
* @see #BORDER_DOTTED
* @see #BORDER_THICK
* @see #BORDER_DOUBLE
* @see #BORDER_HAIR
* @see #BORDER_MEDIUM_DASHED
* @see #BORDER_DASH_DOT
* @see #BORDER_MEDIUM_DASH_DOT
* @see #BORDER_DASH_DOT_DOT
* @see #BORDER_MEDIUM_DASH_DOT_DOT
* @see #BORDER_SLANTED_DASH_DOT
*/
public short getBorderDiagonal()
{
return (short)bordDiagLineStyle.getValue(field_14_border_styles2);
}
/**
* set the color to use for the left border
* @param color The index of the color definition
*/
public void setLeftBorderColor(short color)
{
field_13_border_styles1 = bordLeftLineColor.setValue(field_13_border_styles1, color);
}
/**
* get the color to use for the left border
* @see org.apache.poi.hssf.usermodel.HSSFPalette#getColor(short)
* @param color The index of the color definition
*/
public short getLeftBorderColor()
{
return (short)bordLeftLineColor.getValue(field_13_border_styles1);
}
/**
* set the color to use for the right border
* @param color The index of the color definition
*/
public void setRightBorderColor(short color)
{
field_13_border_styles1 = bordRightLineColor.setValue(field_13_border_styles1, color);
}
/**
* get the color to use for the right border
* @see org.apache.poi.hssf.usermodel.HSSFPalette#getColor(short)
* @param color The index of the color definition
*/
public short getRightBorderColor()
{
return (short)bordRightLineColor.getValue(field_13_border_styles1);
}
/**
* set the color to use for the top border
* @param color The index of the color definition
*/
public void setTopBorderColor(short color)
{
field_14_border_styles2 = bordTopLineColor.setValue(field_14_border_styles2, color);
}
/**
* get the color to use for the top border
* @see org.apache.poi.hssf.usermodel.HSSFPalette#getColor(short)
* @param color The index of the color definition
*/
public short getTopBorderColor()
{
return (short)bordTopLineColor.getValue(field_14_border_styles2);
}
/**
* set the color to use for the bottom border
* @param color The index of the color definition
*/
public void setBottomBorderColor(short color)
{
field_14_border_styles2 = bordBottomLineColor.setValue(field_14_border_styles2, color);
}
/**
* get the color to use for the bottom border
* @see org.apache.poi.hssf.usermodel.HSSFPalette#getColor(short)
* @param color The index of the color definition
*/
public short getBottomBorderColor()
{
return (short)bordBottomLineColor.getValue(field_14_border_styles2);
}
/**
* set the color to use for the diagonal borders
* @param color The index of the color definition
*/
public void setDiagonalBorderColor(short color)
{
field_14_border_styles2 = bordDiagLineColor.setValue(field_14_border_styles2, color);
}
/**
* get the color to use for the diagonal border
* @see org.apache.poi.hssf.usermodel.HSSFPalette#getColor(short)
* @param color The index of the color definition
*/
public short getDiagonalBorderColor()
{
return (short)bordDiagLineColor.getValue(field_14_border_styles2);
}
/**
* Of/off bottom left to top right line
*
* @param on - if true - on, otherwise off
*/
public void setForwardDiagonalOn(boolean on)
{
field_13_border_styles1 = bordBlTrtLineOnOff.setBoolean(field_13_border_styles1, on);
}
/**
* Of/off top left to bottom right line
*
* @param on - if true - on, otherwise off
*/
public void setBackwardDiagonalOn(boolean on)
{
field_13_border_styles1 = bordTlBrLineOnOff.setBoolean(field_13_border_styles1, on);
}
/**
* @return true if forward diagonal is on
*/
public boolean isForwardDiagonalOn()
{
return bordBlTrtLineOnOff.isSet(field_13_border_styles1);
}
/**
* @return true if backward diagonal is on
*/
public boolean isBackwardDiagonalOn()
{
return bordTlBrLineOnOff.isSet(field_13_border_styles1);
}
public String toString()
{
StringBuffer buffer = new StringBuffer();
buffer.append(" [Border Formatting]\n");
buffer.append(" .lftln = ").append(Integer.toHexString(getBorderLeft())).append("\n");
buffer.append(" .rgtln = ").append(Integer.toHexString(getBorderRight())).append("\n");
buffer.append(" .topln = ").append(Integer.toHexString(getBorderTop())).append("\n");
buffer.append(" .btmln = ").append(Integer.toHexString(getBorderBottom())).append("\n");
buffer.append(" .leftborder= ").append(Integer.toHexString(getLeftBorderColor())).append("\n");
buffer.append(" .rghtborder= ").append(Integer.toHexString(getRightBorderColor())).append("\n");
buffer.append(" .topborder= ").append(Integer.toHexString(getTopBorderColor())).append("\n");
buffer.append(" .bottomborder= ").append(Integer.toHexString(getBottomBorderColor())).append("\n");
buffer.append(" .fwdiag= ").append(isForwardDiagonalOn()).append("\n");
buffer.append(" .bwdiag= ").append(isBackwardDiagonalOn()).append("\n");
buffer.append(" [/Border Formatting]\n");
return buffer.toString();
}
public Object clone()
{
BorderFormatting rec = new BorderFormatting();
rec.field_13_border_styles1 = field_13_border_styles1;
rec.field_14_border_styles2 = field_14_border_styles2;
return rec;
}
public int serialize(int offset, byte [] data)
{
LittleEndian.putInt(data, offset, field_13_border_styles1);
offset += 4;
LittleEndian.putInt(data, offset, field_14_border_styles2);
offset += 4;
return 8;
}
}

259
src/java/org/apache/poi/hssf/record/cf/CellRange.java Normal file
View File

@ -0,0 +1,259 @@
/* ====================================================================
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==================================================================== */
package org.apache.poi.hssf.record.cf;
/**
* CellRange.java
* Created on January 22, 2008, 10:05 PM
*
* @author Dmitriy Kumshayev
*/
public class CellRange
{
private int field_1_first_row;
private int field_2_last_row;
private short field_3_first_column;
private short field_4_last_column;
public CellRange(int firstRow, int lastRow, short firstColumn, short lastColumn)
{
this.field_1_first_row = firstRow;
this.field_2_last_row = lastRow;
this.field_3_first_column = firstColumn;
this.field_4_last_column = lastColumn;
validateRegion();
}
private void validateRegion()
{
if( field_1_first_row < 0 ||
field_2_last_row < -1 ||
field_3_first_column < 0 ||
field_4_last_column < -1 ||
field_2_last_row>=0 && field_2_last_row<field_1_first_row ||
field_4_last_column>=0 && field_4_last_column<field_3_first_column
)
{
throw new IllegalArgumentException("Invalid cell region "+toString());
}
}
public int getFirstRow()
{
return field_1_first_row;
}
private void setFirstRow(int firstRow)
{
this.field_1_first_row = firstRow;
}
public int getLastRow()
{
return field_2_last_row;
}
private void setLastRow(int lastRow)
{
this.field_2_last_row = lastRow;
}
public short getFirstColumn()
{
return field_3_first_column;
}
private void setFirstColumn(short firstColumn)
{
this.field_3_first_column = firstColumn;
}
public short getLastColumn()
{
return field_4_last_column;
}
private void setLastColumn(short lastColumn)
{
this.field_4_last_column = lastColumn;
}
public static final int NO_INTERSECTION = 1;
public static final int OVERLAP = 2;
public static final int INSIDE = 3;
public static final int ENCLOSES = 4;
/**
* Intersect this range with the specified range.
*
* @param another - the specified range
* @return code which reflects how the specified range is related to this range.<br/>
* Possible return codes are:
* NO_INTERSECTION - the specified range is outside of this range;<br/>
* OVERLAP - both ranges partially overlap;<br/>
* INSIDE - the specified range is inside of this one<br/>
* ENCLOSES - the specified range encloses this range<br/>
*/
public int intersect(CellRange another )
{
int firstRow = another.getFirstRow();
int lastRow = another.getLastRow();
short firstCol = another.getFirstColumn();
short lastCol = another.getLastColumn();
if
(
gt(this.getFirstRow(),lastRow) ||
lt(this.getLastRow(),firstRow) ||
gt(this.getFirstColumn(),lastCol) ||
lt(this.getLastColumn(),firstCol)
)
{
return NO_INTERSECTION;
}
else if( this.contains(another) )
{
return INSIDE;
}
else if( another.contains(this) )
{
return ENCLOSES;
}
else
{
return OVERLAP;
}
}
/**
* Check if the specified range is located inside of this cell range.
*
* @param range
* @return true if this cell range contains the argument range inside if it's area
*/
public boolean contains(CellRange range)
{
int firstRow = range.getFirstRow();
int lastRow = range.getLastRow();
short firstCol = range.getFirstColumn();
short lastCol = range.getLastColumn();
return le(this.getFirstRow(), firstRow) && ge(this.getLastRow(), lastRow)
&& le(this.getFirstColumn(), firstCol) && ge(this.getLastColumn(), lastCol);
}
public boolean contains(int row, short column)
{
return le(this.getFirstRow(), row) && ge(this.getLastRow(), row)
&& le(this.getFirstColumn(), column) && ge(this.getLastColumn(), column);
}
/**
* Check if the specified cell range has a shared border with the current range.
*
* @return true if the ranges have a shared border.
*/
public boolean hasSharedBorder(CellRange range)
{
int firstRow = range.getFirstRow();
int lastRow = range.getLastRow();
short firstCol = range.getFirstColumn();
short lastCol = range.getLastColumn();
return
(this.getFirstRow()>0 && this.getFirstRow() - 1 == lastRow || firstRow>0 &&this.getLastRow() == firstRow -1)&&
(this.getFirstColumn() == firstCol) &&
(this.getLastColumn() == lastCol) ||
(this.getFirstColumn()>0 && this.getFirstColumn() - 1 == lastCol || firstCol>0 && this.getLastColumn() == firstCol -1) &&
(this.getFirstRow() == firstRow) &&
(this.getLastRow() == lastRow)
;
}
/**
* Create an enclosing CellRange for the two cell ranges.
*
* @return enclosing CellRange
*/
public CellRange createEnclosingCellRange(CellRange range)
{
if( range == null)
{
return cloneCellRange();
}
else
{
CellRange cellRange =
new CellRange(
lt(range.getFirstRow(),getFirstRow())?range.getFirstRow():getFirstRow(),
gt(range.getLastRow(),getLastRow())?range.getLastRow():getLastRow(),
lt(range.getFirstColumn(),getFirstColumn())?range.getFirstColumn():getFirstColumn(),
gt(range.getLastColumn(),getLastColumn())?range.getLastColumn():getLastColumn()
);
return cellRange;
}
}
public CellRange cloneCellRange()
{
return new CellRange(getFirstRow(),getLastRow(),getFirstColumn(),getLastColumn());
}
/**
* Copy data from antother cell range to this cell range
* @param cr - another cell range
*/
public void setCellRange(CellRange cr)
{
setFirstRow(cr.getFirstRow());
setLastRow(cr.getLastRow());
setFirstColumn(cr.getFirstColumn());
setLastColumn(cr.getLastColumn());
}
/**
* @return true if a < b
*/
private static boolean lt(int a, int b)
{
return a == -1 ? false : (b == -1 ? true : a < b);
}
/**
* @return true if a <= b
*/
private static boolean le(int a, int b)
{
return a == b || lt(a,b);
}
/**
* @return true if a > b
*/
private static boolean gt(int a, int b)
{
return lt(b,a);
}
/**
* @return true if a >= b
*/
private static boolean ge(int a, int b)
{
return !lt(a,b);
}
public String toString()
{
return "("+this.getFirstRow()+","+this.getLastRow()+","+this.getFirstColumn()+","+this.getLastColumn()+")";
}
}

591
src/java/org/apache/poi/hssf/record/cf/FontFormatting.java Normal file
View File

@ -0,0 +1,591 @@
/* ====================================================================
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==================================================================== */
package org.apache.poi.hssf.record.cf;
import org.apache.poi.hssf.record.RecordInputStream;
import org.apache.poi.util.BitField;
import org.apache.poi.util.BitFieldFactory;
import org.apache.poi.util.LittleEndian;
/**
* Font Formatting Block of the Conditional Formatting Rule Record.
*
* Created on January 22, 2008, 10:05 PM
*
* @author Dmitriy Kumshayev
*/
public class FontFormatting
{
private byte [] record;
private static final int OFFSET_FONT_NAME = 0;
private static final int OFFSET_FONT_HEIGHT = 64;
private static final int OFFSET_FONT_OPTIONS = 68;
private static final int OFFSET_FONT_WEIGHT = 72;
private static final int OFFSET_ESCAPEMENT_TYPE = 74;
private static final int OFFSET_UNDERLINE_TYPE = 76;
private static final int OFFSET_FONT_COLOR_INDEX = 80;
private static final int OFFSET_OPTION_FLAGS = 88;
private static final int OFFSET_ESCAPEMENT_TYPE_MODIFIED = 92;
private static final int OFFSET_UNDERLINE_TYPE_MODIFIED = 96;
private static final int OFFSET_NOT_USED1 = 100;
private static final int OFFSET_NOT_USED2 = 104;
private static final int OFFSET_FONT_FORMATING_END = 116;
public final static int FONT_CELL_HEIGHT_PRESERVED = 0xFFFFFFFF;
// FONT OPTIONS MASKS
private static final BitField posture = BitFieldFactory.getInstance(0x00000002);
private static final BitField outline = BitFieldFactory.getInstance(0x00000008);
private static final BitField shadow = BitFieldFactory.getInstance(0x00000010);
private static final BitField condense = BitFieldFactory.getInstance(0x00000020);
private static final BitField cancellation = BitFieldFactory.getInstance(0x00000080);
// OPTION FLAGS MASKS
private static final BitField styleModified = BitFieldFactory.getInstance(0x00000002);
private static final BitField outlineModified = BitFieldFactory.getInstance(0x00000008);
private static final BitField shadowModified = BitFieldFactory.getInstance(0x00000010);
private static final BitField condenseModified = BitFieldFactory.getInstance(0x00000020);
private static final BitField cancellationModified = BitFieldFactory.getInstance(0x00000080);
/**
* Escapement type - None
*/
public final static short SS_NONE = 0;
/**
* Escapement type - Superscript
*/
public final static short SS_SUPER = 1;
/**
* Escapement type - Subscript
*/
public final static short SS_SUB = 2;
/**
* Underline type - None
*/
public final static byte U_NONE = 0;
/**
* Underline type - Single
*/
public final static byte U_SINGLE = 1;
/**
* Underline type - Double
*/
public final static byte U_DOUBLE = 2;
/**
* Underline type - Single Accounting
*/
public final static byte U_SINGLE_ACCOUNTING = 0x21;
/**
* Underline type - Double Accounting
*/
public final static byte U_DOUBLE_ACCOUNTING = 0x22;
/**
* Normal boldness (not bold)
*/
protected final static short FONT_WEIGHT_NORMAL = 0x190;
/**
* Bold boldness (bold)
*/
protected final static short FONT_WEIGHT_BOLD = 0x2bc;
public FontFormatting()
{
this(new byte[118]);
this.setFontHeight((short)-1);
this.setItalic(false);
this.setBold(false);
this.setOutline(false);
this.setShadow(false);
this.setCondense(false);
this.setStrikeout(false);
this.setEscapementType((short)0);
this.setUnderlineType((byte)0);
this.setFontColorIndex((short)-1);
this.setFontStyleModified(false);
this.setFontOutlineModified(false);
this.setFontShadowModified(false);
this.setFontCondenseModified(false);
this.setFontCancellationModified(false);
this.setEscapementTypeModified(false);
this.setUnderlineTypeModified(false);
LittleEndian.putShort(record, OFFSET_FONT_NAME, (short)0);
LittleEndian.putInt(record, OFFSET_NOT_USED1, 0x00000001);
LittleEndian.putInt(record, OFFSET_NOT_USED2, 0x00000001);
LittleEndian.putShort(record, OFFSET_FONT_FORMATING_END, (short)0x0001);
}
/** Creates new FontFormatting */
private FontFormatting(byte[] record)
{
this.record = record;
}
/** Creates new FontFormatting */
public FontFormatting(RecordInputStream in)
{
record = new byte[118];
for (int i = 0; i != record.length; i++)
{
record[i] = in.readByte();
}
}
public byte[] getRawRecord()
{
return record;
}
/**
* sets the height of the font in 1/20th point units
*
*
* @param height fontheight (in points/20); or -1 to preserve the cell font height
*/
public void setFontHeight(short height)
{
LittleEndian.putInt(record, OFFSET_FONT_HEIGHT, height);
}
/**
* gets the height of the font in 1/20th point units
*
* @return fontheight (in points/20); or -1 if not modified
*/
public short getFontHeight()
{
return (short) LittleEndian.getInt(record, OFFSET_FONT_HEIGHT);
}
private void setFontOption(boolean option, BitField field)
{
int options = LittleEndian.getInt(record,OFFSET_FONT_OPTIONS);
options = field.setBoolean(options, option);
LittleEndian.putInt(record,OFFSET_FONT_OPTIONS, options);
}
private boolean getFontOption(BitField field)
{
int options = LittleEndian.getInt(record,OFFSET_FONT_OPTIONS);
return field.isSet(options);
}
/**
* set the font to be italics or not
*
* @param italics - whether the font is italics or not
* @see #setAttributes(short)
*/
public void setItalic(boolean italic)
{
setFontOption(italic, posture);
}
/**
* get whether the font is to be italics or not
*
* @return italics - whether the font is italics or not
* @see #getAttributes()
*/
public boolean isItalic()
{
return getFontOption(posture);
}
public void setOutline(boolean on)
{
setFontOption(on, outline);
}
public boolean isOutlineOn()
{
return getFontOption(outline);
}
public void setShadow(boolean on)
{
setFontOption(on, shadow);
}
public boolean isShadowOn()
{
return getFontOption(shadow);
}
public void setCondense(boolean on)
{
setFontOption(on, condense);
}
public boolean isCondenseOn()
{
return getFontOption(condense);
}
/**
* set the font to be stricken out or not
*
* @param strike - whether the font is stricken out or not
*/
public void setStrikeout(boolean strike)
{
setFontOption(strike, cancellation);
}
/**
* get whether the font is to be stricken out or not
*
* @return strike - whether the font is stricken out or not
* @see #getAttributes()
*/
public boolean isStruckout()
{
return getFontOption(cancellation);
}
/**
* set the font weight (100-1000dec or 0x64-0x3e8). Default is
* 0x190 for normal and 0x2bc for bold
*
* @param bw - a number between 100-1000 for the fonts "boldness"
*/
private void setFontWeight(short bw)
{
if( bw<100) { bw=100; }
if( bw>1000){ bw=1000; }
LittleEndian.putShort(record,OFFSET_FONT_WEIGHT, bw);
}
/**
* set the font weight to bold (weight=700) or to normal(weight=400) boldness.
*
* @param bold - set font weight to bold if true; to normal otherwise
*/
public void setBold(boolean bold)
{
setFontWeight(bold?FONT_WEIGHT_BOLD:FONT_WEIGHT_NORMAL);
}
/**
* get the font weight for this font (100-1000dec or 0x64-0x3e8). Default is
* 0x190 for normal and 0x2bc for bold
*
* @return bw - a number between 100-1000 for the fonts "boldness"
*/
public short getFontWeight()
{
return LittleEndian.getShort(record,OFFSET_FONT_WEIGHT);
}
/**
* get whether the font weight is set to bold or not
*
* @return bold - whether the font is bold or not
*/
public boolean isBold()
{
return getFontWeight()==FONT_WEIGHT_BOLD;
}
/**
* get the type of super or subscript for the font
*
* @return super or subscript option
* @see org.apache.poi.hssf.usermodel.HSSFFontFormatting#SS_NONE
* @see org.apache.poi.hssf.usermodel.HSSFFontFormatting#SS_SUPER
* @see org.apache.poi.hssf.usermodel.HSSFFontFormatting#SS_SUB
*/
public short getEscapementType()
{
return LittleEndian.getShort(record,OFFSET_ESCAPEMENT_TYPE);
}
/**
* set the escapement type for the font
*
* @param escapementType super or subscript option
* @see org.apache.poi.hssf.usermodel.HSSFFontFormatting#SS_NONE
* @see org.apache.poi.hssf.usermodel.HSSFFontFormatting#SS_SUPER
* @see org.apache.poi.hssf.usermodel.HSSFFontFormatting#SS_SUB
*/
public void setEscapementType( short escapementType)
{
LittleEndian.putShort(record,OFFSET_ESCAPEMENT_TYPE, escapementType);
}
/**
* get the type of underlining for the font
*
* @return font underlining type
*
* @see org.apache.poi.hssf.usermodel.HSSFFontFormatting#U_NONE
* @see org.apache.poi.hssf.usermodel.HSSFFontFormatting#U_SINGLE
* @see org.apache.poi.hssf.usermodel.HSSFFontFormatting#U_DOUBLE
* @see org.apache.poi.hssf.usermodel.HSSFFontFormatting#U_SINGLE_ACCOUNTING
* @see org.apache.poi.hssf.usermodel.HSSFFontFormatting#U_DOUBLE_ACCOUNTING
*/
public short getUnderlineType()
{
return LittleEndian.getShort(record,OFFSET_UNDERLINE_TYPE);
}
/**
* set the type of underlining type for the font
*
* @param u super or subscript option
*
* @see org.apache.poi.hssf.usermodel.HSSFFontFormatting#U_NONE
* @see org.apache.poi.hssf.usermodel.HSSFFontFormatting#U_SINGLE
* @see org.apache.poi.hssf.usermodel.HSSFFontFormatting#U_DOUBLE
* @see org.apache.poi.hssf.usermodel.HSSFFontFormatting#U_SINGLE_ACCOUNTING
* @see org.apache.poi.hssf.usermodel.HSSFFontFormatting#U_DOUBLE_ACCOUNTING
*/
public void setUnderlineType( short underlineType)
{
LittleEndian.putShort(record,OFFSET_UNDERLINE_TYPE, underlineType);
}
public short getFontColorIndex()
{
return (short)LittleEndian.getInt(record,OFFSET_FONT_COLOR_INDEX);
}
public void setFontColorIndex(short fci )
{
LittleEndian.putInt(record,OFFSET_FONT_COLOR_INDEX,fci);
}
private boolean getOptionFlag(BitField field)
{
int optionFlags = LittleEndian.getInt(record,OFFSET_OPTION_FLAGS);
int value = field.getValue(optionFlags);
return value==0? true : false ;
}
private void setOptionFlag(boolean modified, BitField field)
{
int value = modified? 0 : 1;
int optionFlags = LittleEndian.getInt(record,OFFSET_OPTION_FLAGS);
optionFlags = field.setValue(optionFlags, value);
LittleEndian.putInt(record,OFFSET_OPTION_FLAGS, optionFlags);
}
public boolean isFontStyleModified()
{
return getOptionFlag(styleModified);
}
public void setFontStyleModified(boolean modified)
{
setOptionFlag(modified, styleModified);
}
public boolean isFontOutlineModified()
{
return getOptionFlag(outlineModified);
}
public void setFontOutlineModified(boolean modified)
{
setOptionFlag(modified, outlineModified);
}
public boolean isFontShadowModified()
{
return getOptionFlag(shadowModified);
}
public void setFontShadowModified(boolean modified)
{
setOptionFlag(modified, shadowModified);
}
public boolean isFontCondenseModified()
{
return getOptionFlag(condenseModified);
}
public void setFontCondenseModified(boolean modified)
{
setOptionFlag(modified, condenseModified);
}
public void setFontCancellationModified(boolean modified)
{
setOptionFlag(modified, cancellationModified);
}
public boolean isFontCancellationModified()
{
return getOptionFlag(cancellationModified);
}
public void setEscapementTypeModified(boolean modified)
{
int value = modified? 0 : 1;
LittleEndian.putInt(record,OFFSET_ESCAPEMENT_TYPE_MODIFIED, value);
}
public boolean isEscapementTypeModified()
{
int escapementModified = LittleEndian.getInt(record,OFFSET_ESCAPEMENT_TYPE_MODIFIED);
return escapementModified == 0;
}
public void setUnderlineTypeModified(boolean modified)
{
int value = modified? 0 : 1;
LittleEndian.putInt(record,OFFSET_UNDERLINE_TYPE_MODIFIED, value);
}
public boolean isUnderlineTypeModified()
{
int underlineModified = LittleEndian.getInt(record,OFFSET_UNDERLINE_TYPE_MODIFIED);
return underlineModified == 0;
}
public String toString()
{
StringBuffer buffer = new StringBuffer();
buffer.append(" [Font Formatting]\n");
buffer.append(" .font height = ").append(getFontHeight()).append(" twips\n");
if( isFontStyleModified() )
{
buffer.append(" .font posture = ").append(isItalic()?"Italic":"Normal").append("\n");
}
else
{
buffer.append(" .font posture = ]not modified]").append("\n");
}
if( isFontOutlineModified() )
{
buffer.append(" .font outline = ").append(isOutlineOn()).append("\n");
}
else
{
buffer.append(" .font outline is not modified\n");
}
if( isFontShadowModified() )
{
buffer.append(" .font shadow = ").append(isShadowOn()).append("\n");
}
else
{
buffer.append(" .font shadow is not modified\n");
}
if( isFontCondenseModified() )
{
buffer.append(" .font condense = ").append(isCondenseOn()).append("\n");
}
else
{
buffer.append(" .font condense is not modified\n");
}
if( isFontCancellationModified() )
{
buffer.append(" .font strikeout = ").append(isStruckout()).append("\n");
}
else
{
buffer.append(" .font strikeout is not modified\n");
}
if( isFontStyleModified() )
{
buffer.append(" .font weight = ").
append(getFontWeight()).
append(
getFontWeight() == FONT_WEIGHT_NORMAL ? "(Normal)"
: getFontWeight() == FONT_WEIGHT_BOLD ? "(Bold)" : "0x"+Integer.toHexString(getFontWeight())).
append("\n");
}
else
{
buffer.append(" .font weight = ]not modified]").append("\n");
}
if( isEscapementTypeModified() )
{
buffer.append(" .escapement type = ").append(getEscapementType()).append("\n");
}
else
{
buffer.append(" .escapement type is not modified\n");
}
if( isUnderlineTypeModified() )
{
buffer.append(" .underline type = ").append(getUnderlineType()).append("\n");
}
else
{
buffer.append(" .underline type is not modified\n");
}
buffer.append(" .color index = ").append("0x"+Integer.toHexString(getFontColorIndex()).toUpperCase()).append("\n");
buffer.append(" [/Font Formatting]\n");
return buffer.toString();
}
public Object clone()
{
FontFormatting rec = new FontFormatting();
if( record != null)
{
byte[] clone = new byte[record.length];
System.arraycopy(record, 0, clone, 0, record.length);
rec.record = clone;
}
return rec;
}
}

206
src/java/org/apache/poi/hssf/record/cf/PatternFormatting.java Normal file
View File

@ -0,0 +1,206 @@
/* ====================================================================
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==================================================================== */
/*
* FontFormatting.java
*
* Created on January 22, 2008, 10:05 PM
*/
package org.apache.poi.hssf.record.cf;
import org.apache.poi.hssf.record.RecordInputStream;
import org.apache.poi.util.BitField;
import org.apache.poi.util.BitFieldFactory;
import org.apache.poi.util.LittleEndian;
/**
* Pattern Formatting Block of the Conditional Formatting Rule Record.
*
* @author Dmitriy Kumshayev
*/
public class PatternFormatting implements Cloneable
{
/** No background */
public final static short NO_FILL = 0 ;
/** Solidly filled */
public final static short SOLID_FOREGROUND = 1 ;
/** Small fine dots */
public final static short FINE_DOTS = 2 ;
/** Wide dots */
public final static short ALT_BARS = 3 ;
/** Sparse dots */
public final static short SPARSE_DOTS = 4 ;
/** Thick horizontal bands */
public final static short THICK_HORZ_BANDS = 5 ;
/** Thick vertical bands */
public final static short THICK_VERT_BANDS = 6 ;
/** Thick backward facing diagonals */
public final static short THICK_BACKWARD_DIAG = 7 ;
/** Thick forward facing diagonals */
public final static short THICK_FORWARD_DIAG = 8 ;
/** Large spots */
public final static short BIG_SPOTS = 9 ;
/** Brick-like layout */
public final static short BRICKS = 10 ;
/** Thin horizontal bands */
public final static short THIN_HORZ_BANDS = 11 ;
/** Thin vertical bands */
public final static short THIN_VERT_BANDS = 12 ;
/** Thin backward diagonal */
public final static short THIN_BACKWARD_DIAG = 13 ;
/** Thin forward diagonal */
public final static short THIN_FORWARD_DIAG = 14 ;
/** Squares */
public final static short SQUARES = 15 ;
/** Diamonds */
public final static short DIAMONDS = 16 ;
/** Less Dots */
public final static short LESS_DOTS = 17 ;
/** Least Dots */
public final static short LEAST_DOTS = 18 ;
public PatternFormatting()
{
field_15_pattern_style = (short)0;
field_16_pattern_color_indexes = (short)0;
}
/** Creates new FontFormatting */
public PatternFormatting(RecordInputStream in)
{
field_15_pattern_style = in.readShort();
field_16_pattern_color_indexes = in.readShort();
}
// PATTERN FORMATING BLOCK
// For Pattern Styles see constants at HSSFCellStyle (from NO_FILL to LEAST_DOTS)
private short field_15_pattern_style;
private static final BitField fillPatternStyle = BitFieldFactory.getInstance(0xFC00);
private short field_16_pattern_color_indexes;
private static final BitField patternColorIndex = BitFieldFactory.getInstance(0x007F);
private static final BitField patternBackgroundColorIndex = BitFieldFactory.getInstance(0x3F80);
/**
* setting fill pattern
*
* @see #NO_FILL
* @see #SOLID_FOREGROUND
* @see #FINE_DOTS
* @see #ALT_BARS
* @see #SPARSE_DOTS
* @see #THICK_HORZ_BANDS
* @see #THICK_VERT_BANDS
* @see #THICK_BACKWARD_DIAG
* @see #THICK_FORWARD_DIAG
* @see #BIG_SPOTS
* @see #BRICKS
* @see #THIN_HORZ_BANDS
* @see #THIN_VERT_BANDS
* @see #THIN_BACKWARD_DIAG
* @see #THIN_FORWARD_DIAG
* @see #SQUARES
* @see #DIAMONDS
*
* @param fp fill pattern
*/
public void setFillPattern(short fp)
{
field_15_pattern_style = fillPatternStyle.setShortValue(field_15_pattern_style, fp);
}
/**
* get the fill pattern
* @return fill pattern
*/
public short getFillPattern()
{
return fillPatternStyle.getShortValue(field_15_pattern_style);
}
/**
* set the background fill color.
*
* @param bg color
*/
public void setFillBackgroundColor(short bg)
{
field_16_pattern_color_indexes = patternBackgroundColorIndex.setShortValue(field_16_pattern_color_indexes,bg);
}
/**
* get the background fill color
* @see org.apache.poi.hssf.usermodel.HSSFPalette#getColor(short)
* @return fill color
*/
public short getFillBackgroundColor()
{
return patternBackgroundColorIndex.getShortValue(field_16_pattern_color_indexes);
}
/**
* set the foreground fill color
* @param bg color
*/
public void setFillForegroundColor(short fg)
{
field_16_pattern_color_indexes = patternColorIndex.setShortValue(field_16_pattern_color_indexes,fg);
}
/**
* get the foreground fill color
* @see org.apache.poi.hssf.usermodel.HSSFPalette#getColor(short)
* @return fill color
*/
public short getFillForegroundColor()
{
return patternColorIndex.getShortValue(field_16_pattern_color_indexes);
}
public String toString()
{
StringBuffer buffer = new StringBuffer();
buffer.append(" [Pattern Formatting]\n");
buffer.append(" .fillpattern= ").append(Integer.toHexString(getFillPattern())).append("\n");
buffer.append(" .fgcoloridx= ").append(Integer.toHexString(getFillForegroundColor())).append("\n");
buffer.append(" .bgcoloridx= ").append(Integer.toHexString(getFillBackgroundColor())).append("\n");
buffer.append(" [/Pattern Formatting]\n");
return buffer.toString();
}
public Object clone()
{
PatternFormatting rec = new PatternFormatting();
rec.field_15_pattern_style = field_15_pattern_style;
rec.field_16_pattern_color_indexes = field_16_pattern_color_indexes;
return rec;
}
public int serialize(int offset, byte [] data)
{
LittleEndian.putShort(data, offset, field_15_pattern_style);
offset += 2;
LittleEndian.putShort(data, offset, field_16_pattern_color_indexes);
offset += 2;
return 4;
}
}

128
src/java/org/apache/poi/hssf/usermodel/HSSFBorderFormatting.java Normal file
View File

@ -0,0 +1,128 @@
/* ====================================================================
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==================================================================== */
package org.apache.poi.hssf.usermodel;
import org.apache.poi.hssf.record.cf.BorderFormatting;
/**
* High level representation for Border Formatting component
* of Conditional Formatting settings
*
* @author Dmitriy Kumshayev
*
*/
public class HSSFBorderFormatting
{
/**
* No border
*/
public final static short BORDER_NONE = BorderFormatting.BORDER_NONE;
/**
* Thin border
*/
public final static short BORDER_THIN = BorderFormatting.BORDER_THIN;
/**
* Medium border
*/
public final static short BORDER_MEDIUM = BorderFormatting.BORDER_MEDIUM;
/**
* dash border
*/
public final static short BORDER_DASHED = BorderFormatting.BORDER_DASHED;
/**
* dot border
*/
public final static short BORDER_HAIR = BorderFormatting.BORDER_HAIR;
/**
* Thick border
*/
public final static short BORDER_THICK = BorderFormatting.BORDER_THICK;
/**
* double-line border
*/
public final static short BORDER_DOUBLE = BorderFormatting.BORDER_DOUBLE;
/**
* hair-line border
*/
public final static short BORDER_DOTTED = BorderFormatting.BORDER_DOTTED;
/**
* Medium dashed border
*/
public final static short BORDER_MEDIUM_DASHED = BorderFormatting.BORDER_MEDIUM_DASHED;
/**
* dash-dot border
*/
public final static short BORDER_DASH_DOT = BorderFormatting.BORDER_DASH_DOT;
/**
* medium dash-dot border
*/
public final static short BORDER_MEDIUM_DASH_DOT = BorderFormatting.BORDER_MEDIUM_DASH_DOT;
/**
* dash-dot-dot border
*/
public final static short BORDER_DASH_DOT_DOT = BorderFormatting.BORDER_DASH_DOT_DOT;
/**
* medium dash-dot-dot border
*/
public final static short BORDER_MEDIUM_DASH_DOT_DOT = BorderFormatting.BORDER_MEDIUM_DASH_DOT_DOT;
/**
* slanted dash-dot border
*/
public final static short BORDER_SLANTED_DASH_DOT = BorderFormatting.BORDER_SLANTED_DASH_DOT;
private BorderFormatting borderFormatting;
public HSSFBorderFormatting()
{
borderFormatting = new BorderFormatting();
}
protected BorderFormatting getBorderFormattingBlock()
{
return borderFormatting;
}
}

201
src/java/org/apache/poi/hssf/usermodel/HSSFConditionalFormatting.java Normal file
View File

@ -0,0 +1,201 @@
/* ====================================================================
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==================================================================== */
package org.apache.poi.hssf.usermodel;
import java.util.ArrayList;
import java.util.List;
import org.apache.poi.hssf.record.CFHeaderRecord;
import org.apache.poi.hssf.record.CFRuleRecord;
import org.apache.poi.hssf.record.aggregates.CFRecordsAggregate;
import org.apache.poi.hssf.record.cf.CellRange;
import org.apache.poi.hssf.util.Region;
public class HSSFConditionalFormatting
{
HSSFSheet sheet;
CFRecordsAggregate cfAggregate;
protected HSSFConditionalFormatting(HSSFSheet sheet)
{
this.sheet = sheet;
this.cfAggregate = new CFRecordsAggregate();
}
protected HSSFConditionalFormatting(HSSFSheet sheet, CFRecordsAggregate cfAggregate)
{
this.sheet = sheet;
this.cfAggregate = cfAggregate;
}
public void setFormattingRegions(Region[] regions)
{
if( regions != null)
{
CFHeaderRecord header = cfAggregate.getHeader();
header.setCellRanges(mergeCellRanges(toCellRangeList(regions)));
}
}
public Region[] getFormattingRegions()
{
CFHeaderRecord cfh = cfAggregate.getHeader();
List cellRanges = cfh.getCellRanges();
if (cellRanges != null)
{
return toRegionArray(cellRanges);
}
return null;
}
public void setConditionalFormat(int idx, HSSFConditionalFormattingRule cfRule)
{
cfAggregate.getRules().set(idx, cfRule);
}
public void addConditionalFormat(HSSFConditionalFormattingRule cfRule)
{
cfAggregate.getRules().add(cfRule);
}
public HSSFConditionalFormattingRule getConditionalFormat(int idx)
{
CFRuleRecord ruleRecord = (CFRuleRecord)cfAggregate.getRules().get(idx);
return new HSSFConditionalFormattingRule(sheet.workbook, ruleRecord);
}
/**
* Do all possible cell merges between cells of the list so that:<br>
* <li>if a cell range is completely inside of another cell range, it gets removed from the list
* <li>if two cells have a shared border, merge them into one bigger cell range
* @param cellRangeList
* @return updated List of cell ranges
*/
private static List mergeCellRanges(List cellRangeList)
{
boolean merged = false;
do
{
merged = false;
if( cellRangeList.size()>1 )
{
for( int i=0; i<cellRangeList.size(); i++)
{
CellRange range1 = (CellRange)cellRangeList.get(i);
for( int j=i+1; j<cellRangeList.size(); j++)
{
CellRange range2 = (CellRange)cellRangeList.get(j);
switch(range1.intersect(range2))
{
case CellRange.NO_INTERSECTION:
{
if( range1.hasSharedBorder(range2))
{
cellRangeList.set(i, range1.createEnclosingCellRange(range2));
cellRangeList.remove(j--);
merged = true;
}
else
{
// No intersection and no shared border: do nothing
}
break;
}
case CellRange.OVERLAP:
{
// TODO split and re-merge the intersected area
break;
}
case CellRange.INSIDE:
{
// Remove range2, since it is completely inside of range1
cellRangeList.remove(j--);
merged = true;
break;
}
case CellRange.ENCLOSES:
{
// range2 encloses range1, so replace it with the enclosing one
cellRangeList.set(i, range2);
cellRangeList.remove(j--);
merged = true;
break;
}
}
}
}
}
}
while( merged );
return cellRangeList;
}
/**
* Convert a List of CellRange objects to an array of regions
*
* @param List of CellRange objects
* @return regions
*/
private static Region[] toRegionArray(List cellRanges)
{
int size = cellRanges.size();
Region[] regions = new Region[size];
for (int i = 0; i != size; i++)
{
CellRange cr = (CellRange) cellRanges.get(i);
regions[i] = new Region(cr.getFirstRow(), cr.getFirstColumn(),
cr.getLastRow(), cr.getLastColumn());
}
return regions;
}
/**
* Convert array of regions to a List of CellRange objects
*
* @param regions
* @return List of CellRange objects
*/
private static List toCellRangeList(Region[] regions)
{
List cellRangeList = new ArrayList();
for( int i=0; i<regions.length; i++)
{
Region r = regions[i];
CellRange cr = new CellRange(r.getRowFrom(), r.getRowTo(), r.getColumnFrom(), r
.getColumnTo());
cellRangeList.add(cr);
}
return cellRangeList;
}
public String toString()
{
if(cfAggregate!=null)
{
return cfAggregate.toString();
}
return null;
}
}

248
src/java/org/apache/poi/hssf/usermodel/HSSFConditionalFormattingRule.java Normal file
View File

@ -0,0 +1,248 @@
/* ====================================================================
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==================================================================== */
package org.apache.poi.hssf.usermodel;
import java.util.List;
import java.util.Stack;
import org.apache.poi.hssf.model.FormulaParser;
import org.apache.poi.hssf.record.CFRuleRecord;
import org.apache.poi.hssf.record.formula.Ptg;
/**
*
* High level representation of Conditional Format
*
* @author Dmitriy Kumshayev
*/
public class HSSFConditionalFormattingRule
{
public static final byte CELL_COMPARISON = CFRuleRecord.CONDITION_TYPE_CELL_VALUE_IS;
public static final byte FORMULA = CFRuleRecord.CONDITION_TYPE_FORMULA;
public static final byte COMPARISON_OPERATOR_NO_COMPARISON = CFRuleRecord.COMPARISON_OPERATOR_NO_COMPARISON;
public static final byte COMPARISON_OPERATOR_BETWEEN = CFRuleRecord.COMPARISON_OPERATOR_BETWEEN;
public static final byte COMPARISON_OPERATOR_NOT_BETWEEN = CFRuleRecord.COMPARISON_OPERATOR_NOT_BETWEEN;
public static final byte COMPARISON_OPERATOR_EQUAL = CFRuleRecord.COMPARISON_OPERATOR_EQUAL;
public static final byte COMPARISON_OPERATOR_NOT_EQUAL = CFRuleRecord.COMPARISON_OPERATOR_NOT_EQUAL;
public static final byte COMPARISON_OPERATOR_GT = CFRuleRecord.COMPARISON_OPERATOR_GT;
public static final byte COMPARISON_OPERATOR_LT = CFRuleRecord.COMPARISON_OPERATOR_LT;
public static final byte COMPARISON_OPERATOR_GE = CFRuleRecord.COMPARISON_OPERATOR_GE;
public static final byte COMPARISON_OPERATOR_LE = CFRuleRecord.COMPARISON_OPERATOR_LE;
private CFRuleRecord cfRuleRecord;
private HSSFWorkbook workbook;
protected HSSFConditionalFormattingRule(HSSFWorkbook workbook)
{
this.workbook = workbook;
this.cfRuleRecord = new CFRuleRecord();
}
protected HSSFConditionalFormattingRule(HSSFWorkbook workbook, CFRuleRecord cfRuleRecord)
{
this.workbook = workbook;
this.cfRuleRecord = cfRuleRecord;
}
/**
* Keep Font Formatting unchanged for this Conditional Formatting Rule
*/
public void setFontFormattingUnchanged()
{
cfRuleRecord.setFontFormattingUnchanged();
}
/**
* Keep Border Formatting unchanged for this Conditional Formatting Rule
*/
public void setBorderFormattingUnchanged()
{
cfRuleRecord.setBorderFormattingUnchanged();
}
/**
* Keep Pattern Formatting unchanged for this Conditional Formatting Rule
*/
public void setPatternFormattingUnchanged()
{
cfRuleRecord.setPatternFormattingUnchanged();
}
public void setFontFormatting(HSSFFontFormatting fontFormatting)
{
if( fontFormatting!=null )
{
cfRuleRecord.setFontFormatting(fontFormatting.getFontFormattingBlock());
}
else
{
setFontFormattingUnchanged();
}
}
public void setBorderFormatting(HSSFBorderFormatting borderFormatting)
{
if( borderFormatting != null )
{
cfRuleRecord.setBorderFormatting(borderFormatting.getBorderFormattingBlock());
}
else
{
setBorderFormattingUnchanged();
}
}
public void setPatternFormatting(HSSFPatternFormatting patternFormatting)
{
if( patternFormatting != null)
{
cfRuleRecord.setPatternFormatting(patternFormatting.getPatternFormattingBlock());
}
else
{
setPatternFormattingUnchanged();
}
}
public void setCellComparisonCondition(byte comparisonOperation, String formula1, String formula2)
{
cfRuleRecord.setConditionType(CELL_COMPARISON);
cfRuleRecord.setComparisonOperation(comparisonOperation);
// Formula 1
setFormula1(formula1);
// Formula 2
setFormula1(formula2);
}
public void setFormulaCondition(String formula)
{
cfRuleRecord.setConditionType(FORMULA);
// Formula 1
setFormula1(formula);
}
public void setFormula1(String formula)
{
// Formula 1
if( formula != null)
{
Stack parsedExpression = parseFormula(formula);
if( parsedExpression != null )
{
cfRuleRecord.setParsedExpression1(parsedExpression);
}
else
{
cfRuleRecord.setParsedExpression1(null);
}
}
else
{
cfRuleRecord.setParsedExpression1(null);
}
}
public void setFormula2(String formula)
{
// Formula 2
if( formula != null)
{
Stack parsedExpression = parseFormula(formula);
if( parsedExpression != null )
{
cfRuleRecord.setParsedExpression2(parsedExpression);
}
else
{
cfRuleRecord.setParsedExpression2(null);
}
}
else
{
cfRuleRecord.setParsedExpression2(null);
}
}
public String getFormula1()
{
return toFormulaString(cfRuleRecord.getParsedExpression1());
}
public String getFormula2()
{
byte conditionType = cfRuleRecord.getConditionType();
switch(conditionType)
{
case CELL_COMPARISON:
{
byte comparisonOperation = cfRuleRecord.getComparisonOperation();
switch(comparisonOperation)
{
case COMPARISON_OPERATOR_BETWEEN:
case COMPARISON_OPERATOR_NOT_BETWEEN:
return toFormulaString(cfRuleRecord.getParsedExpression2());
}
}
}
return null;
}
private String toFormulaString(List parsedExpression)
{
String formula = null;
if(parsedExpression!=null)
{
formula = FormulaParser.toFormulaString(workbook.getWorkbook(),parsedExpression);
}
return formula;
}
private Stack parseFormula(String formula2)
{
FormulaParser parser =
new FormulaParser(formula2, workbook.getWorkbook());
parser.parse();
Stack parsedExpression = convertToTokenStack(parser.getRPNPtg());
parsedExpression = convertToTokenStack(parser.getRPNPtg());
return parsedExpression;
}
private static Stack convertToTokenStack(Ptg[] ptgs)
{
if( ptgs != null)
{
Stack parsedExpression = new Stack();
// fill the Ptg Stack with Ptgs of new formula
for (int k = 0; k < ptgs.length; k++)
{
parsedExpression.push(ptgs[ k ]);
}
return parsedExpression;
}
else
{
return null;
}
}
}

456
src/java/org/apache/poi/hssf/usermodel/HSSFFontFormatting.java Normal file
View File

@ -0,0 +1,456 @@
/* ====================================================================
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==================================================================== */
package org.apache.poi.hssf.usermodel;
import org.apache.poi.hssf.record.cf.FontFormatting;
/**
* High level representation for Font Formatting component
* of Conditional Formatting settings
*
* @author Dmitriy Kumshayev
*
*/
public class HSSFFontFormatting
{
/**
* Escapement type - None
*/
public final static short SS_NONE = FontFormatting.SS_NONE;
/**
* Escapement type - Superscript
*/
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
*/
public final static byte U_SINGLE = FontFormatting.U_SINGLE;
/**
* 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
*/
public final static byte U_DOUBLE_ACCOUNTING = FontFormatting.U_DOUBLE_ACCOUNTING;
private FontFormatting fontFormatting;
public HSSFFontFormatting()
{
fontFormatting = new FontFormatting();
}
protected FontFormatting getFontFormattingBlock()
{
return fontFormatting;
}
/**
* get the type of super or subscript for the font
*
* @return super or subscript option
* @see #SS_NONE
* @see #SS_SUPER
* @see #SS_SUB
*/
public short getEscapementType()
{
return fontFormatting.getEscapementType();
}
/**
* @return font color index
*/
public short getFontColorIndex()
{
return fontFormatting.getFontColorIndex();
}
/**
* gets the height of the font in 1/20th point units
*
* @return fontheight (in points/20); or -1 if not modified
*/
public short getFontHeight()
{
return fontFormatting.getFontHeight();
}
/**
* get the font weight for this font (100-1000dec or 0x64-0x3e8). Default is
* 0x190 for normal and 0x2bc for bold
*
* @return bw - a number between 100-1000 for the fonts "boldness"
*/
public short getFontWeight()
{
return fontFormatting.getFontWeight();
}
/**
* @return
* @see org.apache.poi.hssf.record.cf.FontFormatting#getRawRecord()
*/
protected byte[] getRawRecord()
{
return fontFormatting.getRawRecord();
}
/**
* get the type of underlining for the font
*
* @return font underlining type
*
* @see #U_NONE
* @see #U_SINGLE
* @see #U_DOUBLE
* @see #U_SINGLE_ACCOUNTING
* @see #U_DOUBLE_ACCOUNTING
*/
public short getUnderlineType()
{
return fontFormatting.getUnderlineType();
}
/**
* get whether the font weight is set to bold or not
*
* @return bold - whether the font is bold or not
*/
public boolean isBold()
{
return fontFormatting.isBold();
}
/**
* @return whether the font is condense or not
*/
public boolean isCondenseOn()
{
return fontFormatting.isFontOutlineModified() && fontFormatting.isCondenseOn();
}
/**
* @return true if escapement type was modified from default
*/
public boolean isEscapementTypeModified()
{
return fontFormatting.isEscapementTypeModified();
}
/**
* @return true if font cancellation was modified from default
*/
public boolean isFontCancellationModified()
{
return fontFormatting.isFontCancellationModified();
}
/**
* @return true if font condense type was modified from default
*/
public boolean isFontCondenseModified()
{
return fontFormatting.isFontCondenseModified();
}
/**
* @return true if font outline type was modified from default
*/
public boolean isFontOutlineModified()
{
return fontFormatting.isFontOutlineModified();
}
/**
* @return true if font shadow type was modified from default
*/
public boolean isFontShadowModified()
{
return fontFormatting.isFontShadowModified();
}
/**
* @return true if font style was modified from default
*/
public boolean isFontStyleModified()
{
return fontFormatting.isFontStyleModified();
}
/**
* @return true if font style was set to <i>italic</i>
*/
public boolean isItalic()
{
return fontFormatting.isFontStyleModified() && fontFormatting.isItalic();
}
/**
* @return true if font outline is on
*/
public boolean isOutlineOn()
{
return fontFormatting.isFontOutlineModified() && fontFormatting.isOutlineOn();
}
/**
* @return true if font shadow is on
*/
public boolean isShadowOn()
{
return fontFormatting.isFontOutlineModified() && fontFormatting.isShadowOn();
}
/**
* @return true if font strikeout is on
*/
public boolean isStruckout()
{
return fontFormatting.isFontCancellationModified() && fontFormatting.isStruckout();
}
/**
* @return true if font underline type was modified from default
*/
public boolean isUnderlineTypeModified()
{
return fontFormatting.isUnderlineTypeModified();
}
/**
* set font style options.
*
* @param italic - if true, set posture style to italic, otherwise to normal
* @param bold- if true, set font weight to bold, otherwise to normal
*/
public void setFontStyle(boolean italic, boolean bold)
{
boolean modified = italic || bold;
fontFormatting.setItalic(italic);
fontFormatting.setBold(bold);
fontFormatting.setFontStyleModified(modified);
}
/**
* set font style options to default values (non-italic, non-bold)
*/
public void resetFontStyle()
{
setFontStyle(false,false);
}
/**
* set the escapement type for the font
*
* @param escapementType super or subscript option
* @see #SS_NONE
* @see #SS_SUPER
* @see #SS_SUB
*/
public void setCondense(boolean on)
{
fontFormatting.setCondense(on);
fontFormatting.setFontCondenseModified(on);
}
/**
* set the escapement type for the font
*
* @param escapementType super or subscript option
* @see #SS_NONE
* @see #SS_SUPER
* @see #SS_SUB
*/
public void setEscapementType(short escapementType)
{
switch(escapementType)
{
case HSSFFontFormatting.SS_SUB:
case HSSFFontFormatting.SS_SUPER:
fontFormatting.setEscapementType(escapementType);
fontFormatting.setEscapementTypeModified(true);
break;
case HSSFFontFormatting.SS_NONE:
fontFormatting.setEscapementType(escapementType);
fontFormatting.setEscapementTypeModified(false);
break;
default:
}
}
/**
* @param modified
* @see org.apache.poi.hssf.record.cf.FontFormatting#setEscapementTypeModified(boolean)
*/
public void setEscapementTypeModified(boolean modified)
{
fontFormatting.setEscapementTypeModified(modified);
}
/**
* @param modified
* @see org.apache.poi.hssf.record.cf.FontFormatting#setFontCancellationModified(boolean)
*/
public void setFontCancellationModified(boolean modified)
{
fontFormatting.setFontCancellationModified(modified);
}
/**
* @param fci
* @see org.apache.poi.hssf.record.cf.FontFormatting#setFontColorIndex(short)
*/
public void setFontColorIndex(short fci)
{
fontFormatting.setFontColorIndex(fci);
}
/**
* @param modified
* @see org.apache.poi.hssf.record.cf.FontFormatting#setFontCondenseModified(boolean)
*/
public void setFontCondenseModified(boolean modified)
{
fontFormatting.setFontCondenseModified(modified);
}
/**
* @param height
* @see org.apache.poi.hssf.record.cf.FontFormatting#setFontHeight(short)
*/
public void setFontHeight(short height)
{
fontFormatting.setFontHeight(height);
}
/**
* @param modified
* @see org.apache.poi.hssf.record.cf.FontFormatting#setFontOutlineModified(boolean)
*/
public void setFontOutlineModified(boolean modified)
{
fontFormatting.setFontOutlineModified(modified);
}
/**
* @param modified
* @see org.apache.poi.hssf.record.cf.FontFormatting#setFontShadowModified(boolean)
*/
public void setFontShadowModified(boolean modified)
{
fontFormatting.setFontShadowModified(modified);
}
/**
* @param modified
* @see org.apache.poi.hssf.record.cf.FontFormatting#setFontStyleModified(boolean)
*/
public void setFontStyleModified(boolean modified)
{
fontFormatting.setFontStyleModified(modified);
}
/**
* @param on
* @see org.apache.poi.hssf.record.cf.FontFormatting#setOutline(boolean)
*/
public void setOutline(boolean on)
{
fontFormatting.setOutline(on);
fontFormatting.setFontOutlineModified(on);
}
/**
* @param on
* @see org.apache.poi.hssf.record.cf.FontFormatting#setShadow(boolean)
*/
public void setShadow(boolean on)
{
fontFormatting.setShadow(on);
fontFormatting.setFontShadowModified(on);
}
/**
* @param strike
* @see org.apache.poi.hssf.record.cf.FontFormatting#setStrikeout(boolean)
*/
public void setStrikeout(boolean strike)
{
fontFormatting.setStrikeout(strike);
fontFormatting.setFontCancellationModified(strike);
}
/**
* set the type of underlining type for the font
*
* @param u super or subscript option
*
* @see #U_NONE
* @see #U_SINGLE
* @see #U_DOUBLE
* @see #U_SINGLE_ACCOUNTING
* @see #U_DOUBLE_ACCOUNTING
*/
public void setUnderlineType(short underlineType)
{
switch(underlineType)
{
case HSSFFontFormatting.U_SINGLE:
case HSSFFontFormatting.U_DOUBLE:
case HSSFFontFormatting.U_SINGLE_ACCOUNTING:
case HSSFFontFormatting.U_DOUBLE_ACCOUNTING:
fontFormatting.setUnderlineType(underlineType);
setUnderlineTypeModified(true);
break;
case HSSFFontFormatting.U_NONE:
fontFormatting.setUnderlineType(underlineType);
setUnderlineTypeModified(false);
break;
default:
}
}
/**
* @param modified
* @see org.apache.poi.hssf.record.cf.FontFormatting#setUnderlineTypeModified(boolean)
*/
public void setUnderlineTypeModified(boolean modified)
{
fontFormatting.setUnderlineTypeModified(modified);
}
}

134
src/java/org/apache/poi/hssf/usermodel/HSSFPatternFormatting.java Normal file
View File

@ -0,0 +1,134 @@
/* ====================================================================
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==================================================================== */
package org.apache.poi.hssf.usermodel;
import org.apache.poi.hssf.record.cf.PatternFormatting;
/**
* High level representation for Conditional Formatting settings
*
* @author Dmitriy Kumshayev
*
*/
public class HSSFPatternFormatting
{
/** No background */
public final static short NO_FILL = PatternFormatting.NO_FILL;
/** Solidly filled */
public final static short SOLID_FOREGROUND = PatternFormatting.SOLID_FOREGROUND;
/** Small fine dots */
public final static short FINE_DOTS = PatternFormatting.FINE_DOTS;
/** Wide dots */
public final static short ALT_BARS = PatternFormatting.ALT_BARS;
/** Sparse dots */
public final static short SPARSE_DOTS = PatternFormatting.SPARSE_DOTS;
/** Thick horizontal bands */
public final static short THICK_HORZ_BANDS = PatternFormatting.THICK_HORZ_BANDS;
/** Thick vertical bands */
public final static short THICK_VERT_BANDS = PatternFormatting.THICK_VERT_BANDS;
/** Thick backward facing diagonals */
public final static short THICK_BACKWARD_DIAG = PatternFormatting.THICK_BACKWARD_DIAG;
/** Thick forward facing diagonals */
public final static short THICK_FORWARD_DIAG = PatternFormatting.THICK_FORWARD_DIAG;
/** Large spots */
public final static short BIG_SPOTS = PatternFormatting.BIG_SPOTS;
/** Brick-like layout */
public final static short BRICKS = PatternFormatting.BRICKS;
/** Thin horizontal bands */
public final static short THIN_HORZ_BANDS = PatternFormatting.THIN_HORZ_BANDS;
/** Thin vertical bands */
public final static short THIN_VERT_BANDS = PatternFormatting.THIN_VERT_BANDS;
/** Thin backward diagonal */
public final static short THIN_BACKWARD_DIAG = PatternFormatting.THIN_BACKWARD_DIAG;
/** Thin forward diagonal */
public final static short THIN_FORWARD_DIAG = PatternFormatting.THIN_FORWARD_DIAG;
/** Squares */
public final static short SQUARES = PatternFormatting.SQUARES;
/** Diamonds */
public final static short DIAMONDS = PatternFormatting.DIAMONDS;
/** Less Dots */
public final static short LESS_DOTS = PatternFormatting.LESS_DOTS;
/** Least Dots */
public final static short LEAST_DOTS = PatternFormatting.LEAST_DOTS;
private PatternFormatting patternFormatting;
public HSSFPatternFormatting()
{
patternFormatting = new PatternFormatting();
}
protected PatternFormatting getPatternFormattingBlock()
{
return patternFormatting;
}
/**
* @return
* @see org.apache.poi.hssf.record.cf.PatternFormatting#getFillBackgroundColor()
*/
public short getFillBackgroundColor()
{
return patternFormatting.getFillBackgroundColor();
}
/**
* @return
* @see org.apache.poi.hssf.record.cf.PatternFormatting#getFillForegroundColor()
*/
public short getFillForegroundColor()
{
return patternFormatting.getFillForegroundColor();
}
/**
* @return
* @see org.apache.poi.hssf.record.cf.PatternFormatting#getFillPattern()
*/
public short getFillPattern()
{
return patternFormatting.getFillPattern();
}
/**
* @param bg
* @see org.apache.poi.hssf.record.cf.PatternFormatting#setFillBackgroundColor(short)
*/
public void setFillBackgroundColor(short bg)
{
patternFormatting.setFillBackgroundColor(bg);
}
/**
* @param fg
* @see org.apache.poi.hssf.record.cf.PatternFormatting#setFillForegroundColor(short)
*/
public void setFillForegroundColor(short fg)
{
patternFormatting.setFillForegroundColor(fg);
}
/**
* @param fp
* @see org.apache.poi.hssf.record.cf.PatternFormatting#setFillPattern(short)
*/
public void setFillPattern(short fp)
{
patternFormatting.setFillPattern(fp);
}
}

158
src/java/org/apache/poi/hssf/usermodel/HSSFSheet.java
View File

@ -27,6 +27,7 @@ import org.apache.poi.hssf.model.FormulaParser;
import org.apache.poi.hssf.model.Sheet;
import org.apache.poi.hssf.model.Workbook;
import org.apache.poi.hssf.record.*;
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;
@ -1830,4 +1831,161 @@ public class HSSFSheet
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 - one of the following values: <p>
* <li>{@link HSSFConditionalFormattingRule#COMPARISON_OPERATOR_BETWEEN}</li>
* <li>{@link HSSFConditionalFormattingRule#COMPARISON_OPERATOR_NOT_BETWEEN}</li>
* <li>{@link HSSFConditionalFormattingRule#COMPARISON_OPERATOR_EQUAL}</li>
* <li>{@link HSSFConditionalFormattingRule#COMPARISON_OPERATOR_NOT_EQUAL}</li>
* <li>{@link HSSFConditionalFormattingRule#COMPARISON_OPERATOR_GT}</li>
* <li>{@link HSSFConditionalFormattingRule#COMPARISON_OPERATOR_LT}</li>
* <li>{@link HSSFConditionalFormattingRule#COMPARISON_OPERATOR_GE}</li>
* <li>{@link HSSFConditionalFormattingRule#COMPARISON_OPERATOR_LE}</li>
* </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
* @param bordFmt - border formatting rules
* @param patternFmt - pattern formatting rules
* @return
*
*/
public HSSFConditionalFormattingRule createConditionalFormattingRule(
byte comparisonOperation,
String formula1,
String formula2,
HSSFFontFormatting fontFmt,
HSSFBorderFormatting bordFmt,
HSSFPatternFormatting patternFmt)
{
HSSFConditionalFormattingRule cf = new HSSFConditionalFormattingRule(workbook);
cf.setFontFormatting(fontFmt);
cf.setBorderFormatting(bordFmt);
cf.setPatternFormatting(patternFmt);
cf.setCellComparisonCondition(comparisonOperation, formula1, formula2);
return cf;
}
/**
* 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 comparisonOperation - one of the following values: <p>
* <li>{@link HSSFConditionalFormattingRule#COMPARISON_OPERATOR_BETWEEN}</li>
* <li>{@link HSSFConditionalFormattingRule#COMPARISON_OPERATOR_NOT_BETWEEN}</li>
* <li>{@link HSSFConditionalFormattingRule#COMPARISON_OPERATOR_EQUAL}</li>
* <li>{@link HSSFConditionalFormattingRule#COMPARISON_OPERATOR_NOT_EQUAL}</li>
* <li>{@link HSSFConditionalFormattingRule#COMPARISON_OPERATOR_GT}</li>
* <li>{@link HSSFConditionalFormattingRule#COMPARISON_OPERATOR_LT}</li>
* <li>{@link HSSFConditionalFormattingRule#COMPARISON_OPERATOR_GE}</li>
* <li>{@link HSSFConditionalFormattingRule#COMPARISON_OPERATOR_LE}</li>
* </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
* @param bordFmt - border formatting rules
* @param patternFmt - pattern formatting rules
* @return
*
*/
public HSSFConditionalFormattingRule createConditionalFormattingRule(
String formula,
HSSFFontFormatting fontFmt,
HSSFBorderFormatting bordFmt,
HSSFPatternFormatting patternFmt)
{
HSSFConditionalFormattingRule cf = new HSSFConditionalFormattingRule(workbook);
cf.setFontFormatting(fontFmt);
cf.setBorderFormatting(bordFmt);
cf.setPatternFormatting(patternFmt);
cf.setFormulaCondition(formula);
return cf;
}
/**
* 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 )
{
HSSFConditionalFormatting cfClone = new HSSFConditionalFormatting(this,cf.cfAggregate.cloneCFAggregate());
cfClone.sheet=this;
return sheet.addConditionalFormatting(cfClone.cfAggregate);
}
/**
* Allows to add a new Conditional Formatting set to the sheet.
*
* @param regions - list of rectangular regions to apply conditional formatting rules
* @param cfRules - set of up to three conditional formatting rules
*
* @return index of the newly created Conditional Formatting object
*/
public int addConditionalFormatting( Region [] regions, HSSFConditionalFormattingRule [] cfRules )
{
HSSFConditionalFormatting cf = new HSSFConditionalFormatting(this);
cf.setFormattingRegions(regions);
if( cfRules != null )
{
for( int i=0; i!= cfRules.length; i++ )
{
cf.addConditionalFormat(cfRules[i]);
}
}
return sheet.addConditionalFormatting(cf.cfAggregate);
}
/**
* 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 new HSSFConditionalFormatting(this,cf);
}
return null;
}
/**
* @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);
}
}

145
src/testcases/org/apache/poi/hssf/record/TestCFHeaderRecord.java Normal file
View File

@ -0,0 +1,145 @@
/* ====================================================================
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==================================================================== */
package org.apache.poi.hssf.record;
import java.util.ArrayList;
import java.util.List;
import junit.framework.TestCase;
import org.apache.poi.hssf.record.cf.CellRange;
/**
* Tests the serialization and deserialization of the TestCFHeaderRecord
* class works correctly.
*
* @author Dmitriy Kumshayev
*/
public class TestCFHeaderRecord
extends TestCase
{
public TestCFHeaderRecord(String name)
{
super(name);
}
public void testCreateCFHeaderRecord ()
{
CFHeaderRecord record = new CFHeaderRecord();
List ranges = new ArrayList();
ranges.add(new CellRange(0,-1,(short)5,(short)5));
ranges.add(new CellRange(0,-1,(short)6,(short)6));
ranges.add(new CellRange(0,1,(short)0,(short)1));
ranges.add(new CellRange(0,1,(short)2,(short)3));
ranges.add(new CellRange(2,3,(short)0,(short)1));
ranges.add(new CellRange(2,3,(short)2,(short)3));
record.setCellRanges(ranges);
ranges = record.getCellRanges();
assertEquals(6,ranges.size());
CellRange enclosingCellRange = record.getEnclosingCellRange();
assertEquals(0, enclosingCellRange.getFirstRow());
assertEquals(-1, enclosingCellRange.getLastRow());
assertEquals(0, enclosingCellRange.getFirstColumn());
assertEquals(6, enclosingCellRange.getLastColumn());
record.setNeedRecalculation(true);
assertTrue(record.getNeedRecalculation());
record.setNeedRecalculation(false);
assertFalse(record.getNeedRecalculation());
}
public void testSerialization() {
byte[] recordData = new byte[]
{
(byte)0x03, (byte)0x00,
(byte)0x01, (byte)0x00,
(byte)0x00, (byte)0x00,
(byte)0x03, (byte)0x00,
(byte)0x00, (byte)0x00,
(byte)0x03, (byte)0x00,
(byte)0x04, (byte)0x00,
(byte)0x00, (byte)0x00,
(byte)0x01, (byte)0x00,
(byte)0x00, (byte)0x00,
(byte)0x01, (byte)0x00,
(byte)0x00, (byte)0x00,
(byte)0x01, (byte)0x00,
(byte)0x02, (byte)0x00,
(byte)0x03, (byte)0x00,
(byte)0x02, (byte)0x00,
(byte)0x03, (byte)0x00,
(byte)0x00, (byte)0x00,
(byte)0x01, (byte)0x00,
(byte)0x02, (byte)0x00,
(byte)0x03, (byte)0x00,
(byte)0x02, (byte)0x00,
(byte)0x03, (byte)0x00,
};
CFHeaderRecord record = new CFHeaderRecord(new TestcaseRecordInputStream(CFHeaderRecord.sid, (short)recordData.length, recordData));
assertEquals("#CFRULES", 3, record.getNumberOfConditionalFormats());
assertTrue(record.getNeedRecalculation());
CellRange enclosingCellRange = record.getEnclosingCellRange();
assertEquals(0, enclosingCellRange.getFirstRow());
assertEquals(3, enclosingCellRange.getLastRow());
assertEquals(0, enclosingCellRange.getFirstColumn());
assertEquals(3, enclosingCellRange.getLastColumn());
List ranges = record.getCellRanges();
assertEquals(0, ((CellRange)ranges.get(0)).getFirstRow());
assertEquals(1, ((CellRange)ranges.get(0)).getLastRow());
assertEquals(0, ((CellRange)ranges.get(0)).getFirstColumn());
assertEquals(1, ((CellRange)ranges.get(0)).getLastColumn());
assertEquals(0, ((CellRange)ranges.get(1)).getFirstRow());
assertEquals(1, ((CellRange)ranges.get(1)).getLastRow());
assertEquals(2, ((CellRange)ranges.get(1)).getFirstColumn());
assertEquals(3, ((CellRange)ranges.get(1)).getLastColumn());
assertEquals(2, ((CellRange)ranges.get(2)).getFirstRow());
assertEquals(3, ((CellRange)ranges.get(2)).getLastRow());
assertEquals(0, ((CellRange)ranges.get(2)).getFirstColumn());
assertEquals(1, ((CellRange)ranges.get(2)).getLastColumn());
assertEquals(2, ((CellRange)ranges.get(3)).getFirstRow());
assertEquals(3, ((CellRange)ranges.get(3)).getLastRow());
assertEquals(2, ((CellRange)ranges.get(3)).getFirstColumn());
assertEquals(3, ((CellRange)ranges.get(3)).getLastColumn());
assertEquals(recordData.length+4, record.getRecordSize());
byte[] output = record.serialize();
assertEquals("Output size", recordData.length+4, output.length); //includes sid+recordlength
for (int i = 0; i < recordData.length;i++)
{
assertEquals("CFHeaderRecord doesn't match", recordData[i], output[i+4]);
}
}
public static void main(String[] ignored_args)
{
System.out.println("Testing org.apache.poi.hssf.record.CFHeaderRecord");
junit.textui.TestRunner.run(TestCFHeaderRecord.class);
}
}

296
src/testcases/org/apache/poi/hssf/record/TestCFRuleRecord.java Normal file
View File

@ -0,0 +1,296 @@
/* ====================================================================
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==================================================================== */
package org.apache.poi.hssf.record;
import junit.framework.TestCase;
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.util.HSSFColor;
/**
* Tests the serialization and deserialization of the TestCFRuleRecord
* class works correctly.
*
* @author Dmitriy Kumshayev
*/
public class TestCFRuleRecord
extends TestCase
{
public TestCFRuleRecord(String name)
{
super(name);
}
public void testCreateCFRuleRecord ()
{
CFRuleRecord record = new CFRuleRecord();
testCFRuleRecord(record);
// Serialize
byte [] serializedRecord = record.serialize();
// Strip header
byte [] recordData = new byte[serializedRecord.length-4];
System.arraycopy(serializedRecord, 4, recordData, 0, recordData.length);
// Deserialize
record = new CFRuleRecord(new TestcaseRecordInputStream(CFRuleRecord.sid, (short)recordData.length, recordData));
// Serialize again
byte[] output = record.serialize();
// Compare
assertEquals("Output size", recordData.length+4, output.length); //includes sid+recordlength
for (int i = 0; i < recordData.length;i++)
{
assertEquals("CFRuleRecord doesn't match", recordData[i], output[i+4]);
}
}
private void testCFRuleRecord(CFRuleRecord record)
{
FontFormatting fontFormatting = new FontFormatting();
testFontFormattingAccessors(fontFormatting);
assertFalse(record.containsFontFormattingBlock());
record.setFontFormatting(fontFormatting);
assertTrue(record.containsFontFormattingBlock());
BorderFormatting borderFormatting = new BorderFormatting();
testBorderFormattingAccessors(borderFormatting);
assertFalse(record.containsBorderFormattingBlock());
record.setBorderFormatting(borderFormatting);
assertTrue(record.containsBorderFormattingBlock());
assertFalse(record.isLeftBorderModified());
record.setLeftBorderModified(true);
assertTrue(record.isLeftBorderModified());
assertFalse(record.isRightBorderModified());
record.setRightBorderModified(true);
assertTrue(record.isRightBorderModified());
assertFalse(record.isTopBorderModified());
record.setTopBorderModified(true);
assertTrue(record.isTopBorderModified());
assertFalse(record.isBottomBorderModified());
record.setBottomBorderModified(true);
assertTrue(record.isBottomBorderModified());
assertFalse(record.isTopLeftBottomRightBorderModified());
record.setTopLeftBottomRightBorderModified(true);
assertTrue(record.isTopLeftBottomRightBorderModified());
assertFalse(record.isBottomLeftTopRightBorderModified());
record.setBottomLeftTopRightBorderModified(true);
assertTrue(record.isBottomLeftTopRightBorderModified());
PatternFormatting patternFormatting = new PatternFormatting();
testPatternFormattingAccessors(patternFormatting);
assertFalse(record.containsPatternFormattingBlock());
record.setPatternFormatting(patternFormatting);
assertTrue(record.containsPatternFormattingBlock());
assertFalse(record.isPatternBackgroundColorModified());
record.setPatternBackgroundColorModified(true);
assertTrue(record.isPatternBackgroundColorModified());
assertFalse(record.isPatternColorModified());
record.setPatternColorModified(true);
assertTrue(record.isPatternColorModified());
assertFalse(record.isPatternStyleModified());
record.setPatternStyleModified(true);
assertTrue(record.isPatternStyleModified());
}
private void testPatternFormattingAccessors(PatternFormatting patternFormatting)
{
patternFormatting.setFillBackgroundColor(HSSFColor.GREEN.index);
assertEquals(HSSFColor.GREEN.index,patternFormatting.getFillBackgroundColor());
patternFormatting.setFillForegroundColor(HSSFColor.INDIGO.index);
assertEquals(HSSFColor.INDIGO.index,patternFormatting.getFillForegroundColor());
patternFormatting.setFillPattern(PatternFormatting.DIAMONDS);
assertEquals(PatternFormatting.DIAMONDS,patternFormatting.getFillPattern());
}
private void testBorderFormattingAccessors(BorderFormatting borderFormatting)
{
borderFormatting.setBackwardDiagonalOn(false);
assertFalse(borderFormatting.isBackwardDiagonalOn());
borderFormatting.setBackwardDiagonalOn(true);
assertTrue(borderFormatting.isBackwardDiagonalOn());
borderFormatting.setBorderBottom(BorderFormatting.BORDER_DOTTED);
assertEquals(BorderFormatting.BORDER_DOTTED, borderFormatting.getBorderBottom());
borderFormatting.setBorderDiagonal(BorderFormatting.BORDER_MEDIUM);
assertEquals(BorderFormatting.BORDER_MEDIUM, borderFormatting.getBorderDiagonal());
borderFormatting.setBorderLeft(BorderFormatting.BORDER_MEDIUM_DASH_DOT_DOT);
assertEquals(BorderFormatting.BORDER_MEDIUM_DASH_DOT_DOT, borderFormatting.getBorderLeft());
borderFormatting.setBorderRight(BorderFormatting.BORDER_MEDIUM_DASHED);
assertEquals(BorderFormatting.BORDER_MEDIUM_DASHED, borderFormatting.getBorderRight());
borderFormatting.setBorderTop(BorderFormatting.BORDER_HAIR);
assertEquals(BorderFormatting.BORDER_HAIR, borderFormatting.getBorderTop());
borderFormatting.setBottomBorderColor(HSSFColor.AQUA.index);
assertEquals(HSSFColor.AQUA.index, borderFormatting.getBottomBorderColor());
borderFormatting.setDiagonalBorderColor(HSSFColor.RED.index);
assertEquals(HSSFColor.RED.index, borderFormatting.getDiagonalBorderColor());
assertFalse(borderFormatting.isForwardDiagonalOn());
borderFormatting.setForwardDiagonalOn(true);
assertTrue(borderFormatting.isForwardDiagonalOn());
borderFormatting.setLeftBorderColor(HSSFColor.BLACK.index);
assertEquals(HSSFColor.BLACK.index, borderFormatting.getLeftBorderColor());
borderFormatting.setRightBorderColor(HSSFColor.BLUE.index);
assertEquals(HSSFColor.BLUE.index, borderFormatting.getRightBorderColor());
borderFormatting.setTopBorderColor(HSSFColor.GOLD.index);
assertEquals(HSSFColor.GOLD.index, borderFormatting.getTopBorderColor());
}
private void testFontFormattingAccessors(FontFormatting fontFormatting)
{
// Check for defaults
assertFalse(fontFormatting.isEscapementTypeModified());
assertFalse(fontFormatting.isFontCancellationModified());
assertFalse(fontFormatting.isFontCondenseModified());
assertFalse(fontFormatting.isFontOutlineModified());
assertFalse(fontFormatting.isFontShadowModified());
assertFalse(fontFormatting.isFontStyleModified());
assertFalse(fontFormatting.isUnderlineTypeModified());
assertFalse(fontFormatting.isBold());
assertFalse(fontFormatting.isCondenseOn());
assertFalse(fontFormatting.isItalic());
assertFalse(fontFormatting.isOutlineOn());
assertFalse(fontFormatting.isShadowOn());
assertFalse(fontFormatting.isStruckout());
assertEquals(0, fontFormatting.getEscapementType());
assertEquals(-1, fontFormatting.getFontColorIndex());
assertEquals(-1, fontFormatting.getFontHeight());
assertEquals(400, fontFormatting.getFontWeight());
assertEquals(0, fontFormatting.getUnderlineType());
fontFormatting.setBold(true);
assertTrue(fontFormatting.isBold());
fontFormatting.setBold(false);
assertFalse(fontFormatting.isBold());
fontFormatting.setCondense(true);
assertTrue(fontFormatting.isCondenseOn());
fontFormatting.setCondense(false);
assertFalse(fontFormatting.isCondenseOn());
fontFormatting.setEscapementType(FontFormatting.SS_SUB);
assertEquals(FontFormatting.SS_SUB, fontFormatting.getEscapementType());
fontFormatting.setEscapementType(FontFormatting.SS_SUPER);
assertEquals(FontFormatting.SS_SUPER, fontFormatting.getEscapementType());
fontFormatting.setEscapementType(FontFormatting.SS_NONE);
assertEquals(FontFormatting.SS_NONE, fontFormatting.getEscapementType());
fontFormatting.setEscapementTypeModified(false);
assertFalse(fontFormatting.isEscapementTypeModified());
fontFormatting.setEscapementTypeModified(true);
assertTrue(fontFormatting.isEscapementTypeModified());
fontFormatting.setFontCancellationModified(false);
assertFalse(fontFormatting.isFontCancellationModified());
fontFormatting.setFontCancellationModified(true);
assertTrue(fontFormatting.isFontCancellationModified());
fontFormatting.setFontColorIndex((short)10);
assertEquals(10,fontFormatting.getFontColorIndex());
fontFormatting.setFontCondenseModified(false);
assertFalse(fontFormatting.isFontCondenseModified());
fontFormatting.setFontCondenseModified(true);
assertTrue(fontFormatting.isFontCondenseModified());
fontFormatting.setFontHeight((short)100);
assertEquals(100,fontFormatting.getFontHeight());
fontFormatting.setFontOutlineModified(false);
assertFalse(fontFormatting.isFontOutlineModified());
fontFormatting.setFontOutlineModified(true);
assertTrue(fontFormatting.isFontOutlineModified());
fontFormatting.setFontShadowModified(false);
assertFalse(fontFormatting.isFontShadowModified());
fontFormatting.setFontShadowModified(true);
assertTrue(fontFormatting.isFontShadowModified());
fontFormatting.setFontStyleModified(false);
assertFalse(fontFormatting.isFontStyleModified());
fontFormatting.setFontStyleModified(true);
assertTrue(fontFormatting.isFontStyleModified());
fontFormatting.setItalic(false);
assertFalse(fontFormatting.isItalic());
fontFormatting.setItalic(true);
assertTrue(fontFormatting.isItalic());
fontFormatting.setOutline(false);
assertFalse(fontFormatting.isOutlineOn());
fontFormatting.setOutline(true);
assertTrue(fontFormatting.isOutlineOn());
fontFormatting.setShadow(false);
assertFalse(fontFormatting.isShadowOn());
fontFormatting.setShadow(true);
assertTrue(fontFormatting.isShadowOn());
fontFormatting.setStrikeout(false);
assertFalse(fontFormatting.isStruckout());
fontFormatting.setStrikeout(true);
assertTrue(fontFormatting.isStruckout());
fontFormatting.setUnderlineType(FontFormatting.U_DOUBLE_ACCOUNTING);
assertEquals(FontFormatting.U_DOUBLE_ACCOUNTING, fontFormatting.getUnderlineType());
fontFormatting.setUnderlineTypeModified(false);
assertFalse(fontFormatting.isUnderlineTypeModified());
fontFormatting.setUnderlineTypeModified(true);
assertTrue(fontFormatting.isUnderlineTypeModified());
}
public static void main(String[] ignored_args)
{
System.out.println("Testing org.apache.poi.hssf.record.CFRuleRecord");
junit.textui.TestRunner.run(TestCFRuleRecord.class);
}
}

111
src/testcases/org/apache/poi/hssf/record/aggregates/TestCFRecordsAggregate.java Normal file
View File

@ -0,0 +1,111 @@
/* ====================================================================
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==================================================================== */
package org.apache.poi.hssf.record.aggregates;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import junit.framework.TestCase;
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.cf.CellRange;
/**
* Tests the serialization and deserialization of the CFRecordsAggregate
* class works correctly.
*
* @author Dmitriy Kumshayev
*/
public class TestCFRecordsAggregate
extends TestCase
{
public TestCFRecordsAggregate(String name)
{
super(name);
}
public void testCFRecordsAggregate()
{
CFRecordsAggregate record = new CFRecordsAggregate();
List recs = new ArrayList();
CFHeaderRecord header = new CFHeaderRecord();
CFRuleRecord rule1 = new CFRuleRecord();
CFRuleRecord rule2 = new CFRuleRecord();
CFRuleRecord rule3 = new CFRuleRecord();
header.setNumberOfConditionalFormats(3);
CellRange range1 = new CellRange(0,1,(short)0,(short)0);
CellRange range2 = new CellRange(0,1,(short)2,(short)2);
List cellRanges = new ArrayList();
cellRanges.add(range1);
cellRanges.add(range2);
header.setCellRanges(cellRanges);
recs.add(header);
recs.add(rule1);
recs.add(rule2);
recs.add(rule3);
record = CFRecordsAggregate.createCFAggregate(recs, 0);
// Serialize
byte [] serializedRecord = record.serialize();
InputStream in = new ByteArrayInputStream(serializedRecord);
//Parse
recs = RecordFactory.createRecords(in);
// Verify
assertNotNull(recs);
assertEquals(4, recs.size());
header = (CFHeaderRecord)recs.get(0);
rule1 = (CFRuleRecord)recs.get(1);
rule2 = (CFRuleRecord)recs.get(2);
rule3 = (CFRuleRecord)recs.get(3);
cellRanges = header.getCellRanges();
assertEquals(2, cellRanges.size());
assertEquals(3, header.getNumberOfConditionalFormats());
record = CFRecordsAggregate.createCFAggregate(recs, 0);
record = record.cloneCFAggregate();
assertNotNull(record.getHeader());
assertEquals(3,record.getRules().size());
header = record.getHeader();
rule1 = (CFRuleRecord)record.getRules().get(0);
rule2 = (CFRuleRecord)record.getRules().get(1);
rule3 = (CFRuleRecord)record.getRules().get(2);
cellRanges = header.getCellRanges();
assertEquals(2, cellRanges.size());
assertEquals(3, header.getNumberOfConditionalFormats());
}
public static void main(String[] ignored_args)
{
System.out.println("Testing org.apache.poi.hssf.record.aggregates.CFRecordsAggregate");
junit.textui.TestRunner.run(TestCFRecordsAggregate.class);
}
}

139
src/testcases/org/apache/poi/hssf/record/cf/TestCellRange.java Normal file
View File

@ -0,0 +1,139 @@
/* ====================================================================
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==================================================================== */
package org.apache.poi.hssf.record.cf;
import junit.framework.TestCase;
/**
* Tests CellRange operations.
*/
public class TestCellRange extends TestCase
{
private static final CellRange biggest = new CellRange(0, -1,(short) 0,(short)-1);
private static final CellRange tenthColumn = new CellRange(0, -1,(short)10,(short)10);
private static final CellRange tenthRow = new CellRange(10,10,(short) 0,(short)-1);
private static final CellRange box10x10 = new CellRange(0, 10,(short) 0,(short)10);
private static final CellRange box9x9 = new CellRange(0, 9,(short) 0,(short) 9);
private static final CellRange box10to20c = new CellRange(0, 10,(short)10,(short)20);
private static final CellRange oneCell = new CellRange(10,10,(short)10,(short)10);
boolean [][] contanis = new boolean[][]
{
// biggest, tenthColumn, tenthRow, box10x10, box9x9, box10to20c, oneCell
/*biggest */ new boolean[]{true, true , true , true , true , true , true},
/*tenthColumn*/ new boolean[]{false, true , false, false, false, false, true},
/*tenthRow */ new boolean[]{false, false, true , false, false, false, true},
/*box10x10 */ new boolean[]{false, false, false, true , true , false, true},
/*box9x9 */ new boolean[]{false, false, false, false, true , false, false},
/*box10to20c */ new boolean[]{false, false, false, false, false, true , true},
/*oneCell */ new boolean[]{false, false, false, false, false, false, true},
} ;
public void testContainsMethod()
{
CellRange [] ranges = new CellRange[]{biggest,tenthColumn,tenthRow,box10x10,box9x9,box10to20c,oneCell};
testContainsMethod(contanis,ranges);
}
private void testContainsMethod(boolean[][]contains,CellRange[] ranges)
{
for(int i=0; i!=ranges.length;i++)
{
for(int j=0; j!=ranges.length;j++)
{
assertEquals("("+i+","+j+"): ",contains[i][j],ranges[i].contains(ranges[j]));
}
}
}
private static final CellRange col1 = new CellRange(0, -1,(short) 1,(short)1);
private static final CellRange col2 = new CellRange(0, -1,(short) 2,(short)2);
private static final CellRange row1 = new CellRange(1, 1,(short) 0,(short)-1);
private static final CellRange row2 = new CellRange(2, 2,(short) 0,(short)-1);
private static final CellRange box0 = new CellRange( 0, 2,(short) 0,(short)2);
private static final CellRange box1 = new CellRange( 0, 1,(short) 0,(short)1);
private static final CellRange box2 = new CellRange( 0, 1,(short) 2,(short)3);
private static final CellRange box3 = new CellRange( 2, 3,(short) 0,(short)1);
private static final CellRange box4 = new CellRange( 2, 3,(short) 2,(short)3);
private static final CellRange box5 = new CellRange( 1, 3,(short) 1,(short)3);
public void testHasSharedBorderMethod()
{
assertFalse(col1.hasSharedBorder(col1));
assertFalse(col2.hasSharedBorder(col2));
assertTrue(col1.hasSharedBorder(col2));
assertTrue(col2.hasSharedBorder(col1));
assertFalse(row1.hasSharedBorder(row1));
assertFalse(row2.hasSharedBorder(row2));
assertTrue(row1.hasSharedBorder(row2));
assertTrue(row2.hasSharedBorder(row1));
assertFalse(row1.hasSharedBorder(col1));
assertFalse(row1.hasSharedBorder(col2));
assertFalse(col1.hasSharedBorder(row1));
assertFalse(col2.hasSharedBorder(row1));
assertFalse(row2.hasSharedBorder(col1));
assertFalse(row2.hasSharedBorder(col2));
assertFalse(col1.hasSharedBorder(row2));
assertFalse(col2.hasSharedBorder(row2));
assertTrue(col2.hasSharedBorder(col1));
assertFalse(box1.hasSharedBorder(box1));
assertTrue(box1.hasSharedBorder(box2));
assertTrue(box1.hasSharedBorder(box3));
assertFalse(box1.hasSharedBorder(box4));
assertTrue(box2.hasSharedBorder(box1));
assertFalse(box2.hasSharedBorder(box2));
assertFalse(box2.hasSharedBorder(box3));
assertTrue(box2.hasSharedBorder(box4));
assertTrue(box3.hasSharedBorder(box1));
assertFalse(box3.hasSharedBorder(box2));
assertFalse(box3.hasSharedBorder(box3));
assertTrue(box3.hasSharedBorder(box4));
assertFalse(box4.hasSharedBorder(box1));
assertTrue(box4.hasSharedBorder(box2));
assertTrue(box4.hasSharedBorder(box3));
assertFalse(box4.hasSharedBorder(box4));
}
public void testIntersectMethod()
{
assertEquals( CellRange.OVERLAP,box0.intersect(box5));
assertEquals( CellRange.OVERLAP,box5.intersect(box0));
assertEquals(CellRange.NO_INTERSECTION,box1.intersect(box4));
assertEquals(CellRange.NO_INTERSECTION,box4.intersect(box1));
assertEquals(CellRange.NO_INTERSECTION,box2.intersect(box3));
assertEquals(CellRange.NO_INTERSECTION,box3.intersect(box2));
assertEquals(CellRange.INSIDE,box0.intersect(box1));
assertEquals(CellRange.INSIDE,box0.intersect(box0));
assertEquals(CellRange.ENCLOSES,box1.intersect(box0));
assertEquals(CellRange.INSIDE,tenthColumn.intersect(oneCell));
assertEquals(CellRange.ENCLOSES,oneCell.intersect(tenthColumn));
assertEquals(CellRange.OVERLAP,tenthColumn.intersect(tenthRow));
assertEquals(CellRange.OVERLAP,tenthRow.intersect(tenthColumn));
assertEquals(CellRange.INSIDE,tenthColumn.intersect(tenthColumn));
assertEquals(CellRange.INSIDE,tenthRow.intersect(tenthRow));
}
}