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

1. initial support for rich text in xssf"

Browse Source 
2. cleaned common ooxml-ole2 interfaces, removed ole2-specific stuff
3. added new examples from the quick guide
4. misc xssf refactoring, tending to use enums intstead of final static constants
5. refactored XSSFFont
6. included test-ooxml and jar-ooxml in the dist target, they are part of release and should be there

git-svn-id: https://svn.apache.org/repos/asf/poi/branches/ooxml@696584 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Yegor Kozlov 2008-09-18 07:42:40 +00:00
parent 35962f976b
commit 40f525ecbd
34 changed files with 1572 additions and 1013 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
build.xml
View File

@ -555,8 +555,8 @@ under the License.
<delete file="${version.java}" /> <delete file="${version.java}" />
</target> </target>
<target name="test" depends="test-main,test-scratchpad,test-contrib" <target name="test" depends="test-main,test-scratchpad,test-contrib,test-ooxml"
description="Tests main, contrib and scratchpad"/> description="Tests main, contrib, scratchpad and ooxml"/>
<target name="-test-main-check"> <target name="-test-main-check">
<uptodate property="main.test.notRequired" targetfile="${main.testokfile}"> <uptodate property="main.test.notRequired" targetfile="${main.testokfile}">
@ -1206,7 +1206,7 @@ FORREST_HOME environment variable!</echo>
</manifest> </manifest>
</jar> </jar>
</target> </target>
<target name="jar" depends="compile, compile-version, jar-14" description="Creates jar files for distribution"> <target name="jar" depends="compile, compile-version, jar-14, jar-ooxml" description="Creates jar files for distribution">
<jar destfile="${dist.dir}/${jar.name}-${version.id}-${DSTAMP}.jar"> <jar destfile="${dist.dir}/${jar.name}-${version.id}-${DSTAMP}.jar">
<fileset dir="${main.output.dir}" /> <fileset dir="${main.output.dir}" />
<fileset dir="legal/" /> <fileset dir="legal/" />

76
src/examples/src/org/apache/poi/xssf/usermodel/examples/CreateCell.java Executable file
View File

@ -0,0 +1,76 @@
/* ====================================================================
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.xssf.usermodel.examples;
import java.io.FileOutputStream;
import java.util.Date;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.xssf.usermodel.XSSFRichTextString;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
/**
*
*/
public class CreateCell {
public static void main(String[]args) throws Exception {
Workbook wb = new XSSFWorkbook();
CreationHelper creationHelper = wb.getCreationHelper();
Sheet sheet = wb.createSheet("new sheet");
// Create a row and put some cells in it. Rows are 0 based.
Row row = sheet.createRow((short)0);
// Create a cell and put a value in it.
Cell cell = row.createCell((short)0);
cell.setCellValue(1);
//numeric value
row.createCell(1).setCellValue(1.2);
//plain string value
row.createCell(2).setCellValue("This is a string cell");
//rich text string
RichTextString str = creationHelper.createRichTextString("Apache");
Font font = wb.createFont();
font.setItalic(true);
font.setUnderline(Font.U_SINGLE);
str.applyFont(font);
row.createCell(3).setCellValue(str);
//boolean value
row.createCell(4).setCellValue(true);
//formula
row.createCell(5).setCellFormula("SUM(A1:B1)");
//date
CellStyle style = wb.createCellStyle();
style.setDataFormat(creationHelper.createDataFormat().getFormat("m/d/yy h:mm"));
cell = row.createCell(6);
cell.setCellValue(new Date());
cell.setCellStyle(style);
// Write the output to a file
FileOutputStream fileOut = new FileOutputStream("ooxml-cell.xlsx");
wb.write(fileOut);
fileOut.close();
}
}

4
src/examples/src/org/apache/poi/xssf/usermodel/examples/CreateNewSpreadsheet.java
View File

@ -46,7 +46,7 @@ public class CreateNewSpreadsheet {
s2.getRow(2).createCell(1).setCellValue(createHelper.createRichTextString("Sheet 2")); s2.getRow(2).createCell(1).setCellValue(createHelper.createRichTextString("Sheet 2"));
/*
// Comment // Comment
Comment comment = ((XSSFSheet)s1).createComment(); Comment comment = ((XSSFSheet)s1).createComment();
// HSSFPatriarch patriach = (HSSFPatriarch)s1.createDrawingPatriarch(); // HSSFPatriarch patriach = (HSSFPatriarch)s1.createDrawingPatriarch();
@ -62,7 +62,7 @@ public class CreateNewSpreadsheet {
hyperlink.setLabel("Link to POI"); hyperlink.setLabel("Link to POI");
s1.getRow(1).createCell(1).setHyperlink(hyperlink); s1.getRow(1).createCell(1).setHyperlink(hyperlink);
s1.getRow(1).getCell(1).setCellValue(createHelper.createRichTextString("Link to POI")); s1.getRow(1).getCell(1).setCellValue(createHelper.createRichTextString("Link to POI"));
*/
// Save // Save
FileOutputStream fout = new FileOutputStream("NewFile.xlsx"); FileOutputStream fout = new FileOutputStream("NewFile.xlsx");
wb.write(fout); wb.write(fout);

65
src/examples/src/org/apache/poi/xssf/usermodel/examples/CreateUserDefinedDataFormats.java Executable file
View File

@ -0,0 +1,65 @@
/* ====================================================================
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.xssf.usermodel.examples;
import java.io.FileOutputStream;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.DataFormat;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
/**
* How to set user-defined date formats
*/
public class CreateUserDefinedDataFormats {
public static void main(String[]args) throws Exception {
Workbook wb = new XSSFWorkbook();
Sheet sheet = wb.createSheet("format sheet");
CellStyle style;
DataFormat format = wb.createDataFormat();
Row row;
Cell cell;
short rowNum = 0;
short colNum = 0;
row = sheet.createRow(rowNum++);
cell = row.createCell(colNum);
cell.setCellValue(11111.25);
style = wb.createCellStyle();
style.setDataFormat(format.getFormat("0.0"));
cell.setCellStyle(style);
row = sheet.createRow(rowNum++);
cell = row.createCell(colNum);
cell.setCellValue(11111.25);
style = wb.createCellStyle();
style.setDataFormat(format.getFormat("#,##0.0000"));
cell.setCellStyle(style);
FileOutputStream fileOut = new FileOutputStream("ooxml_dataFormat.xlsx");
wb.write(fileOut);
fileOut.close();
}
}

10
src/examples/src/org/apache/poi/xssf/usermodel/examples/WorkingWithBorders.java
View File

@ -17,7 +17,7 @@
package org.apache.poi.xssf.usermodel.examples; package org.apache.poi.xssf.usermodel.examples;
import org.apache.poi.xssf.usermodel.XSSFWorkbook; import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.apache.poi.xssf.util.IndexedColors; import org.apache.poi.xssf.usermodel.IndexedColors;
import org.apache.poi.ss.usermodel.*; import org.apache.poi.ss.usermodel.*;
import java.io.FileOutputStream; import java.io.FileOutputStream;
@ -40,13 +40,13 @@ public class WorkingWithBorders {
// Style the cell with borders all around. // Style the cell with borders all around.
CellStyle style = wb.createCellStyle(); CellStyle style = wb.createCellStyle();
style.setBorderBottom(CellStyle.BORDER_THIN); style.setBorderBottom(CellStyle.BORDER_THIN);
style.setBottomBorderColor((short)IndexedColors.BLACK); style.setBottomBorderColor(IndexedColors.BLACK.getIndex());
style.setBorderLeft(CellStyle.BORDER_THIN); style.setBorderLeft(CellStyle.BORDER_THIN);
style.setLeftBorderColor((short)IndexedColors.GREEN); style.setLeftBorderColor(IndexedColors.GREEN.getIndex());
style.setBorderRight(CellStyle.BORDER_THIN); style.setBorderRight(CellStyle.BORDER_THIN);
style.setRightBorderColor((short)IndexedColors.BLUE); style.setRightBorderColor(IndexedColors.BLUE.getIndex());
style.setBorderTop(CellStyle.BORDER_MEDIUM_DASHED); style.setBorderTop(CellStyle.BORDER_MEDIUM_DASHED);
style.setTopBorderColor((short)IndexedColors.BLACK); style.setTopBorderColor(IndexedColors.BLACK.getIndex());
cell.setCellStyle(style); cell.setCellStyle(style);
// Write the output to a file // Write the output to a file

4
src/examples/src/org/apache/poi/xssf/usermodel/examples/WorkingWithFonts.java
View File

@ -21,8 +21,8 @@ import org.apache.poi.hssf.util.HSSFColor;
import org.apache.poi.ss.usermodel.*; import org.apache.poi.ss.usermodel.*;
import org.apache.poi.xssf.usermodel.XSSFWorkbook; import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.apache.poi.xssf.usermodel.XSSFRichTextString; import org.apache.poi.xssf.usermodel.XSSFRichTextString;
import org.apache.poi.xssf.usermodel.IndexedColors;
import org.apache.poi.xssf.usermodel.extensions.XSSFColor; import org.apache.poi.xssf.usermodel.extensions.XSSFColor;
import org.apache.poi.xssf.util.IndexedColors;
import java.io.FileOutputStream; import java.io.FileOutputStream;
@ -42,7 +42,7 @@ public class WorkingWithFonts {
font.setFontHeightInPoints((short)24); font.setFontHeightInPoints((short)24);
font.setFontName("Courier New"); font.setFontName("Courier New");
font.setColor((short)IndexedColors.RED); font.setColor(IndexedColors.RED.getIndex());
font.setItalic(true); font.setItalic(true);
font.setStrikeout(true); font.setStrikeout(true);

62
src/examples/src/org/apache/poi/xssf/usermodel/examples/WorkingWithRichText.java Executable file
View File

@ -0,0 +1,62 @@
/* ====================================================================
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.xssf.usermodel.examples;
import org.apache.poi.xssf.usermodel.*;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.hssf.util.HSSFColor;
import org.apache.xmlbeans.XmlOptions;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.*;
import java.io.FileOutputStream;
import java.io.Writer;
import java.io.StringWriter;
/**
* Demonstrates how to work with rich text
*/
public class WorkingWithRichText {
public static void main(String[] args)
throws Exception
{
XSSFWorkbook wb = new XSSFWorkbook();
XSSFSheet sheet = wb.createSheet();
XSSFRow row = sheet.createRow((short) 2);
XSSFCell cell = row.createCell(1);
XSSFRichTextString rt = new XSSFRichTextString("The quick");
XSSFFont font1 = wb.createFont();
font1.setBold(true);
rt.append(" brown fox", font1);
XSSFFont font2 = wb.createFont();
font2.setItalic(true);
font2.setColor(IndexedColors.RED.getIndex());
rt.applyFont((short)0);
cell.setCellValue(rt);
// Write the output to a file
FileOutputStream fileOut = new FileOutputStream("rich_text.xlsx");
wb.write(fileOut);
fileOut.close();
}
}

2
src/ooxml/interfaces-jdk14/org/apache/poi/ss/usermodel/Comment.java
View File

@ -18,6 +18,6 @@
package org.apache.poi.ss.usermodel; package org.apache.poi.ss.usermodel;
public interface Comment { public interface Comment {
public void setRow(short row); public void setRow(int row);
public void setColumn(short row); public void setColumn(short row);
} }

2
src/ooxml/interfaces-jdk15/org/apache/poi/ss/usermodel/Cell.java
View File

@ -173,6 +173,8 @@ public interface Cell {
void setCellValue(RichTextString value); void setCellValue(RichTextString value);
void setCellValue(String value);
void setCellFormula(String formula); void setCellFormula(String formula);
String getCellFormula(); String getCellFormula();

17
src/ooxml/interfaces-jdk15/org/apache/poi/ss/usermodel/Color.java
View File

@ -19,22 +19,5 @@ package org.apache.poi.ss.usermodel;
public interface Color { public interface Color {
/**
* @return index to the standard palette
*/
short getIndex();
/**
* @return triplet representation like that in Excel
*/
short[] getTriplet();
/**
* @return a hex string exactly like a gnumeric triplet
*/
String getHexString();
} }

26
src/ooxml/interfaces-jdk15/org/apache/poi/ss/usermodel/Font.java
View File

@ -129,14 +129,6 @@ public interface Font {
String getFontName(); String getFontName();
/**
* get the index within the HSSFWorkbook (sequence within the collection of Font objects)
* @return unique index number of the underlying record this Font represents (probably you don't care
* unless you're comparing which one is which)
*/
short getIndex();
/** /**
* set the font height in unit's of 1/20th of a point. Maybe you might want to * set the font height in unit's of 1/20th of a point. Maybe you might want to
* use the setFontHeightInPoints which matches to the familiar 10, 12, 14 etc.. * use the setFontHeightInPoints which matches to the familiar 10, 12, 14 etc..
@ -217,24 +209,6 @@ public interface Font {
*/ */
short getColor(); short getColor();
/**
* set the boldness to use
* @param boldweight
* @see #BOLDWEIGHT_NORMAL
* @see #BOLDWEIGHT_BOLD
*/
void setBoldweight(short boldweight);
/**
* get the boldness to use
* @return boldweight
* @see #BOLDWEIGHT_NORMAL
* @see #BOLDWEIGHT_BOLD
*/
short getBoldweight();
/** /**
* set normal,super or subscript. * set normal,super or subscript.
* @param offset type to use (none,super,sub) * @param offset type to use (none,super,sub)

24
src/ooxml/interfaces-jdk15/org/apache/poi/ss/usermodel/RichTextString.java
View File

@ -25,8 +25,6 @@ package org.apache.poi.ss.usermodel;
* @author Jason Height (jheight at apache.org) * @author Jason Height (jheight at apache.org)
*/ */
public interface RichTextString { public interface RichTextString {
/** Place holder for indicating that NO_FONT has been applied here */
public static final short NO_FONT = 0;
/** /**
* Applies a font to the specified characters of a string. * Applies a font to the specified characters of a string.
@ -68,20 +66,8 @@ public interface RichTextString {
int length(); int length();
/** /**
* Returns the font in use at a particular index. * @return The number of formatting runs used.
* *
* @param index The index.
* @return The font that's currently being applied at that
* index or null if no font is being applied or the
* index is out of range.
*/
short getFontAtIndex(int index);
/**
* @return The number of formatting runs used. There will always be at
* least one of font NO_FONT.
*
* @see #NO_FONT
*/ */
int numFormattingRuns(); int numFormattingRuns();
@ -92,14 +78,6 @@ public interface RichTextString {
*/ */
int getIndexOfFormattingRun(int index); int getIndexOfFormattingRun(int index);
/**
* Gets the font used in a particular formatting run.
*
* @param index the index of the formatting run
* @return the font number used.
*/
short getFontOfFormattingRun(int index);
/** /**
* Applies the specified font to the entire string. * Applies the specified font to the entire string.
* *

9
src/ooxml/java/org/apache/poi/POIXMLDocument.java
View File

@ -100,7 +100,14 @@ public abstract class POIXMLDocument {
throw new IOException(e.toString()); throw new IOException(e.toString());
} }
} }
public static Package openPackage(InputStream is) throws IOException {
try {
return Package.open(is);
} catch (InvalidFormatException e) {
throw new IOException(e.toString());
}
}
protected Package getPackage() { protected Package getPackage() {
return this.pkg; return this.pkg;
} }

42
src/ooxml/java/org/apache/poi/xssf/dev/XSSFSave.java Executable file
View File

@ -0,0 +1,42 @@
/* ====================================================================
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.xssf.dev;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import java.io.FileOutputStream;
/**
* Utility which loads a SpreadsheetML file and saves it back.
* This is a handy tool to investigate read-write round trip safety.
*
* @author Yegor Kozlov
*/
public class XSSFSave {
public static void main(String[] args) throws Exception {
for (int i = 0; i < args.length; i++) {
XSSFWorkbook wb = new XSSFWorkbook(args[i]);
int sep = args[i].lastIndexOf('.');
String outfile = args[i].substring(0, sep) + "-save.xlsx";
FileOutputStream out = new FileOutputStream(outfile);
wb.write(out);
out.close();
}
}
}

2
src/ooxml/java/org/apache/poi/xssf/model/SharedStringsTable.java
View File

@ -195,7 +195,7 @@ public class SharedStringsTable implements SharedStringSource, XSSFModel {
options.setUseDefaultNamespace(); options.setUseDefaultNamespace();
//re-create the sst table every time saving a workbook //re-create the sst table every time saving a workbook
SstDocument doc = SstDocument.Factory.newInstance(options); SstDocument doc = SstDocument.Factory.newInstance();
CTSst sst = doc.addNewSst(); CTSst sst = doc.addNewSst();
sst.setCount(count); sst.setCount(count);
sst.setUniqueCount(uniqueCount); sst.setUniqueCount(uniqueCount);

16
src/ooxml/java/org/apache/poi/xssf/model/StylesTable.java
View File

@ -20,6 +20,7 @@ package org.apache.poi.xssf.model;
import java.io.IOException; import java.io.IOException;
import java.io.InputStream; import java.io.InputStream;
import java.io.OutputStream; import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Enumeration; import java.util.Enumeration;
import java.util.Hashtable; import java.util.Hashtable;
import java.util.LinkedList; import java.util.LinkedList;
@ -59,7 +60,7 @@ import org.openxmlformats.schemas.spreadsheetml.x2006.main.StyleSheetDocument;
*/ */
public class StylesTable implements StylesSource, XSSFModel { public class StylesTable implements StylesSource, XSSFModel {
private final Hashtable<Long,String> numberFormats = new Hashtable<Long,String>(); private final Hashtable<Long,String> numberFormats = new Hashtable<Long,String>();
private final LinkedList<CTFont> fonts = new LinkedList<CTFont>(); private final ArrayList<CTFont> fonts = new ArrayList<CTFont>();
private final LinkedList<CTFill> fills = new LinkedList<CTFill>(); private final LinkedList<CTFill> fills = new LinkedList<CTFill>();
private final LinkedList<CTBorder> borders = new LinkedList<CTBorder>(); private final LinkedList<CTBorder> borders = new LinkedList<CTBorder>();
private final LinkedList<CTXf> styleXfs = new LinkedList<CTXf>(); private final LinkedList<CTXf> styleXfs = new LinkedList<CTXf>();
@ -230,7 +231,12 @@ public class StylesTable implements StylesSource, XSSFModel {
public int getNumCellStyles(){ public int getNumCellStyles(){
return styleXfs.size(); return styleXfs.size();
} }
/**
* get the size of fonts
*/
public int getNumberOfFonts(){
return this.fonts.size();
}
/** /**
* For unit testing only * For unit testing only
*/ */
@ -367,7 +373,7 @@ public class StylesTable implements StylesSource, XSSFModel {
return fill.putFill(fills); return fill.putFill(fills);
} }
private long putFont(XSSFFont font, LinkedList<CTFont> fonts) { private long putFont(XSSFFont font, ArrayList<CTFont> fonts) {
return font.putFont(fonts); return font.putFont(fonts);
} }
private void initialize() { private void initialize() {
@ -423,8 +429,8 @@ public class StylesTable implements StylesSource, XSSFModel {
XSSFFont font=new XSSFFont(ctFont); XSSFFont font=new XSSFFont(ctFont);
return font; return font;
*/ */
CTFont ctFont = CTFont.Factory.newInstance();
XSSFFont xssfFont=new XSSFFont(); XSSFFont xssfFont=new XSSFFont(ctFont);
xssfFont.setFontHeightInPoints(XSSFFont.DEFAULT_FONT_SIZE); xssfFont.setFontHeightInPoints(XSSFFont.DEFAULT_FONT_SIZE);
xssfFont.setColor(XSSFFont.DEFAULT_FONT_COLOR);//setTheme xssfFont.setColor(XSSFFont.DEFAULT_FONT_COLOR);//setTheme
xssfFont.setFontName(XSSFFont.DEFAULT_FONT_NAME); xssfFont.setFontName(XSSFFont.DEFAULT_FONT_NAME);

79
src/ooxml/java/org/apache/poi/xssf/usermodel/IndexedColors.java Executable file
View File

@ -0,0 +1,79 @@
package org.apache.poi.xssf.usermodel;
/**
* A deprecated indexing scheme for colours that is still required for some records, and for backwards
* compatibility with OLE2 formats.
*
* <p>
* Each element corresponds to a color index (zero-based). When using the default indexed color palette,
* the values are not written out, but instead are implied. When the color palette has been modified from default,
* then the entire color palette is used.
* </p>
*
* @author Yegor Kozlov
*/
public enum IndexedColors {
BLACK(8),
WHITE(9),
RED(10),
BRIGHT_GREEN(11),
BLUE(12),
YELLOW(13),
PINK(14),
TURQUOISE(15),
DARK_RED(16),
GREEN(17),
DARK_BLUE(18),
DARK_YELLOW(19),
VIOLET(20),
TEAL(21),
GREY_25_PERCENT(22),
GREY_50_PERCENT(23),
CORNFLOWER_BLUE(24),
MAROON(25),
LEMON_CHIFFON(26),
ORCHID(28),
CORAL(29),
ROYAL_BLUE(30),
LIGHT_CORNFLOWER_BLUE(31),
SKY_BLUE(40),
LIGHT_TURQUOISE(41),
LIGHT_GREEN(42),
LIGHT_YELLOW(43),
PALE_BLUE(44),
ROSE(45),
LAVENDER(46),
TAN(47),
LIGHT_BLUE(48),
AQUA(49),
LIME(50),
GOLD(51),
LIGHT_ORANGE(52),
ORANGE(53),
BLUE_GREY(54),
GREY_40_PERCENT(55),
DARK_TEAL(56),
SEA_GREEN(57),
DARK_GREEN(58),
OLIVE_GREEN(59),
BROWN(60),
PLUM(61),
INDIGO(62),
GREY_80_PERCENT(63);
private short index;
IndexedColors(int idx){
index = (short)idx;
}
/**
* Returns index of this color
*
* @return index of this color
*/
public short getIndex(){
return index;
}
}

12
src/ooxml/java/org/apache/poi/xssf/usermodel/XSSFCell.java
View File

@ -392,6 +392,10 @@ public final class XSSFCell implements Cell {
} }
public void setCellValue(String str) {
this.setCellValue(new XSSFRichTextString(str));
}
public void setCellValue(RichTextString value) { public void setCellValue(RichTextString value) {
if(this.cell.getT() == STCellType.INLINE_STR) { if(this.cell.getT() == STCellType.INLINE_STR) {
this.cell.setV(value.getString()); this.cell.setV(value.getString());
@ -401,6 +405,7 @@ public final class XSSFCell implements Cell {
this.cell.setT(STCellType.S); this.cell.setT(STCellType.S);
} }
XSSFRichTextString rt = (XSSFRichTextString)value; XSSFRichTextString rt = (XSSFRichTextString)value;
rt.setStylesTableReference(stylesSource);
int sRef = sharedStringSource.addEntry(rt.getCTRst()); int sRef = sharedStringSource.addEntry(rt.getCTRst());
this.cell.setV(Integer.toString(sRef)); this.cell.setV(Integer.toString(sRef));
} }
@ -437,13 +442,6 @@ public final class XSSFCell implements Cell {
} }
} }
/**
* Creates an XSSFRichTextString for you.
*/
public RichTextString createRichTextString(String text) {
return new XSSFRichTextString(text);
}
public Hyperlink getHyperlink() { public Hyperlink getHyperlink() {
return row.getSheet().getHyperlink(row.getRowNum(), cellNum); return row.getSheet().getHyperlink(row.getRowNum(), cellNum);
} }

2
src/ooxml/java/org/apache/poi/xssf/usermodel/XSSFCellStyle.java
View File

@ -417,7 +417,7 @@ public class XSSFCellStyle implements CellStyle {
return (short) getBorderColor(side).getIndexed(); return (short) getBorderColor(side).getIndexed();
} }
private void setBorderColorIndexed(BorderSide side, long color) { private void setBorderColorIndexed(BorderSide side, int color) {
getBorderColor(side).setIndexed(color); getBorderColor(side).setIndexed(color);
} }

897
src/ooxml/java/org/apache/poi/xssf/usermodel/XSSFFont.java
View File

@ -1,491 +1,406 @@
/* ==================================================================== /* ====================================================================
Licensed to the Apache Software Foundation (ASF) under one or more Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership. this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0 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 not use this file except in compliance with
the License. You may obtain a copy of the License at the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0 http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS, distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and See the License for the specific language governing permissions and
limitations under the License. limitations under the License.
==================================================================== */ ==================================================================== */
package org.apache.poi.xssf.usermodel; package org.apache.poi.xssf.usermodel;
import java.util.LinkedList; import org.apache.poi.ss.usermodel.Font;
import org.apache.poi.ss.usermodel.Font; import org.apache.poi.xssf.util.Charset;
import org.apache.poi.xssf.usermodel.extensions.XSSFColor;
import org.apache.poi.xssf.util.CTFontWrapper; import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTBooleanProperty;
import org.apache.poi.xssf.util.Charset; import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTColor;
import org.apache.poi.xssf.util.IndexedColors;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTBooleanProperty; import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTFont;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTColor; import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTFontName;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTFontScheme;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTFont; import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTFontSize;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTFontName; import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTIntProperty;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTFontScheme; import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTUnderlineProperty;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTFontSize; import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTVerticalAlignFontProperty;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTIntProperty; import org.openxmlformats.schemas.spreadsheetml.x2006.main.STFontScheme;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTUnderlineProperty; import org.openxmlformats.schemas.spreadsheetml.x2006.main.STUnderlineValues;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTVerticalAlignFontProperty; import org.openxmlformats.schemas.spreadsheetml.x2006.main.STVerticalAlignRun;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.STFontScheme;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.STUnderlineValues; import java.util.ArrayList;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.STVerticalAlignRun;
public class XSSFFont implements Font {
public class XSSFFont implements Font {
public static final int SCHEME_MAJOR=2;
public static final int SCHEME_MAJOR=2; public static final int SCHEME_MINOR=3;
public static final int SCHEME_MINOR=3; public static final int SCHEME_NONE=0;
public static final int SCHEME_NONE=0;
public static final int FONT_FAMILY_NOT_APPLICABLE=0;
public static final int FONT_FAMILY_NOT_APPLICABLE=0; public static final int FONT_FAMILY_ROMAN=1;
public static final int FONT_FAMILY_ROMAN=1; public static final int FONT_FAMILY_SWISS=2;
public static final int FONT_FAMILY_SWISS=2; public static final int FONT_FAMILY_MODERN=3;
public static final int FONT_FAMILY_MODERN=3; public static final int FONT_FAMILY_SCRIPT=4;
public static final int FONT_FAMILY_SCRIPT=4; public static final int FONT_FAMILY_DECORATIVE=5;
public static final int FONT_FAMILY_DECORATIVE=5;
public static final String DEFAULT_FONT_NAME="Calibri";
public static final String DEFAULT_FONT_NAME="Calibri"; public static final short DEFAULT_FONT_SIZE=11;
public static final short DEFAULT_FONT_SIZE=11; public static final short DEFAULT_FONT_COLOR = IndexedColors.BLACK.getIndex();
public static final short DEFAULT_FONT_COLOR=(short)IndexedColors.BLACK;
private CTFont ctFont;
private int index=0;
public XSSFFont(CTFont font) {
this.ctFont=font;
private CTFontWrapper fontWrapper; }
protected XSSFFont() {
this.ctFont = CTFont.Factory.newInstance();
public XSSFFont(CTFont font) { }
this.fontWrapper=new CTFontWrapper(font);
}
public CTFont getCTFont(){
/* return ctFont;
public XSSFFont(int index) { }
this.fontWrapper=new CTFontWrapper(font);
this.index=index; /**
} *
*/ */
public boolean getBold() {
public XSSFFont() { CTBooleanProperty bold=ctFont.sizeOfBArray() == 0 ? null : ctFont.getBArray(0);
this.fontWrapper = new CTFontWrapper(CTFont.Factory.newInstance()); return (bold!=null && bold.getVal());
} }
public CTFont getCTFont(){
return fontWrapper.getCTFont(); public byte getCharSet() {
} CTIntProperty charset= ctFont.sizeOfCharsetArray() == 0?null:ctFont.getCharsetArray(0);
if(charset!=null){
//this value must be set -- can't be null
public short getBoldweight() { switch (charset.getVal()) {
CTBooleanProperty bold=fontWrapper.getB(); case Charset.ANSI_CHARSET:
if(bold!=null && bold.getVal()) return Font.ANSI_CHARSET;
return Font.BOLDWEIGHT_BOLD;
else case Charset.DEFAULT_CHARSET:
return Font.BOLDWEIGHT_NORMAL; return Font.DEFAULT_CHARSET;
}
case Charset.SYMBOL_CHARSET:
return Font.SYMBOL_CHARSET;
public byte getCharSet() { default://maight be correct to return this byte value???
CTIntProperty charset= fontWrapper.getCharset(); return Byte.parseByte(Integer.toString(charset.getVal()));
if(charset!=null){ }
//this value must be set -- can't be null }
switch (charset.getVal()) { else
case Charset.ANSI_CHARSET: return Font.ANSI_CHARSET;
return Font.ANSI_CHARSET; }
case Charset.DEFAULT_CHARSET: public short getColor() {
return Font.DEFAULT_CHARSET; CTColor color=ctFont.sizeOfColorArray()==0?null: ctFont.getColorArray(0);
if(color == null) return Font.COLOR_NORMAL;
case Charset.SYMBOL_CHARSET:
return Font.SYMBOL_CHARSET; long index=color.getIndexed();
if (index==XSSFFont.DEFAULT_FONT_COLOR){
default://maight be correct to return this byte value??? return Font.COLOR_NORMAL;
return Byte.parseByte(Integer.toString(charset.getVal())); }
} else if(index == IndexedColors.RED.getIndex()){
} return Font.COLOR_RED;
else }
return Font.ANSI_CHARSET; else{
} return Short.parseShort(new Long(index).toString());
}
public short getColor() { }
CTColor color=fontWrapper.getColor();
long index=color.getIndexed();
if (index==XSSFFont.DEFAULT_FONT_COLOR){ public byte[] getRgbColor() {
return Font.COLOR_NORMAL; CTColor color=ctFont.sizeOfColorArray()==0?null: ctFont.getColorArray(0);
} return color.getRgb();
else if(index==IndexedColors.RED){ }
return Font.COLOR_RED;
} public short getThemeColor() {
else{ CTColor color=ctFont.sizeOfColorArray()==0?null: ctFont.getColorArray(0);
return Short.parseShort(new Long(index).toString()); long index=color.getTheme();
} return (short)index;
} }
public short getFontHeight() {
if(fontWrapper.getSz()!=null){ public short getFontHeight() {
double fontHeight= fontWrapper.getSz().getVal()/20; CTFontSize size=ctFont.sizeOfSzArray()==0?null: ctFont.getSzArray(0);
return (short)fontHeight; if(size!=null){
} double fontHeight= size.getVal()/20;
else return (short)fontHeight;
return DEFAULT_FONT_SIZE/20; }
} else
return DEFAULT_FONT_SIZE/20;
public short getFontHeightInPoints() { }
if(fontWrapper.getSz()!=null){
double fontHeight= fontWrapper.getSz().getVal();// /72; public short getFontHeightInPoints() {
return (short)fontHeight;//new Double(fontHeight).shortValue(); CTFontSize size=ctFont.sizeOfSzArray()==0?null: ctFont.getSzArray(0);
} if(size!=null){
else double fontHeight= size.getVal();
return DEFAULT_FONT_SIZE; return (short)fontHeight;
} }
else
//AGGIUNGERE CONTROLLO NULL return DEFAULT_FONT_SIZE;
public String getFontName() { }
if(fontWrapper.getName()!=null)
return fontWrapper.getName().getVal();
else public String getFontName() {
return DEFAULT_FONT_NAME; CTFontName name=ctFont.sizeOfNameArray()==0?null:ctFont.getNameArray(0);
} return name==null? null:name.getVal();
}
public short getIndex() {
// TODO Auto-generated method stub public boolean getItalic() {
return 0; CTBooleanProperty italic=ctFont.sizeOfIArray()==0?null:ctFont.getIArray(0);
} return italic!=null && italic.getVal();
}
public boolean getItalic() {
if(fontWrapper.getI()!=null) public boolean getStrikeout() {
return fontWrapper.getI().getVal(); CTBooleanProperty strike=ctFont.sizeOfStrikeArray()==0?null:ctFont.getStrikeArray(0);
else return strike!=null && strike.getVal();
return false; }
}
public short getTypeOffset() {
public boolean getStrikeout() { CTVerticalAlignFontProperty vAlign=ctFont.sizeOfVertAlignArray()==0?null:ctFont.getVertAlignArray(0);
if(fontWrapper.getStrike()!=null) if(vAlign!=null){
return fontWrapper.getStrike().getVal(); int val=vAlign.getVal().intValue();
else switch (val) {
return false; case STVerticalAlignRun.INT_BASELINE:
} return Font.SS_NONE;
case STVerticalAlignRun.INT_SUBSCRIPT:
public short getTypeOffset() { return Font.SS_SUB;
if(fontWrapper.getVertAlign()!=null){ case STVerticalAlignRun.INT_SUPERSCRIPT:
int val=fontWrapper.getVertAlign().getVal().intValue(); return Font.SS_SUPER;
switch (val) { default: throw new RuntimeException("Wrong offset value "+val);
case STVerticalAlignRun.INT_BASELINE: }
return Font.SS_NONE; }
case STVerticalAlignRun.INT_SUBSCRIPT: else
return Font.SS_SUB; return Font.SS_NONE;
case STVerticalAlignRun.INT_SUPERSCRIPT: }
return Font.SS_SUPER;
default: throw new RuntimeException("Wrong offset value "+val); public byte getUnderline() {
} CTUnderlineProperty underline=ctFont.sizeOfUArray()==0?null:ctFont.getUArray(0);
} if(underline!=null){
else switch (underline.getVal().intValue()) {
return Font.SS_NONE; case STUnderlineValues.INT_DOUBLE:
} return Font.U_DOUBLE;
case STUnderlineValues.INT_DOUBLE_ACCOUNTING:
public byte getUnderline() { return Font.U_DOUBLE_ACCOUNTING;
if(fontWrapper.getU()!=null){
//attenzione : -- get val pu˜ tornare null---- case STUnderlineValues.INT_SINGLE_ACCOUNTING:
switch (fontWrapper.getU().getVal().intValue()) { return Font.U_SINGLE_ACCOUNTING;
case STUnderlineValues.INT_DOUBLE:
return Font.U_DOUBLE; case STUnderlineValues.INT_NONE:
case STUnderlineValues.INT_DOUBLE_ACCOUNTING: return Font.U_NONE;
return Font.U_DOUBLE_ACCOUNTING;
case STUnderlineValues.INT_SINGLE:
case STUnderlineValues.INT_SINGLE_ACCOUNTING: default:
return Font.U_SINGLE_ACCOUNTING; return Font.U_SINGLE;
}
case STUnderlineValues.INT_NONE: }
return Font.U_NONE; return Font.U_NONE;
}
case STUnderlineValues.INT_SINGLE:
default: /**
return Font.U_SINGLE; * Set characters in bold face font style.
} * If omitted, the default value is true.
} */
return Font.U_NONE; public void setBold(boolean bold) {
} CTBooleanProperty ctBold=ctFont.sizeOfBArray()==0?ctFont.addNewB():ctFont.getBArray(0);
ctBold.setVal(true);
public void setBoldweight(short boldweight) { }
if(boldweight==Font.BOLDWEIGHT_BOLD){
/**
CTBooleanProperty bold; *
if(fontWrapper.getCTFont().getBArray().length==0){ */
bold=fontWrapper.getCTFont().addNewB(); public void setCharSet(byte charset) {
} CTIntProperty charsetProperty=ctFont.sizeOfCharsetArray()==0?ctFont.addNewCharset():ctFont.getCharsetArray(0);
else{ switch (charset) {
bold=CTBooleanProperty.Factory.newInstance(); case Font.ANSI_CHARSET:
} charsetProperty.setVal(Charset.ANSI_CHARSET);
bold.setVal(true); break;
fontWrapper.setB(bold); case Font.SYMBOL_CHARSET:
} charsetProperty.setVal(Charset.SYMBOL_CHARSET);
} break;
case Font.DEFAULT_CHARSET:
public void setCharSet(byte charset) { charsetProperty.setVal(Charset.DEFAULT_CHARSET);
CTIntProperty charsetProperty; break;
if(fontWrapper.getCTFont().getCharsetArray().length==0){ default:
charsetProperty=fontWrapper.getCTFont().addNewCharset(); throw new RuntimeException("Attention: an attempt to set a type of unknow charset and charset");
} }
else{ }
charsetProperty=CTIntProperty.Factory.newInstance();
}
switch (charset) { public void setColor(short color) {
case Font.ANSI_CHARSET: CTColor ctColor=ctFont.sizeOfColorArray()==0?ctFont.addNewColor():ctFont.getColorArray(0);
charsetProperty.setVal(Charset.ANSI_CHARSET);
break; switch (color) {
case Font.SYMBOL_CHARSET: case Font.COLOR_NORMAL:{
charsetProperty.setVal(Charset.SYMBOL_CHARSET); ctColor.setIndexed(XSSFFont.DEFAULT_FONT_COLOR);
break; break;
case Font.DEFAULT_CHARSET: }
charsetProperty.setVal(Charset.DEFAULT_CHARSET); case Font.COLOR_RED:{
break; ctColor.setIndexed(IndexedColors.RED.getIndex());
default: break;
throw new RuntimeException("Attention: an attempt to set a type of unknow charset and charset"); }
} default:
ctColor.setIndexed(color);
fontWrapper.setCharset(charsetProperty); }
} }
public void setColor(short color) {
CTColor ctColor; public void setFontHeight(short height) {
if(fontWrapper.getCTFont().getColorArray().length==0){ CTFontSize fontSize=ctFont.sizeOfSzArray()==0?ctFont.addNewSz():ctFont.getSzArray(0);
ctColor=fontWrapper.getCTFont().addNewColor(); fontSize.setVal(height*20);
} }
else{
ctColor=CTColor.Factory.newInstance();
} public void setFontHeightInPoints(short height) {
CTFontSize fontSize=ctFont.sizeOfSzArray()==0?ctFont.addNewSz():ctFont.getSzArray(0);
switch (color) { fontSize.setVal(height);
case Font.COLOR_NORMAL:{ }
ctColor.setIndexed(XSSFFont.DEFAULT_FONT_COLOR);
break;
}
case Font.COLOR_RED:{ public void setRgbColor(XSSFColor color) {
ctColor.setIndexed(IndexedColors.RED); CTColor ctColor=ctFont.sizeOfColorArray()==0?ctFont.addNewColor():ctFont.getColorArray(0);
break; ctColor.setRgb(color.getRgb());
} }
default:
ctColor.setIndexed(color); public void setThemeColor(short theme) {
} CTColor ctColor=ctFont.sizeOfColorArray()==0?ctFont.addNewColor():ctFont.getColorArray(0);
ctColor.setTheme(theme);
fontWrapper.setColor(ctColor); }
}
public void setFontName(String name) {
CTFontName fontName=ctFont.sizeOfNameArray()==0?ctFont.addNewName():ctFont.getNameArray(0);
fontName.setVal(name);
public void setFontHeight(short height) { }
CTFontSize fontSize;
if(fontWrapper.getCTFont().getSzArray().length==0){ public void setItalic(boolean italic) {
fontSize=fontWrapper.getCTFont().addNewSz(); CTBooleanProperty bool=ctFont.sizeOfIArray()==0?ctFont.addNewI():ctFont.getIArray(0);
} bool.setVal(italic);
else{ }
fontSize=CTFontSize.Factory.newInstance();
} public void setStrikeout(boolean strikeout) {
fontSize.setVal(height*20); CTBooleanProperty strike=ctFont.sizeOfStrikeArray()==0?ctFont.addNewStrike():ctFont.getStrikeArray(0);
fontWrapper.setSz(fontSize); strike.setVal(strikeout);
} }
public void setTypeOffset(short offset) {
public void setFontHeightInPoints(short height) { CTVerticalAlignFontProperty offsetProperty=ctFont.sizeOfVertAlignArray()==0?ctFont.addNewVertAlign(): ctFont.getVertAlignArray(0);
CTFontSize fontSize; switch (offset) {
if(fontWrapper.getCTFont().getSzArray().length==0){ case Font.SS_NONE:
fontSize=fontWrapper.getCTFont().addNewSz(); offsetProperty.setVal(STVerticalAlignRun.BASELINE);
} break;
else{ case Font.SS_SUB:
fontSize=CTFontSize.Factory.newInstance(); offsetProperty.setVal(STVerticalAlignRun.SUBSCRIPT);
} break;
case Font.SS_SUPER:
fontSize.setVal(height); offsetProperty.setVal(STVerticalAlignRun.SUPERSCRIPT);
fontWrapper.setSz(fontSize); break;
} }
}
public void setUnderline(byte underline) {
public void setFontName(String name) { CTUnderlineProperty ctUnderline=ctFont.sizeOfUArray()==0?ctFont.addNewU():ctFont.getUArray(0);
CTFontName fontName; switch (underline) {
if(fontWrapper.getCTFont().getNameArray().length==0){ case Font.U_DOUBLE:
fontName=fontWrapper.getCTFont().addNewName(); ctUnderline.setVal(STUnderlineValues.DOUBLE);
} break;
else{ case Font.U_DOUBLE_ACCOUNTING:
fontName=CTFontName.Factory.newInstance(); ctUnderline.setVal(STUnderlineValues.DOUBLE_ACCOUNTING);
} break;
case Font.U_SINGLE_ACCOUNTING:
fontName.setVal(name); ctUnderline.setVal(STUnderlineValues.SINGLE_ACCOUNTING);
fontWrapper.setName(fontName); break;
} case Font.U_NONE:
ctUnderline.setVal(STUnderlineValues.NONE);
break;
public void setItalic(boolean italic) {
CTBooleanProperty bool; case Font.U_SINGLE:
if(fontWrapper.getCTFont().getIArray().length==0){ default:
bool=fontWrapper.getCTFont().addNewI(); ctUnderline.setVal(STUnderlineValues.SINGLE);
} break;
else{ }
bool=CTBooleanProperty.Factory.newInstance(); }
}
bool.setVal(italic); public long putFont(ArrayList<CTFont> fonts) {
fontWrapper.setI(bool); //TODO
} /*
* we need to implement a method equals to check that 2 instances of CTFont
public void setStrikeout(boolean strikeout) { * are different by comparison of all font attributes.
CTBooleanProperty strike; * NB: take a look to findFont method in XSSFWorkbook
if(fontWrapper.getCTFont().getStrikeArray().length==0){ */
strike=fontWrapper.getCTFont().addNewStrike(); if(fonts.contains(ctFont)) {
} return fonts.indexOf(ctFont);
else{ }
strike=CTBooleanProperty.Factory.newInstance(); fonts.add(ctFont);
} return fonts.size() - 1;
strike.setVal(strikeout); }
fontWrapper.setStrike(strike);
} // solo di xssfFont - non di Font-
//sono utilizzati nel metodo createDefaultFont in StylesTable insta.
public void setTypeOffset(short offset) {
CTVerticalAlignFontProperty offsetProperty; public int getScheme(){
if(fontWrapper.getCTFont().getVertAlignArray().length==0){ CTFontScheme scheme=ctFont.sizeOfSchemeArray()==0?null:ctFont.getSchemeArray(0);
offsetProperty=fontWrapper.getCTFont().addNewVertAlign(); if(scheme!=null){
} int fontScheme = scheme.getVal().intValue();
else{ switch (fontScheme) {
offsetProperty=CTVerticalAlignFontProperty.Factory.newInstance(); case STFontScheme.INT_MAJOR:
} return XSSFFont.SCHEME_MAJOR;
switch (offset) { case STFontScheme.INT_MINOR:
case Font.SS_NONE: return XSSFFont.SCHEME_MINOR;
offsetProperty.setVal(STVerticalAlignRun.BASELINE); case STFontScheme.INT_NONE:
break; return XSSFFont.SCHEME_NONE;
case Font.SS_SUB:
offsetProperty.setVal(STVerticalAlignRun.SUBSCRIPT); default:
break; return fontScheme;
case Font.SS_SUPER: }
offsetProperty.setVal(STVerticalAlignRun.SUPERSCRIPT); }
break; return 0;
} }
fontWrapper.setVertAlign(offsetProperty);
}
public void setScheme(int scheme){
public void setUnderline(byte underline) { CTFontScheme ctFontScheme=ctFont.sizeOfSchemeArray()==0?ctFont.addNewScheme():ctFont.getSchemeArray(0);
CTUnderlineProperty ctUnderline; switch (scheme) {
if(fontWrapper.getCTFont().getUArray().length==0){ case XSSFFont.SCHEME_MAJOR:
ctUnderline=fontWrapper.getCTFont().addNewU(); ctFontScheme.setVal(STFontScheme.MAJOR);
} break;
else{ case XSSFFont.SCHEME_MINOR:
ctUnderline=CTUnderlineProperty.Factory.newInstance(); ctFontScheme.setVal(STFontScheme.MINOR);
} break;
switch (underline) { case XSSFFont.SCHEME_NONE:
case Font.U_DOUBLE: ctFontScheme.setVal(STFontScheme.NONE);
ctUnderline.setVal(STUnderlineValues.DOUBLE); break;
break; default:
case Font.U_DOUBLE_ACCOUNTING: throw new RuntimeException("Schema value ["+ scheme +"] not supported in XSSFFont");
ctUnderline.setVal(STUnderlineValues.DOUBLE_ACCOUNTING); }
break; }
case Font.U_SINGLE_ACCOUNTING:
ctUnderline.setVal(STUnderlineValues.SINGLE_ACCOUNTING);
break; public int getFamily(){
case Font.U_NONE: CTIntProperty family=ctFont.sizeOfFamilyArray()==0?ctFont.addNewFamily():ctFont.getFamilyArray(0);
ctUnderline.setVal(STUnderlineValues.NONE); if(family!=null)
break; return family.getVal();
else
case Font.U_SINGLE: return XSSFFont.FONT_FAMILY_SWISS;
default: }
ctUnderline.setVal(STUnderlineValues.SINGLE);
break; public void setFamily(int value){
} CTIntProperty family=ctFont.sizeOfFamilyArray()==0?ctFont.addNewFamily():ctFont.getFamilyArray(0);
family.setVal(value);
fontWrapper.setU(ctUnderline); }
}
}
public long putFont(LinkedList<CTFont> fonts) {
//TODO
/*
* we need to implement a method equals to check that 2 instances of CTFont
* are different by comparison of all font attributes.
* NB: take a look to findFont method in XSSFWorkbook
*/
CTFont font=fontWrapper.getCTFont();
if(fonts.contains(font)) {
return fonts.indexOf(font);
}
fonts.add(font);
return fonts.size() - 1;
}
// solo di xssfFont - non di Font-
//sono utilizzati nel metodo createDefaultFont in StylesTable insta.
public int getScheme(){
int fontScheme = fontWrapper.getFontScheme().getVal().intValue();
switch (fontScheme) {
case STFontScheme.INT_MAJOR:
return XSSFFont.SCHEME_MAJOR;
case STFontScheme.INT_MINOR:
return XSSFFont.SCHEME_MINOR;
case STFontScheme.INT_NONE:
return XSSFFont.SCHEME_NONE;
default:
return fontScheme;
}
}
public void setScheme(int scheme){
CTFontScheme ctFontScheme;
if(fontWrapper.getCTFont().getSchemeArray().length==0){
ctFontScheme=fontWrapper.getCTFont().addNewScheme();
}
else{
ctFontScheme=CTFontScheme.Factory.newInstance();
}
switch (scheme) {
case XSSFFont.SCHEME_MAJOR:
ctFontScheme.setVal(STFontScheme.MAJOR);
break;
case XSSFFont.SCHEME_MINOR:
ctFontScheme.setVal(STFontScheme.MINOR);
break;
case XSSFFont.SCHEME_NONE:
ctFontScheme.setVal(STFontScheme.NONE);
break;
default:
throw new RuntimeException("Schema value ["+ scheme +"] not supported in XSSFFont");
}
fontWrapper.setFontScheme(ctFontScheme);
}
public int getFamily(){
if(fontWrapper.getFamily()!=null)
return fontWrapper.getFamily().getVal();
else
return XSSFFont.FONT_FAMILY_SWISS;
}
public void setFamily(int value){
//TODO
CTIntProperty family;
if(fontWrapper.getCTFont().getSchemeArray().length==0){
family=fontWrapper.getCTFont().addNewFamily();
}
else{
family=CTIntProperty.Factory.newInstance();
}
family.setVal(value);
//fontWrapper.setFamily
}
}

365
src/ooxml/java/org/apache/poi/xssf/usermodel/XSSFRichTextString.java
View File

@ -20,8 +20,9 @@ package org.apache.poi.xssf.usermodel;
import org.apache.poi.ss.usermodel.Font; import org.apache.poi.ss.usermodel.Font;
import org.apache.poi.ss.usermodel.RichTextString; import org.apache.poi.ss.usermodel.RichTextString;
import org.apache.poi.xssf.model.StylesTable; import org.apache.poi.xssf.model.StylesTable;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTRst; import org.openxmlformats.schemas.spreadsheetml.x2006.main.*;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTRElt;
import java.util.ArrayList;
/** /**
@ -30,23 +31,11 @@ import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTRElt;
* <p> * <p>
* Most strings in a workbook have formatting applied at the cell level, that is, the entire string in the cell has the * Most strings in a workbook have formatting applied at the cell level, that is, the entire string in the cell has the
* same formatting applied. In these cases, the formatting for the cell is stored in the styles part, * same formatting applied. In these cases, the formatting for the cell is stored in the styles part,
* and the string for the cell can be shared across the workbook. The following xml and code snippet illustrate the example. * and the string for the cell can be shared across the workbook. The following code illustrates the example.
* </p> * </p>
* *
* <blockquote> * <blockquote>
* <pre> * <pre>
* &lt;sst xmlns=http://schemas.openxmlformats.org/spreadsheetml/2006/5/main
* count="1" uniqueCount="1">
* &lt;si&gt;
* &lt;t&gt;Apache POI&lt;/t&gt;
* &lt;/si&gt;
* &lt;/sst&gt;
* </pre>
* </blockquote>
*
* The code to produce xml above:
* <blockquote>
* <pre>
* cell1.setCellValue(new XSSFRichTextString("Apache POI")); * cell1.setCellValue(new XSSFRichTextString("Apache POI"));
* cell2.setCellValue(new XSSFRichTextString("Apache POI")); * cell2.setCellValue(new XSSFRichTextString("Apache POI"));
* cell3.setCellValue(new XSSFRichTextString("Apache POI")); * cell3.setCellValue(new XSSFRichTextString("Apache POI"));
@ -73,56 +62,32 @@ import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTRElt;
* </pre> * </pre>
* </blockquote> * </blockquote>
* *
* The code above will produce the following xml:
* <blockquote>
* <pre>
* &lt;sst xmlns=http://schemas.openxmlformats.org/spreadsheetml/2006/5/main count="2" uniqueCount="2"&gt;
* &lt;si&gt;
* &lt;r&gt;
* &lt;rPr&gt;
* &lt;b/&gt;
* &lt;sz val="11"/&gt;
* &lt;color theme="1"/&gt;
* &lt;rFont val="Arial"/&gt;
* &lt;family val="2"/&gt;
* &lt;scheme val="minor"/&gt;
* &lt;/rPr&gt;
* &lt;t&gt;Apache POI&lt;/t&gt;
* &lt;/r&gt;
* &lt;/si&gt;
* &lt;si&gt;
* &lt;r&gt;
* &lt;rPr&gt;
* &lt;i/&gt;
* &lt;sz val="11"/&gt;
* &lt;color theme="1"/&gt;
* &lt;rFont val="Courier"/&gt;
* &lt;family val="1"/&gt;
* &lt;scheme val="minor"/&gt;
* &lt;/rPr&gt;
* &lt;t&gt;Apache POI&lt;/t&gt;
* &lt;/r&gt;
* &lt;/si&gt;
*&lt;/sst&gt;
*
* </pre>
* </blockquote>
* *
* @author Yegor Kozlov * @author Yegor Kozlov
*/ */
public class XSSFRichTextString implements RichTextString { public class XSSFRichTextString implements RichTextString {
private CTRst st; private CTRst st;
private StylesTable styles; private StylesTable styles;
private ArrayList<CTRPrElt> fontIdRuns;
/**
* Create a rich text string and initialize it with empty string
*/
public XSSFRichTextString(String str) { public XSSFRichTextString(String str) {
st = CTRst.Factory.newInstance(); st = CTRst.Factory.newInstance();
st.setT(str); st.setT(str);
} }
/**
* Create empty rich text string
*/
public XSSFRichTextString() { public XSSFRichTextString() {
st = CTRst.Factory.newInstance(); st = CTRst.Factory.newInstance();
} }
/**
* Create a rich text string from the supplied XML bean
*/
public XSSFRichTextString(CTRst st) { public XSSFRichTextString(CTRst st) {
this.st = st; this.st = st;
} }
@ -135,8 +100,17 @@ public class XSSFRichTextString implements RichTextString {
* @param fontIndex The font to use. * @param fontIndex The font to use.
*/ */
public void applyFont(int startIndex, int endIndex, short fontIndex) { public void applyFont(int startIndex, int endIndex, short fontIndex) {
// TODO Auto-generated method stub XSSFFont font;
if(styles == null) {
//style table is not set, remember fontIndex and set the run properties later,
//when setStylesTableReference is called
font = new XSSFFont();
font.setFontName("#" + fontIndex);
fontIdRuns = new ArrayList<CTRPrElt>();
} else {
font = (XSSFFont)styles.getFontAt(fontIndex);
}
applyFont(startIndex, endIndex, font);
} }
/** /**
@ -147,7 +121,69 @@ public class XSSFRichTextString implements RichTextString {
* @param font The index of the font to use. * @param font The index of the font to use.
*/ */
public void applyFont(int startIndex, int endIndex, Font font) { public void applyFont(int startIndex, int endIndex, Font font) {
applyFont(0, length(), font.getIndex()); if (startIndex > endIndex)
throw new IllegalArgumentException("Start index must be less than end index.");
if (startIndex < 0 || endIndex > length())
throw new IllegalArgumentException("Start and end index not in range.");
if (startIndex == endIndex)
return;
if(st.sizeOfRArray() == 0 && st.isSetT()) {
//convert <t>string</t> into a text run: <r><t>string</t></r>
st.addNewR().setT(st.getT());
st.unsetT();
}
String text = getString();
XSSFFont xssfFont = (XSSFFont)font;
ArrayList<CTRElt> runs = new ArrayList<CTRElt>();
int pos = 0;
int i;
for (i = 0; i < st.sizeOfRArray(); i++) {
CTRElt r = st.getRArray(i);
int len = r.getT().length();
int p1 = pos;
int p2 = pos + len;
if(startIndex > p2) {
runs.add(r);
} else if (startIndex >= p1 && startIndex < p2){
String t = r.getT();
r.setT(t.substring(0, startIndex-p1));
runs.add(r);
} else {
break;
}
pos = p2;
}
CTRElt r = CTRElt.Factory.newInstance();
r.setT(text.substring(startIndex, endIndex));
CTRPrElt pr = r.addNewRPr();
setRunAttributes(xssfFont.getCTFont(), pr);
if(fontIdRuns != null) fontIdRuns.add(pr);
runs.add(r);
for (; i < st.sizeOfRArray(); i++) {
r = st.getRArray(i);
int len = r.getT().length();
int p1 = pos;
int p2 = pos + len;
if(endIndex > p2) {
;
} else if (endIndex >= p1 && endIndex < p2){
String t = r.getT();
r.setT(t.substring(endIndex-p1, len));
runs.add(r);
} else {
runs.add(r);
}
pos = p2;
}
st.setRArray(runs.toArray(new CTRElt[runs.size()]));
} }
/** /**
@ -155,7 +191,20 @@ public class XSSFRichTextString implements RichTextString {
* @param font The font to use. * @param font The font to use.
*/ */
public void applyFont(Font font) { public void applyFont(Font font) {
applyFont(0, length(), font); if(st.sizeOfRArray() == 0 && st.isSetT()) {
CTRElt r = st.addNewR();
r.setT(st.getT());
setRunAttributes(((XSSFFont)font).getCTFont(), r.addNewRPr());
st.unsetT();
} else {
CTRElt r = CTRElt.Factory.newInstance();
r.setT(getString());
setRunAttributes(((XSSFFont)font).getCTFont(), r.addNewRPr());
st.setRArray(new CTRElt[]{r});
}
if(fontIdRuns != null) fontIdRuns.add(st.getRArray(0).getRPr());
} }
/** /**
@ -164,50 +213,118 @@ public class XSSFRichTextString implements RichTextString {
* @param fontIndex the font to apply. * @param fontIndex the font to apply.
*/ */
public void applyFont(short fontIndex) { public void applyFont(short fontIndex) {
applyFont(0, length(), fontIndex); XSSFFont font;
if(styles == null) {
font = new XSSFFont();
font.setFontName("#" + fontIndex);
fontIdRuns = new ArrayList<CTRPrElt>();
} else {
font = (XSSFFont)styles.getFontAt(fontIndex);
}
applyFont(font);
}
/**
* Append new text to this text run and apply the specify font to it
*
* @param text the text to append
* @param font the font to apply to the appended text or <code>null</code> if no formatting is required
*/
public void append(String text, XSSFFont font){
if(st.sizeOfRArray() == 0 && st.isSetT()) {
//convert <t>string</t> into a text run: <r><t>string</t></r>
st.addNewR().setT(st.getT());
st.unsetT();
}
CTRElt lt = st.addNewR();
lt.setT(text);
CTRPrElt pr = lt.addNewRPr();
if(font != null) setRunAttributes(font.getCTFont(), pr);
if(fontIdRuns != null) fontIdRuns.add(pr);
}
/**
* Append new text to this text run
*
* @param text the text to append
*/
public void append(String text){
append(text, null);
}
/**
* Copy font attributes from CTFont bean into CTRPrElt bean
*/
private void setRunAttributes(CTFont ctFont, CTRPrElt pr){
if(ctFont.sizeOfBArray() > 0) pr.addNewB().setVal(ctFont.getBArray(0).getVal());
if(ctFont.sizeOfUArray() > 0) pr.addNewU().setVal(ctFont.getUArray(0).getVal());
if(ctFont.sizeOfIArray() > 0) pr.addNewI().setVal(ctFont.getIArray(0).getVal());
if(ctFont.sizeOfColorArray() > 0) {
CTColor c1 = ctFont.getColorArray(0);
CTColor c2 = pr.addNewColor();
if(c1.isSetAuto()) c2.setAuto(c1.getAuto());
if(c1.isSetIndexed()) c2.setIndexed(c1.getIndexed());
if(c1.isSetRgb()) c2.setRgb(c1.getRgb());
if(c1.isSetTheme()) c2.setTheme(c1.getTheme());
if(c1.isSetTint()) c2.setTint(c1.getTint());
}
if(ctFont.sizeOfNameArray() > 0) pr.addNewRFont().setVal(ctFont.getNameArray(0).getVal());
if(ctFont.sizeOfFamilyArray() > 0) pr.addNewFamily().setVal(ctFont.getFamilyArray(0).getVal());
if(ctFont.sizeOfSchemeArray() > 0) pr.addNewScheme().setVal(ctFont.getSchemeArray(0).getVal());
if(ctFont.sizeOfCharsetArray() > 0) pr.addNewCharset().setVal(ctFont.getCharsetArray(0).getVal());
if(ctFont.sizeOfCondenseArray() > 0) pr.addNewCondense().setVal(ctFont.getCondenseArray(0).getVal());
if(ctFont.sizeOfExtendArray() > 0) pr.addNewExtend().setVal(ctFont.getExtendArray(0).getVal());
if(ctFont.sizeOfVertAlignArray() > 0) pr.addNewVertAlign().setVal(ctFont.getVertAlignArray(0).getVal());
if(ctFont.sizeOfOutlineArray() > 0) pr.addNewOutline().setVal(ctFont.getOutlineArray(0).getVal());
if(ctFont.sizeOfShadowArray() > 0) pr.addNewShadow().setVal(ctFont.getShadowArray(0).getVal());
if(ctFont.sizeOfStrikeArray() > 0) pr.addNewStrike().setVal(ctFont.getStrikeArray(0).getVal());
} }
/** /**
* Removes any formatting that may have been applied to the string. * Removes any formatting that may have been applied to the string.
*/ */
public void clearFormatting() { public void clearFormatting() {
for (int i = 0; i < st.sizeOfRArray(); i++) { String text = getString();
st.removeR(i); while (st.sizeOfRArray() > 0) {
st.removeR(st.sizeOfRArray()-1);
} }
} st.setT(text);
/**
* Returns the font in use at a particular index.
*
* @param index The index.
* @return The font that's currently being applied at that
* index or null if no font is being applied or the
* index is out of range.
*/
public short getFontAtIndex(int index) {
// TODO Auto-generated method stub
return 0;
}
/**
* Gets the font used in a particular formatting run.
*
* @param index the index of the formatting run
* @return the font number used.
*/
public short getFontOfFormattingRun(int index) {
// TODO Auto-generated method stub
return 0;
} }
/** /**
* The index within the string to which the specified formatting run applies. * The index within the string to which the specified formatting run applies.
*
* @param index the index of the formatting run * @param index the index of the formatting run
* @return the index within the string. * @return the index within the string.
*/ */
public int getIndexOfFormattingRun(int index) { public int getIndexOfFormattingRun(int index) {
// TODO Auto-generated method stub if(st.sizeOfRArray() == 0) return 0;
return 0;
int pos = 0;
for(int i = 0; i < st.sizeOfRArray(); i++){
CTRElt r = st.getRArray(i);
if(i == index) return pos;
pos += r.getT().length();
}
return -1;
}
/**
* Returns the number of characters this format run covers.
*
* @param index the index of the formatting run
* @return the number of characters this format run covers
*/
public int getLengthOfFormattingRun(int index) {
if(st.sizeOfRArray() == 0) return length();
for(int i = 0; i < st.sizeOfRArray(); i++){
CTRElt r = st.getRArray(i);
if(i == index) return r.getT().length();
}
return -1;
} }
/** /**
@ -255,6 +372,44 @@ public class XSSFRichTextString implements RichTextString {
return st.sizeOfRArray(); return st.sizeOfRArray();
} }
/**
* Gets a copy of the font used in a particular formatting run.
*
* @param index the index of the formatting run
* @return A copy of the font used or null if no formatting is applied to the specified text run.
*/
public XSSFFont getFontOfFormattingRun(int index) {
if(st.sizeOfRArray() == 0) return null;
for(int i = 0; i < st.sizeOfRArray(); i++){
CTRElt r = st.getRArray(i);
if(i == index) return new XSSFFont(toCTFont(r.getRPr()));
}
return null;
}
/**
* Return a copy of the font in use at a particular index.
*
* @param index The index.
* @return A copy of the font that's currently being applied at that
* index or null if no font is being applied or the
* index is out of range.
*/
public XSSFFont getFontAtIndex( int index ) {
if(st.sizeOfRArray() == 0) return null;
int pos = 0;
for(int i = 0; i < st.sizeOfRArray(); i++){
CTRElt r = st.getRArray(i);
if(index >= pos && index < pos + r.getT().length()) return new XSSFFont(toCTFont(r.getRPr()));
pos += r.getT().length();
}
return null;
}
/** /**
* Return the underlying xml bean * Return the underlying xml bean
*/ */
@ -264,5 +419,51 @@ public class XSSFRichTextString implements RichTextString {
protected void setStylesTableReference(StylesTable tbl){ protected void setStylesTableReference(StylesTable tbl){
styles = tbl; styles = tbl;
if(fontIdRuns != null){
for (CTRPrElt pr : fontIdRuns) {
if(pr.sizeOfRFontArray() > 0 ) {
String fontName = pr.getRFontArray(0).getVal();
if(fontName.startsWith("#")){
int idx = Integer.parseInt(fontName.substring(1));
XSSFFont font = (XSSFFont)styles.getFontAt(idx);
pr.removeRFont(0);
setRunAttributes(font.getCTFont(), pr);
}
}
}
}
}
/**
*
* CTRPrElt --> CTFont adapter
*/
protected static CTFont toCTFont(CTRPrElt pr){
CTFont ctFont = CTFont.Factory.newInstance();
if(pr.sizeOfBArray() > 0) ctFont.addNewB().setVal(pr.getBArray(0).getVal());
if(pr.sizeOfUArray() > 0) ctFont.addNewU().setVal(pr.getUArray(0).getVal());
if(pr.sizeOfIArray() > 0) ctFont.addNewI().setVal(pr.getIArray(0).getVal());
if(pr.sizeOfColorArray() > 0) {
CTColor c1 = pr.getColorArray(0);
CTColor c2 = ctFont.addNewColor();
if(c1.isSetAuto()) c2.setAuto(c1.getAuto());
if(c1.isSetIndexed()) c2.setIndexed(c1.getIndexed());
if(c1.isSetRgb()) c2.setRgb(c1.getRgb());
if(c1.isSetTheme()) c2.setTheme(c1.getTheme());
if(c1.isSetTint()) c2.setTint(c1.getTint());
}
if(pr.sizeOfRFontArray() > 0) ctFont.addNewName().setVal(pr.getRFontArray(0).getVal());
if(pr.sizeOfFamilyArray() > 0) ctFont.addNewFamily().setVal(pr.getFamilyArray(0).getVal());
if(pr.sizeOfSchemeArray() > 0) ctFont.addNewScheme().setVal(pr.getSchemeArray(0).getVal());
if(pr.sizeOfCharsetArray() > 0) ctFont.addNewCharset().setVal(pr.getCharsetArray(0).getVal());
if(pr.sizeOfCondenseArray() > 0) ctFont.addNewCondense().setVal(pr.getCondenseArray(0).getVal());
if(pr.sizeOfExtendArray() > 0) ctFont.addNewExtend().setVal(pr.getExtendArray(0).getVal());
if(pr.sizeOfVertAlignArray() > 0) ctFont.addNewVertAlign().setVal(pr.getVertAlignArray(0).getVal());
if(pr.sizeOfOutlineArray() > 0) ctFont.addNewOutline().setVal(pr.getOutlineArray(0).getVal());
if(pr.sizeOfShadowArray() > 0) ctFont.addNewShadow().setVal(pr.getShadowArray(0).getVal());
if(pr.sizeOfStrikeArray() > 0) ctFont.addNewStrike().setVal(pr.getStrikeArray(0).getVal());
return ctFont;
} }
} }

13
src/ooxml/java/org/apache/poi/xssf/usermodel/XSSFSheet.java
View File

@ -134,6 +134,8 @@ public class XSSFSheet implements Sheet {
if (this.worksheet.getSheetData() == null) { if (this.worksheet.getSheetData() == null) {
this.worksheet.addNewSheetData(); this.worksheet.addNewSheetData();
} }
//CTSheetView sheetView = getSheetTypeSheetView();
//sheetView.setWorkbookViewId(0);
initRows(this.worksheet); initRows(this.worksheet);
initColumns(this.worksheet); initColumns(this.worksheet);
@ -984,8 +986,17 @@ public class XSSFSheet implements Sheet {
} }
// HSSFSheet compatibility methods. See also the following zoom related methods // HSSFSheet compatibility methods. See also the following zoom related methods
/**
* Sets the zoom magnication for the sheet. The zoom is expressed as a
* fraction. For example to express a zoom of 75% use 3 for the numerator
* and 4 for the denominator.
*
* @param numerator The numerator for the zoom magnification.
* @param denominator The denominator for the zoom magnification.
*/
public void setZoom(int numerator, int denominator) { public void setZoom(int numerator, int denominator) {
setZoom((numerator/denominator) * 100); Float result = new Float(numerator)/new Float(denominator)*100;
setZoom(result.intValue());
} }
public void setZoom(long scale) { public void setZoom(long scale) {

19
src/ooxml/java/org/apache/poi/xssf/usermodel/XSSFWorkbook.java
View File

@ -19,6 +19,7 @@ package org.apache.poi.xssf.usermodel;
import java.io.IOException; import java.io.IOException;
import java.io.OutputStream; import java.io.OutputStream;
import java.io.InputStream;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.LinkedList; import java.util.LinkedList;
import java.util.List; import java.util.List;
@ -102,6 +103,10 @@ public class XSSFWorkbook extends POIXMLDocument implements Workbook {
public XSSFWorkbook(String path) throws IOException { public XSSFWorkbook(String path) throws IOException {
this(openPackage(path)); this(openPackage(path));
} }
public XSSFWorkbook(InputStream is) throws IOException {
this(openPackage(is));
}
public XSSFWorkbook(Package pkg) throws IOException { public XSSFWorkbook(Package pkg) throws IOException {
super(pkg); super(pkg);
try { try {
@ -299,11 +304,11 @@ public class XSSFWorkbook extends POIXMLDocument implements Workbook {
} }
public Font findFont(short boldWeight, short color, short fontHeight, String name, boolean italic, boolean strikeout, short typeOffset, byte underline) { public XSSFFont findFont(short boldWeight, short color, short fontHeight, String name, boolean italic, boolean strikeout, short typeOffset, byte underline) {
short fontNum=getNumberOfFonts(); short fontNum=getNumberOfFonts();
for (short i = 0; i <= fontNum; i++) { for (short i = 0; i < fontNum; i++) {
XSSFFont xssfFont = (XSSFFont)getFontAt(i); XSSFFont xssfFont = getFontAt(i);
if (xssfFont.getBoldweight() == boldWeight if ( xssfFont.getBold() == (boldWeight == XSSFFont.BOLDWEIGHT_BOLD)
&& xssfFont.getColor() == color && xssfFont.getColor() == color
&& xssfFont.getFontHeightInPoints() == fontHeight && xssfFont.getFontHeightInPoints() == fontHeight
&& xssfFont.getFontName().equals(name) && xssfFont.getFontName().equals(name)
@ -384,8 +389,8 @@ public class XSSFWorkbook extends POIXMLDocument implements Workbook {
return (short) getFirstVisibleTab(); return (short) getFirstVisibleTab();
} }
public Font getFontAt(short idx) { public XSSFFont getFontAt(short idx) {
return stylesSource.getFontAt(idx); return (XSSFFont)stylesSource.getFontAt(idx);
} }
public XSSFName getNameAt(int index) { public XSSFName getNameAt(int index) {
@ -418,7 +423,7 @@ public class XSSFWorkbook extends POIXMLDocument implements Workbook {
public short getNumberOfFonts() { public short getNumberOfFonts() {
// TODO Auto-generated method stub // TODO Auto-generated method stub
return 0; return (short)((StylesTable)stylesSource).getNumberOfFonts();
} }
public int getNumberOfNames() { public int getNumberOfNames() {

2
src/ooxml/java/org/apache/poi/xssf/usermodel/extensions/XSSFCellBorder.java
View File

@ -70,7 +70,7 @@ public class XSSFCellBorder {
} }
public void setBorderColor(BorderSide side, XSSFColor color) { public void setBorderColor(BorderSide side, XSSFColor color) {
color.setToBorder(getBorder(side)); getBorder(side).setColor(color.getCTColor());
} }
private CTBorderPr getBorder(BorderSide side) { private CTBorderPr getBorder(BorderSide side) {

212
src/ooxml/java/org/apache/poi/xssf/usermodel/extensions/XSSFColor.java
View File

@ -16,61 +16,183 @@
==================================================================== */ ==================================================================== */
package org.apache.poi.xssf.usermodel.extensions; package org.apache.poi.xssf.usermodel.extensions;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTBorderPr;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTColor; import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTColor;
/**
* Represents a color in SpreadsheetML
*/
public class XSSFColor { public class XSSFColor {
private CTColor color; private CTColor ctColor;
public XSSFColor(CTColor color) { /**
this.color = color; * Create an instance of XSSFColor from the supplied XML bean
if (this.color == null) { */
this.color = CTColor.Factory.newInstance(); public XSSFColor(CTColor color) {
} this.ctColor = color;
} }
public boolean isAuto() { /**
return color.getAuto(); * Create an new instance of XSSFColor
*/
public XSSFColor() {
this.ctColor = CTColor.Factory.newInstance();
}
/**
* A boolean value indicating the ctColor is automatic and system ctColor dependent.
*/
public boolean isAuto() {
return ctColor.getAuto();
} }
/**
* A boolean value indicating the ctColor is automatic and system ctColor dependent.
*/
public void setAuto(boolean auto) { public void setAuto(boolean auto) {
color.setAuto(auto); ctColor.setAuto(auto);
}
public long getIndexed() {
return color.getIndexed();
}
public void setIndexed(long indexed) {
color.setIndexed(indexed);
}
public byte[] getRgb() {
return color.getRgb();
}
public void setRgb(byte[] rgb) {
color.setRgb(rgb);
}
public long getTheme() {
return color.getTheme();
}
public void setTheme(long theme) {
color.setTheme(theme);
}
public double getTint() {
return color.getTint();
}
public void setTint(double tint) {
color.setTint(tint);
} }
public void setToBorder(CTBorderPr border) { /**
border.setColor(this.color); * Indexed ctColor value. Only used for backwards compatibility. References a ctColor in indexedColors.
*/
public int getIndexed() {
return (int)ctColor.getIndexed();
} }
/**
* Indexed ctColor value. Only used for backwards compatibility. References a ctColor in indexedColors.
*/
public void setIndexed(int indexed) {
ctColor.setIndexed(indexed);
}
/**
* Standard Alpha Red Green Blue ctColor value (ARGB).
*/
public byte[] getRgb() {
return ctColor.getRgb();
}
/**
* Standard Alpha Red Green Blue ctColor value (ARGB).
*/
public void setRgb(byte[] rgb) {
ctColor.setRgb(rgb);
}
/**
* Index into the <clrScheme> collection, referencing a particular <sysClr> or
* <srgbClr> value expressed in the Theme part.
*/
public int getTheme() {
return (int)ctColor.getTheme();
}
/**
* Index into the <clrScheme> collection, referencing a particular <sysClr> or
* <srgbClr> value expressed in the Theme part.
*/
public void setTheme(int theme) {
ctColor.setTheme(theme);
}
/**
* Specifies the tint value applied to the ctColor.
*
* <p>
* If tint is supplied, then it is applied to the RGB value of the ctColor to determine the final
* ctColor applied.
* </p>
* <p>
* The tint value is stored as a double from -1.0 .. 1.0, where -1.0 means 100% darken and
* 1.0 means 100% lighten. Also, 0.0 means no change.
* </p>
* <p>
* In loading the RGB value, it is converted to HLS where HLS values are (0..HLSMAX), where
* HLSMAX is currently 255.
* </p>
* Here are some examples of how to apply tint to ctColor:
* <blockquote>
* <pre>
* If (tint &lt; 0)
* Lum’ = Lum * (1.0 + tint)
*
* For example: Lum = 200; tint = -0.5; Darken 50%
* Lum‘ = 200 * (0.5) =&gt; 100
* For example: Lum = 200; tint = -1.0; Darken 100% (make black)
* Lum‘ = 200 * (1.0-1.0) =&gt; 0
* If (tint &gt; 0)
* Lum‘ = Lum * (1.0-tint) + (HLSMAX – HLSMAX * (1.0-tint))
* For example: Lum = 100; tint = 0.75; Lighten 75%
*
* Lum‘ = 100 * (1-.75) + (HLSMAX – HLSMAX*(1-.75))
* = 100 * .25 + (255 – 255 * .25)
* = 25 + (255 – 63) = 25 + 192 = 217
* For example: Lum = 100; tint = 1.0; Lighten 100% (make white)
* Lum‘ = 100 * (1-1) + (HLSMAX – HLSMAX*(1-1))
* = 100 * 0 + (255 – 255 * 0)
* = 0 + (255 – 0) = 255
* </pre>
* </blockquote>
*
* @return the tint value
*/
public double getTint() {
return ctColor.getTint();
}
/**
* Specifies the tint value applied to the ctColor.
*
* <p>
* If tint is supplied, then it is applied to the RGB value of the ctColor to determine the final
* ctColor applied.
* </p>
* <p>
* The tint value is stored as a double from -1.0 .. 1.0, where -1.0 means 100% darken and
* 1.0 means 100% lighten. Also, 0.0 means no change.
* </p>
* <p>
* In loading the RGB value, it is converted to HLS where HLS values are (0..HLSMAX), where
* HLSMAX is currently 255.
* </p>
* Here are some examples of how to apply tint to ctColor:
* <blockquote>
* <pre>
* If (tint &lt; 0)
* Lum’ = Lum * (1.0 + tint)
*
* For example: Lum = 200; tint = -0.5; Darken 50%
* Lum‘ = 200 * (0.5) =&gt; 100
* For example: Lum = 200; tint = -1.0; Darken 100% (make black)
* Lum‘ = 200 * (1.0-1.0) =&gt; 0
* If (tint &gt; 0)
* Lum‘ = Lum * (1.0-tint) + (HLSMAX – HLSMAX * (1.0-tint))
* For example: Lum = 100; tint = 0.75; Lighten 75%
*
* Lum‘ = 100 * (1-.75) + (HLSMAX – HLSMAX*(1-.75))
* = 100 * .25 + (255 – 255 * .25)
* = 25 + (255 – 63) = 25 + 192 = 217
* For example: Lum = 100; tint = 1.0; Lighten 100% (make white)
* Lum‘ = 100 * (1-1) + (HLSMAX – HLSMAX*(1-1))
* = 100 * 0 + (255 – 255 * 0)
* = 0 + (255 – 0) = 255
* </pre>
* </blockquote>
*
* @param tint the tint value
*/
public void setTint(double tint) {
ctColor.setTint(tint);
}
/**
* Returns the underlying XML bean
*
* @return the underlying XML bean
*/
public CTColor getCTColor(){
return ctColor;
}
} }

176
src/ooxml/java/org/apache/poi/xssf/util/CTFontWrapper.java
View File

@ -1,176 +0,0 @@
package org.apache.poi.xssf.util;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTBooleanProperty;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTColor;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTFont;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTFontName;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTFontScheme;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTFontSize;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTIntProperty;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTUnderlineProperty;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTVerticalAlignFontProperty;
/*
* The font element in xml is definited like <choice maxOccurs="unbounded">.
* So in the java object CTFont all methods get and set returns an array of elements also if there is always defined
* only one type of attribute per type.
* This class is made to make simple using method get and set instead of getArray() or set(index,object).
* We consider always the index 0 like the only one index to refer of CT_Font attribute.
*
*/
public class CTFontWrapper{
private CTFont font;
public CTFontWrapper(CTFont font){
this.font=font;
}
public CTFont getCTFont(){
return font;
}
public CTBooleanProperty getB(){
if( font.getBArray().length>0)
return font.getBArray(0);
else
return null;
}
public CTIntProperty getCharset(){
if(font.getCharsetArray().length>0)
return font.getCharsetArray(0);
else
return null;
}
public CTColor getColor(){
if(font.getColorArray().length>0)
return font.getColorArray(0);
else
return null;
}
public CTBooleanProperty getStrike(){
if(font.getStrikeArray().length>0)
return font.getStrikeArray(0);
else
return null;
}
public CTVerticalAlignFontProperty getVertAlign() {
if(font.getVertAlignArray().length>0)
return font.getVertAlignArray(0);
else
return null;
}
public CTFontName setName(){
if(font.getNameArray().length>0)
return font.getNameArray(0);
else
return null;
}
public CTFontSize getSz(){
if(font.getSzArray().length>0)
return font.getSzArray(0);
else
return null;
}
public CTBooleanProperty getI(){
if(font.getIArray().length>0)
return font.getIArray(0);
else
return null;
}
public CTUnderlineProperty getU(){
if(font.getUArray().length>0)
return font.getUArray(0);
else
return null;
}
public void setB(CTBooleanProperty value){
font.setBArray(0,value);
}
public void setCharset(CTIntProperty value){
font.setCharsetArray(0, value);
}
public void setColor(CTColor value){
font.setColorArray(0,value);
}
public void setFontName(CTFontName value){
font.setNameArray(0,value);
}
public void setSz(CTFontSize value){
font.setSzArray(0,value);
}
public void setI(CTBooleanProperty value){
font.setIArray(0,value);
}
public void setU(CTUnderlineProperty value){
font.setUArray(0,value);
}
public void setStrike(CTBooleanProperty value){
font.setStrikeArray(0,value);
}
public void setVertAlign(CTVerticalAlignFontProperty value){
font.setVertAlignArray(0,value);
}
public void setName(CTFontName fontName) {
font.setNameArray(0,fontName);
}
public CTFontName getName() {
return font.getNameArray(0);
}
public CTIntProperty getFamily() {
return font.getFamilyArray(0);
}
public void setFamily(CTIntProperty family) {
font.setFamilyArray(0,family);
}
public void setFontScheme(CTFontScheme ctFontScheme) {
font.setSchemeArray(0,ctFontScheme);
}
public CTFontScheme getFontScheme() {
return font.getSchemeArray(0);
}
// methods used in FontFormatting
public CTBooleanProperty getOutline(){
return font.getOutlineArray(0);
}
}

16
src/ooxml/java/org/apache/poi/xssf/util/IndexedColors.java
View File

@ -1,16 +0,0 @@
package org.apache.poi.xssf.util;
public class IndexedColors {
public static int BLACK=0;
public static int WHITE=1;
public static int RED=2;
public static int GREEN=3;
public static int BLUE=4;
public static int YELLOW=5;
public static int PINK=6;
public static int LIGHT_GREY=22;
public static int DARK_GREY=23;
}

2
src/ooxml/testcases/org/apache/poi/xssf/extractor/TestXSSFExcelExtractor.java
View File

@ -132,8 +132,6 @@ public final class TestXSSFExcelExtractor extends TestCase {
POITextExtractor extractor = extractors[i]; POITextExtractor extractor = extractors[i];
String text = extractor.getText().replaceAll("[\r\t]", ""); String text = extractor.getText().replaceAll("[\r\t]", "");
//System.out.println(text.length());
//System.out.println(text);
assertTrue(text.startsWith("First Sheet\nTest spreadsheet\n2nd row2nd row 2nd column\n")); assertTrue(text.startsWith("First Sheet\nTest spreadsheet\n2nd row2nd row 2nd column\n"));
Pattern pattern = Pattern.compile(".*13(\\.0+)?\\s+Sheet3.*", Pattern.DOTALL); Pattern pattern = Pattern.compile(".*13(\\.0+)?\\s+Sheet3.*", Pattern.DOTALL);
Matcher m = pattern.matcher(text); Matcher m = pattern.matcher(text);

3
src/ooxml/testcases/org/apache/poi/xssf/usermodel/TestXSSFCell.java
View File

@ -32,6 +32,7 @@ import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook; import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.XSSFTestDataSamples; import org.apache.poi.xssf.XSSFTestDataSamples;
import org.apache.poi.xssf.model.CommentsTable; import org.apache.poi.xssf.model.CommentsTable;
import org.apache.poi.xssf.model.SharedStringsTable;
import org.apache.poi.xssf.model.SharedStringSource; import org.apache.poi.xssf.model.SharedStringSource;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTCell; import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTCell;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTComment; import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTComment;
@ -336,7 +337,7 @@ public final class TestXSSFCell extends TestCase {
private static XSSFRow createParentObjects() { private static XSSFRow createParentObjects() {
XSSFWorkbook wb = new XSSFWorkbook(); XSSFWorkbook wb = new XSSFWorkbook();
wb.setSharedStringSource(new DummySharedStringSource()); wb.setSharedStringSource(new SharedStringsTable());
XSSFSheet sheet = new XSSFSheet(wb); XSSFSheet sheet = new XSSFSheet(wb);
XSSFRow row = new XSSFRow(sheet); XSSFRow row = new XSSFRow(sheet);
return row; return row;

227
src/ooxml/testcases/org/apache/poi/xssf/usermodel/TestXSSFFont.java
View File

@ -1,5 +1,7 @@
package org.apache.poi.xssf.usermodel; package org.apache.poi.xssf.usermodel;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File; import java.io.File;
import java.io.FileOutputStream; import java.io.FileOutputStream;
import java.io.IOException; import java.io.IOException;
@ -11,9 +13,8 @@ import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.Font; import org.apache.poi.ss.usermodel.Font;
import org.apache.poi.ss.usermodel.Row; import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet; import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.xssf.util.CTFontWrapper;
import org.apache.poi.xssf.util.Charset; import org.apache.poi.xssf.util.Charset;
import org.apache.poi.xssf.util.IndexedColors; import org.openxml4j.opc.Package;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTBooleanProperty; import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTBooleanProperty;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTColor; import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTColor;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTFont; import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTFont;
@ -38,60 +39,51 @@ public class TestXSSFFont extends TestCase{
public void testBoldweight(){ public void testBoldweight(){
CTFont ctFont=CTFont.Factory.newInstance(); CTFont ctFont=CTFont.Factory.newInstance();
CTFontWrapper wrapper=new CTFontWrapper(ctFont); CTBooleanProperty bool=ctFont.addNewB();
CTBooleanProperty bool=wrapper.getCTFont().addNewB();
bool.setVal(false); bool.setVal(false);
wrapper.setB(bool); ctFont.setBArray(0,bool);
XSSFFont xssfFont=new XSSFFont(ctFont); XSSFFont xssfFont=new XSSFFont(ctFont);
assertEquals(Font.BOLDWEIGHT_NORMAL, xssfFont.getBoldweight()); assertEquals(false, xssfFont.getBold());
xssfFont.setBoldweight(Font.BOLDWEIGHT_BOLD); xssfFont.setBold(true);
assertEquals(ctFont.getBArray().length,1); assertEquals(ctFont.getBArray().length,1);
assertEquals(true, ctFont.getBArray(0).getVal()); assertEquals(true, ctFont.getBArray(0).getVal());
assertEquals(true,wrapper.getB().getVal());
} }
public void testCharSet(){ public void testCharSet(){
CTFont ctFont=CTFont.Factory.newInstance(); CTFont ctFont=CTFont.Factory.newInstance();
CTFontWrapper wrapper=new CTFontWrapper(ctFont);
CTIntProperty prop=ctFont.addNewCharset(); CTIntProperty prop=ctFont.addNewCharset();
prop.setVal(Charset.ANSI_CHARSET); prop.setVal(Charset.ANSI_CHARSET);
wrapper.setCharset(prop); ctFont.setCharsetArray(0,prop);
XSSFFont xssfFont=new XSSFFont(ctFont); XSSFFont xssfFont=new XSSFFont(ctFont);
assertEquals(Font.ANSI_CHARSET,xssfFont.getCharSet()); assertEquals(Font.ANSI_CHARSET,xssfFont.getCharSet());
xssfFont.setCharSet(Font.DEFAULT_CHARSET); xssfFont.setCharSet(Font.DEFAULT_CHARSET);
assertEquals(Charset.DEFAULT_CHARSET, wrapper.getCharset().getVal()); assertEquals(Charset.DEFAULT_CHARSET,ctFont.getCharsetArray(0).getVal());
} }
public void testFontName(){ public void testFontName(){
CTFont ctFont=CTFont.Factory.newInstance(); CTFont ctFont=CTFont.Factory.newInstance();
CTFontWrapper wrapper=new CTFontWrapper(ctFont);
CTFontName fname=ctFont.addNewName(); CTFontName fname=ctFont.addNewName();
fname.setVal("Arial"); fname.setVal("Arial");
wrapper.setFontName(fname); ctFont.setNameArray(0,fname);
XSSFFont xssfFont=new XSSFFont(ctFont); XSSFFont xssfFont=new XSSFFont(ctFont);
assertEquals("Arial", xssfFont.getFontName()); assertEquals("Arial", xssfFont.getFontName());
xssfFont.setFontName("Courier"); xssfFont.setFontName("Courier");
assertEquals("Courier",wrapper.getName().getVal()); assertEquals("Courier",ctFont.getNameArray(0).getVal());
} }
public void testItalic(){ public void testItalic(){
CTFont ctFont=CTFont.Factory.newInstance(); CTFont ctFont=CTFont.Factory.newInstance();
CTFontWrapper wrapper=new CTFontWrapper(ctFont); CTBooleanProperty bool=ctFont.addNewI();
CTBooleanProperty bool=wrapper.getCTFont().addNewI();
bool.setVal(false); bool.setVal(false);
wrapper.setI(bool); ctFont.setIArray(0,bool);
XSSFFont xssfFont=new XSSFFont(ctFont); XSSFFont xssfFont=new XSSFFont(ctFont);
assertEquals(false, xssfFont.getItalic()); assertEquals(false, xssfFont.getItalic());
@ -99,17 +91,15 @@ public class TestXSSFFont extends TestCase{
xssfFont.setItalic(true); xssfFont.setItalic(true);
assertEquals(ctFont.getIArray().length,1); assertEquals(ctFont.getIArray().length,1);
assertEquals(true, ctFont.getIArray(0).getVal()); assertEquals(true, ctFont.getIArray(0).getVal());
assertEquals(true,wrapper.getI().getVal()); assertEquals(true,ctFont.getIArray(0).getVal());
} }
public void testStrikeout(){ public void testStrikeout(){
CTFont ctFont=CTFont.Factory.newInstance(); CTFont ctFont=CTFont.Factory.newInstance();
CTFontWrapper wrapper=new CTFontWrapper(ctFont); CTBooleanProperty bool=ctFont.addNewStrike();
CTBooleanProperty bool=wrapper.getCTFont().addNewStrike();
bool.setVal(false); bool.setVal(false);
wrapper.setStrike(bool); ctFont.setStrikeArray(0,bool);
XSSFFont xssfFont=new XSSFFont(ctFont); XSSFFont xssfFont=new XSSFFont(ctFont);
assertEquals(false, xssfFont.getStrikeout()); assertEquals(false, xssfFont.getStrikeout());
@ -117,139 +107,218 @@ public class TestXSSFFont extends TestCase{
xssfFont.setStrikeout(true); xssfFont.setStrikeout(true);
assertEquals(ctFont.getStrikeArray().length,1); assertEquals(ctFont.getStrikeArray().length,1);
assertEquals(true, ctFont.getStrikeArray(0).getVal()); assertEquals(true, ctFont.getStrikeArray(0).getVal());
assertEquals(true,wrapper.getStrike().getVal()); assertEquals(true,ctFont.getStrikeArray(0).getVal());
} }
public void testFontHeight(){ public void testFontHeight(){
CTFont ctFont=CTFont.Factory.newInstance(); CTFont ctFont=CTFont.Factory.newInstance();
CTFontWrapper wrapper=new CTFontWrapper(ctFont);
CTFontSize size=ctFont.addNewSz(); CTFontSize size=ctFont.addNewSz();
size.setVal(11); size.setVal(11);
wrapper.setSz(size); ctFont.setSzArray(0,size);
XSSFFont xssfFont=new XSSFFont(ctFont); XSSFFont xssfFont=new XSSFFont(ctFont);
assertEquals(11/20,xssfFont.getFontHeight()); assertEquals(11/20,xssfFont.getFontHeight());
xssfFont.setFontHeight((short)20); xssfFont.setFontHeight((short)20);
assertEquals(new Double(20*20).doubleValue(),wrapper.getSz().getVal()); } assertEquals(new Double(20*20).doubleValue(),ctFont.getSzArray(0).getVal());
}
public void testFontHeightInPoint(){ public void testFontHeightInPoint(){
CTFont ctFont=CTFont.Factory.newInstance(); CTFont ctFont=CTFont.Factory.newInstance();
CTFontWrapper wrapper=new CTFontWrapper(ctFont);
CTFontSize size=ctFont.addNewSz(); CTFontSize size=ctFont.addNewSz();
size.setVal(14); size.setVal(14);
wrapper.setSz(size); ctFont.setSzArray(0,size);
XSSFFont xssfFont=new XSSFFont(ctFont); XSSFFont xssfFont=new XSSFFont(ctFont);
assertEquals(14,xssfFont.getFontHeightInPoints()); assertEquals(14,xssfFont.getFontHeightInPoints());
xssfFont.setFontHeightInPoints((short)20); xssfFont.setFontHeightInPoints((short)20);
assertEquals(new Double(20).doubleValue(),wrapper.getSz().getVal()); assertEquals(new Double(20).doubleValue(),ctFont.getSzArray(0).getVal());
} }
public void testUnderline(){ public void testUnderline(){
CTFont ctFont=CTFont.Factory.newInstance(); CTFont ctFont=CTFont.Factory.newInstance();
CTFontWrapper wrapper=new CTFontWrapper(ctFont); CTUnderlineProperty underlinePropr=ctFont.addNewU();
CTUnderlineProperty underlinePropr=wrapper.getCTFont().addNewU();
underlinePropr.setVal(STUnderlineValues.SINGLE); underlinePropr.setVal(STUnderlineValues.SINGLE);
wrapper.setU(underlinePropr); ctFont.setUArray(0,underlinePropr);
XSSFFont xssfFont=new XSSFFont(ctFont); XSSFFont xssfFont=new XSSFFont(ctFont);
assertEquals(Font.U_SINGLE, xssfFont.getUnderline()); assertEquals(Font.U_SINGLE, xssfFont.getUnderline());
xssfFont.setUnderline(Font.U_DOUBLE); xssfFont.setUnderline(Font.U_DOUBLE);
assertEquals(ctFont.getUArray().length,1); assertEquals(ctFont.getUArray().length,1);
assertEquals(STUnderlineValues.DOUBLE,wrapper.getU().getVal()); assertEquals(STUnderlineValues.DOUBLE,ctFont.getUArray(0).getVal());
} }
public void testColor(){ public void testColor(){
CTFont ctFont=CTFont.Factory.newInstance(); CTFont ctFont=CTFont.Factory.newInstance();
CTFontWrapper wrapper=new CTFontWrapper(ctFont);
CTColor color=ctFont.addNewColor(); CTColor color=ctFont.addNewColor();
//color.setIndexed(IndexedColors.DEFAULT_COLOR);
color.setIndexed(XSSFFont.DEFAULT_FONT_COLOR); color.setIndexed(XSSFFont.DEFAULT_FONT_COLOR);
wrapper.setColor(color); ctFont.setColorArray(0,color);
XSSFFont xssfFont=new XSSFFont(ctFont); XSSFFont xssfFont=new XSSFFont(ctFont);
assertEquals(Font.COLOR_NORMAL,xssfFont.getColor()); assertEquals(Font.COLOR_NORMAL,xssfFont.getColor());
xssfFont.setColor(Font.COLOR_RED); xssfFont.setColor(IndexedColors.RED.getIndex());
assertEquals(IndexedColors.RED,wrapper.getColor().getIndexed()); assertEquals(IndexedColors.RED.getIndex(), ctFont.getColorArray(0).getIndexed());
}
/*
public void testRgbColor(){
CTFont ctFont=CTFont.Factory.newInstance();
CTColor color=ctFont.addNewColor();
color.setRgb(new byte[]{});
ctFont.setColorArray(0,color);
XSSFFont xssfFont=new XSSFFont(ctFont);
assertEquals(,xssfFont.getRgbColor());
xssfFont.setRgbColor(new XSSFColor(new java.awt.Color(10,19,10)));
//assertEquals(,ctFont.getColorArray(0).getRgb());
} }
public void testThemeColor(){
CTFont ctFont=CTFont.Factory.newInstance();
CTColor color=ctFont.addNewColor();
color.setTheme();
ctFont.setColorArray(0,color);
XSSFFont xssfFont=new XSSFFont(ctFont);
assertEquals(,xssfFont.getThemeColor());
xssfFont.setThemeColor(Font.COLOR_RED);
assertEquals(,ctFont.getColorArray(0).getTheme());
assertEquals(,ctFont.getColorArray(0).getTint());
}
*/
public void testFamily(){ public void testFamily(){
CTFont ctFont=CTFont.Factory.newInstance(); CTFont ctFont=CTFont.Factory.newInstance();
CTFontWrapper wrapper=new CTFontWrapper(ctFont);
CTIntProperty family=ctFont.addNewFamily(); CTIntProperty family=ctFont.addNewFamily();
family.setVal(XSSFFont.FONT_FAMILY_MODERN); family.setVal(XSSFFont.FONT_FAMILY_MODERN);
wrapper.setFamily(family); ctFont.setFamilyArray(0,family);
XSSFFont xssfFont=new XSSFFont(ctFont); XSSFFont xssfFont=new XSSFFont(ctFont);
assertEquals(XSSFFont.FONT_FAMILY_MODERN,xssfFont.getFamily()); assertEquals(XSSFFont.FONT_FAMILY_MODERN,xssfFont.getFamily());
} }
public void testScheme(){ public void testScheme(){
CTFont ctFont=CTFont.Factory.newInstance(); CTFont ctFont=CTFont.Factory.newInstance();
CTFontWrapper wrapper=new CTFontWrapper(ctFont);
CTFontScheme scheme=ctFont.addNewScheme(); CTFontScheme scheme=ctFont.addNewScheme();
scheme.setVal(STFontScheme.MAJOR); scheme.setVal(STFontScheme.MAJOR);
wrapper.setFontScheme(scheme); ctFont.setSchemeArray(0,scheme);
XSSFFont font=new XSSFFont(ctFont); XSSFFont font=new XSSFFont(ctFont);
assertEquals(XSSFFont.SCHEME_MAJOR,font.getScheme()); assertEquals(XSSFFont.SCHEME_MAJOR,font.getScheme());
font.setScheme(XSSFFont.SCHEME_NONE); font.setScheme(XSSFFont.SCHEME_NONE);
assertEquals(STFontScheme.NONE,wrapper.getFontScheme().getVal()); assertEquals(STFontScheme.NONE,ctFont.getSchemeArray(0).getVal());
} }
public void testTypeOffset(){ public void testTypeOffset(){
CTFont ctFont=CTFont.Factory.newInstance(); CTFont ctFont=CTFont.Factory.newInstance();
CTFontWrapper wrapper=new CTFontWrapper(ctFont);
CTVerticalAlignFontProperty valign=ctFont.addNewVertAlign(); CTVerticalAlignFontProperty valign=ctFont.addNewVertAlign();
valign.setVal(STVerticalAlignRun.BASELINE); valign.setVal(STVerticalAlignRun.BASELINE);
wrapper.setVertAlign(valign); ctFont.setVertAlignArray(0,valign);
XSSFFont font=new XSSFFont(ctFont); XSSFFont font=new XSSFFont(ctFont);
assertEquals(Font.SS_NONE,font.getTypeOffset()); assertEquals(Font.SS_NONE,font.getTypeOffset());
font.setTypeOffset(XSSFFont.SS_SUPER); font.setTypeOffset(XSSFFont.SS_SUPER);
assertEquals(STVerticalAlignRun.SUPERSCRIPT,wrapper.getVertAlign().getVal()); assertEquals(STVerticalAlignRun.SUPERSCRIPT,ctFont.getVertAlignArray(0).getVal());
} }
/**
* Tests that we can define fonts to a new
* file, save, load, and still see them
* @throws Exception
*/
public void testCreateSave() throws Exception {
XSSFWorkbook wb = new XSSFWorkbook();
XSSFSheet s1 = (XSSFSheet)wb.createSheet();
Row r1 = s1.createRow(0);
Cell r1c1 = r1.createCell(0);
r1c1.setCellValue(2.2);
assertEquals(1, wb.getNumberOfFonts());
XSSFFont font=wb.createFont();
font.setBold(true);
font.setStrikeout(true);
font.setColor(IndexedColors.YELLOW.getIndex());
font.setFontName("Courier");
wb.createCellStyle().setFont(font);
assertEquals(2, wb.getNumberOfFonts());
CellStyle cellStyleTitle=wb.createCellStyle();
cellStyleTitle.setFont(font);
r1c1.setCellStyle(cellStyleTitle);
// Save and re-load
ByteArrayOutputStream baos = new ByteArrayOutputStream();
wb.write(baos);
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
wb = new XSSFWorkbook(Package.open(bais));
s1 = (XSSFSheet)wb.getSheetAt(0);
assertEquals(2, wb.getNumberOfFonts());
assertNotNull(s1.getRow(0).getCell(0).getCellStyle().getFont(wb));
assertEquals(IndexedColors.YELLOW.getIndex(), s1.getRow(0).getCell(0).getCellStyle().getFont(wb).getColor());
assertEquals("Courier", s1.getRow(0).getCell(0).getCellStyle().getFont(wb).getFontName());
// Now add an orphaned one
XSSFFont font2 = wb.createFont();
font2.setItalic(true);
font2.setFontHeightInPoints((short)15);
wb.createCellStyle().setFont(font2);
assertEquals(3, wb.getNumberOfFonts());
// Save and re-load
baos = new ByteArrayOutputStream();
wb.write(baos);
bais = new ByteArrayInputStream(baos.toByteArray());
wb = new XSSFWorkbook(Package.open(bais));
s1 = (XSSFSheet)wb.getSheetAt(0);
assertEquals(3, wb.getNumberOfFonts());
assertNotNull(wb.getFontAt((short)1));
assertNotNull(wb.getFontAt((short)2));
assertEquals(15, wb.getFontAt((short)2).getFontHeightInPoints());
assertEquals(true, wb.getFontAt((short)2).getItalic());
}
public void testXSSFFont() throws IOException{ public void testXSSFFont() throws IOException{
XSSFWorkbook workbook=new XSSFWorkbook(); XSSFWorkbook workbook=new XSSFWorkbook();
//Font font1=workbook.createFont(); //Font font1=workbook.createFont();
Sheet sheet=workbook.createSheet("sheet 1 - test font"); Sheet sheet=workbook.createSheet("sheet 1 - test font");
Row row=sheet.createRow(0); Row row=sheet.createRow(0);
Cell cell=row.createCell(0); Cell cell=row.createCell(0);
cell.setCellValue(new XSSFRichTextString("XSSFFont test example file")); cell.setCellValue(new XSSFRichTextString("XSSFFont test example file"));
Font font=new XSSFFont(); XSSFFont font=new XSSFFont();
font.setBoldweight(Font.BOLDWEIGHT_BOLD); font.setBold(true);
font.setFontHeightInPoints((short)22); font.setFontHeightInPoints((short)22);
font.setColor((short)IndexedColors.BLUE); font.setColor(IndexedColors.BLUE.getIndex());
font.setFontName("Verdana"); font.setFontName("Verdana");
CellStyle cellStyleTitle=workbook.createCellStyle(); CellStyle cellStyleTitle=workbook.createCellStyle();
cellStyleTitle.setFont(font); cellStyleTitle.setFont(font);
cell.setCellStyle(cellStyleTitle); cell.setCellStyle(cellStyleTitle);
row=sheet.createRow(3); row=sheet.createRow(3);
Font font1=new XSSFFont(); XSSFFont font1=new XSSFFont();
font1.setBoldweight(Font.BOLDWEIGHT_BOLD); font1.setBold(true);
font1.setItalic(true); font1.setItalic(true);
font1.setFontHeightInPoints((short)18); font1.setFontHeightInPoints((short)18);
font1.setColor(Font.COLOR_RED); font1.setColor(IndexedColors.RED.getIndex());
font1.setFontName("Arial"); font1.setFontName("Arial");
CellStyle cellStyle1=workbook.createCellStyle(); CellStyle cellStyle1=workbook.createCellStyle();
cellStyle1.setFont(font1); cellStyle1.setFont(font1);
@ -279,7 +348,7 @@ public class TestXSSFFont extends TestCase{
font3.setFontHeightInPoints((short)9); font3.setFontHeightInPoints((short)9);
font3.setFontName("Times"); font3.setFontName("Times");
font3.setStrikeout(true); font3.setStrikeout(true);
font3.setColor((short)IndexedColors.PINK); font3.setColor(IndexedColors.PINK.getIndex());
CellStyle cellStyle3=workbook.createCellStyle(); CellStyle cellStyle3=workbook.createCellStyle();
cellStyle3.setFont(font3); cellStyle3.setFont(font3);

135
src/ooxml/testcases/org/apache/poi/xssf/usermodel/TestXSSFRichTextString.java Executable file
View File

@ -0,0 +1,135 @@
/* ====================================================================
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.xssf.usermodel;
import java.io.*;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import junit.framework.TestCase;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.Comment;
import org.apache.poi.ss.usermodel.CreationHelper;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.SharedStringSource;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.model.CommentsTable;
import org.apache.xmlbeans.XmlOptions;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.*;
/**
* Tests functionality of the XSSFRichTextRun object
*
* @author Yegor Kozlov
*/
public class TestXSSFRichTextString extends TestCase {
public void testCreate() throws Exception {
XSSFRichTextString rt = new XSSFRichTextString("Apache POI");
assertEquals("Apache POI", rt.getString());
CTRst st = rt.getCTRst();
assertTrue(st.isSetT());
assertEquals("Apache POI", st.getT());
rt.append(" is cool stuff");
assertEquals(2, st.sizeOfRArray());
assertFalse(st.isSetT());
assertEquals("Apache POI is cool stuff", rt.getString());
}
public void testApplyFont() throws Exception {
XSSFRichTextString rt = new XSSFRichTextString();
rt.append("123");
rt.append("4567");
rt.append("89");
XSSFFont font1 = new XSSFFont();
font1.setBold(true);
rt.applyFont(2, 5, font1);
assertEquals(4, rt.numFormattingRuns());
assertEquals(0, rt.getIndexOfFormattingRun(0));
assertEquals(2, rt.getLengthOfFormattingRun(0));
assertEquals(2, rt.getIndexOfFormattingRun(1));
assertEquals(3, rt.getLengthOfFormattingRun(1));
assertEquals(5, rt.getIndexOfFormattingRun(2));
assertEquals(2, rt.getLengthOfFormattingRun(2));
assertEquals(7, rt.getIndexOfFormattingRun(3));
assertEquals(2, rt.getLengthOfFormattingRun(3));
}
public void testClearFormatting() throws Exception {
XSSFRichTextString rt = new XSSFRichTextString("Apache POI");
assertEquals("Apache POI", rt.getString());
rt.clearFormatting();
CTRst st = rt.getCTRst();
assertTrue(st.isSetT());
assertEquals("Apache POI", rt.getString());
assertEquals(0, rt.numFormattingRuns());
XSSFFont font = new XSSFFont();
font.setBold(true);
rt.applyFont(7, 10, font);
assertEquals(2, rt.numFormattingRuns());
rt.clearFormatting();
assertEquals("Apache POI", rt.getString());
assertEquals(0, rt.numFormattingRuns());
}
public void testGetFonts() throws Exception {
XSSFRichTextString rt = new XSSFRichTextString();
XSSFFont font1 = new XSSFFont();
font1.setFontName("Arial");
font1.setItalic(true);
rt.append("The quick", font1);
XSSFFont font1$ = rt.getFontOfFormattingRun(0);
assertEquals(font1.getItalic(), font1$.getItalic());
assertEquals(font1.getFontName(), font1$.getFontName());
XSSFFont font2 = new XSSFFont();
font2.setFontName("Courier");
font2.setBold(true);
rt.append(" brown fox", font2);
XSSFFont font2$ = rt.getFontOfFormattingRun(1);
assertEquals(font2.getBold(), font2$.getBold());
assertEquals(font2.getFontName(), font2$.getFontName());
}
}

15
src/ooxml/testcases/org/apache/poi/xssf/usermodel/TestXSSFRow.java
View File

@ -24,6 +24,7 @@ import junit.framework.TestCase;
import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row; import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.xssf.usermodel.TestXSSFCell.DummySharedStringSource; import org.apache.poi.xssf.usermodel.TestXSSFCell.DummySharedStringSource;
import org.apache.poi.xssf.model.SharedStringsTable;
/** /**
* Tests for XSSFRow * Tests for XSSFRow
@ -167,7 +168,7 @@ public final class TestXSSFRow extends TestCase {
row.setZeroHeight(true); row.setZeroHeight(true);
assertTrue(row.getZeroHeight()); assertTrue(row.getZeroHeight());
} }
/** /**
* Tests for the missing/blank cell policy stuff * Tests for the missing/blank cell policy stuff
*/ */
@ -184,7 +185,7 @@ public final class TestXSSFRow extends TestCase {
row.createCell((short)1).setCellValue(3.2); row.createCell((short)1).setCellValue(3.2);
row.createCell((short)4, Cell.CELL_TYPE_BLANK); row.createCell((short)4, Cell.CELL_TYPE_BLANK);
row.createCell((short)5).setCellValue(4); row.createCell((short)5).setCellValue(4);
// First up, no policy // First up, no policy
assertEquals(Cell.CELL_TYPE_STRING, row.getCell(0).getCellType()); assertEquals(Cell.CELL_TYPE_STRING, row.getCell(0).getCellType());
assertEquals(Cell.CELL_TYPE_NUMERIC, row.getCell(1).getCellType()); assertEquals(Cell.CELL_TYPE_NUMERIC, row.getCell(1).getCellType());
@ -192,7 +193,7 @@ public final class TestXSSFRow extends TestCase {
assertEquals(null, row.getCell(3)); assertEquals(null, row.getCell(3));
assertEquals(Cell.CELL_TYPE_BLANK, row.getCell(4).getCellType()); assertEquals(Cell.CELL_TYPE_BLANK, row.getCell(4).getCellType());
assertEquals(Cell.CELL_TYPE_NUMERIC, row.getCell(5).getCellType()); assertEquals(Cell.CELL_TYPE_NUMERIC, row.getCell(5).getCellType());
// RETURN_NULL_AND_BLANK - same as default // RETURN_NULL_AND_BLANK - same as default
assertEquals(Cell.CELL_TYPE_STRING, row.getCell(0, Row.RETURN_NULL_AND_BLANK).getCellType()); assertEquals(Cell.CELL_TYPE_STRING, row.getCell(0, Row.RETURN_NULL_AND_BLANK).getCellType());
assertEquals(Cell.CELL_TYPE_NUMERIC, row.getCell(1, Row.RETURN_NULL_AND_BLANK).getCellType()); assertEquals(Cell.CELL_TYPE_NUMERIC, row.getCell(1, Row.RETURN_NULL_AND_BLANK).getCellType());
@ -200,7 +201,7 @@ public final class TestXSSFRow extends TestCase {
assertEquals(null, row.getCell(3, Row.RETURN_NULL_AND_BLANK)); assertEquals(null, row.getCell(3, Row.RETURN_NULL_AND_BLANK));
assertEquals(Cell.CELL_TYPE_BLANK, row.getCell(4, Row.RETURN_NULL_AND_BLANK).getCellType()); assertEquals(Cell.CELL_TYPE_BLANK, row.getCell(4, Row.RETURN_NULL_AND_BLANK).getCellType());
assertEquals(Cell.CELL_TYPE_NUMERIC, row.getCell(5, Row.RETURN_NULL_AND_BLANK).getCellType()); assertEquals(Cell.CELL_TYPE_NUMERIC, row.getCell(5, Row.RETURN_NULL_AND_BLANK).getCellType());
// RETURN_BLANK_AS_NULL - nearly the same // RETURN_BLANK_AS_NULL - nearly the same
assertEquals(Cell.CELL_TYPE_STRING, row.getCell(0, XSSFRow.RETURN_BLANK_AS_NULL).getCellType()); assertEquals(Cell.CELL_TYPE_STRING, row.getCell(0, XSSFRow.RETURN_BLANK_AS_NULL).getCellType());
assertEquals(Cell.CELL_TYPE_NUMERIC, row.getCell(1, XSSFRow.RETURN_BLANK_AS_NULL).getCellType()); assertEquals(Cell.CELL_TYPE_NUMERIC, row.getCell(1, XSSFRow.RETURN_BLANK_AS_NULL).getCellType());
@ -208,7 +209,7 @@ public final class TestXSSFRow extends TestCase {
assertEquals(null, row.getCell(3, XSSFRow.RETURN_BLANK_AS_NULL)); assertEquals(null, row.getCell(3, XSSFRow.RETURN_BLANK_AS_NULL));
assertEquals(null, row.getCell(4, XSSFRow.RETURN_BLANK_AS_NULL)); assertEquals(null, row.getCell(4, XSSFRow.RETURN_BLANK_AS_NULL));
assertEquals(Cell.CELL_TYPE_NUMERIC, row.getCell(5, XSSFRow.RETURN_BLANK_AS_NULL).getCellType()); assertEquals(Cell.CELL_TYPE_NUMERIC, row.getCell(5, XSSFRow.RETURN_BLANK_AS_NULL).getCellType());
// CREATE_NULL_AS_BLANK - creates as needed // CREATE_NULL_AS_BLANK - creates as needed
assertEquals(Cell.CELL_TYPE_STRING, row.getCell(0, XSSFRow.CREATE_NULL_AS_BLANK).getCellType()); assertEquals(Cell.CELL_TYPE_STRING, row.getCell(0, XSSFRow.CREATE_NULL_AS_BLANK).getCellType());
assertEquals(Cell.CELL_TYPE_NUMERIC, row.getCell(1, XSSFRow.CREATE_NULL_AS_BLANK).getCellType()); assertEquals(Cell.CELL_TYPE_NUMERIC, row.getCell(1, XSSFRow.CREATE_NULL_AS_BLANK).getCellType());
@ -216,7 +217,7 @@ public final class TestXSSFRow extends TestCase {
assertEquals(Cell.CELL_TYPE_BLANK, row.getCell(3, XSSFRow.CREATE_NULL_AS_BLANK).getCellType()); assertEquals(Cell.CELL_TYPE_BLANK, row.getCell(3, XSSFRow.CREATE_NULL_AS_BLANK).getCellType());
assertEquals(Cell.CELL_TYPE_BLANK, row.getCell(4, XSSFRow.CREATE_NULL_AS_BLANK).getCellType()); assertEquals(Cell.CELL_TYPE_BLANK, row.getCell(4, XSSFRow.CREATE_NULL_AS_BLANK).getCellType());
assertEquals(Cell.CELL_TYPE_NUMERIC, row.getCell(5, XSSFRow.CREATE_NULL_AS_BLANK).getCellType()); assertEquals(Cell.CELL_TYPE_NUMERIC, row.getCell(5, XSSFRow.CREATE_NULL_AS_BLANK).getCellType());
// Check created ones get the right column // Check created ones get the right column
assertEquals((short)0, row.getCell(0, XSSFRow.CREATE_NULL_AS_BLANK).getCellNum()); assertEquals((short)0, row.getCell(0, XSSFRow.CREATE_NULL_AS_BLANK).getCellNum());
assertEquals((short)1, row.getCell(1, XSSFRow.CREATE_NULL_AS_BLANK).getCellNum()); assertEquals((short)1, row.getCell(1, XSSFRow.CREATE_NULL_AS_BLANK).getCellNum());
@ -244,7 +245,7 @@ public final class TestXSSFRow extends TestCase {
private static XSSFSheet createParentObjects() { private static XSSFSheet createParentObjects() {
XSSFWorkbook wb = new XSSFWorkbook(); XSSFWorkbook wb = new XSSFWorkbook();
wb.setSharedStringSource(new DummySharedStringSource()); wb.setSharedStringSource(new SharedStringsTable());
return new XSSFSheet(wb); return new XSSFSheet(wb);
} }
} }

22
src/ooxml/testcases/org/apache/poi/xssf/usermodel/TestXSSFSheet.java
View File

@ -639,12 +639,10 @@ public class TestXSSFSheet extends TestCase {
} }
public void testGetActiveCell() { public void testGetActiveCell() {
Workbook workbook = new XSSFWorkbook(); XSSFWorkbook workbook = new XSSFWorkbook();
CTSheet ctSheet = CTSheet.Factory.newInstance(); XSSFSheet sheet = workbook.createSheet();
CTWorksheet ctWorksheet = CTWorksheet.Factory.newInstance(); sheet.setActiveCell("R5");
XSSFSheet sheet = new XSSFSheet(ctSheet, ctWorksheet, (XSSFWorkbook) workbook);
ctWorksheet.addNewSheetViews().addNewSheetView().addNewSelection().setActiveCell("R5");
assertEquals("R5", sheet.getActiveCell()); assertEquals("R5", sheet.getActiveCell());
} }
@ -733,7 +731,6 @@ public class TestXSSFSheet extends TestCase {
assertEquals(1, ctWorksheet.getColsArray(0).getColArray(0).getStyle()); assertEquals(1, ctWorksheet.getColsArray(0).getColArray(0).getStyle());
XSSFRow row = (XSSFRow) sheet.createRow(0); XSSFRow row = (XSSFRow) sheet.createRow(0);
XSSFCell cell = (XSSFCell) sheet.getRow(0).createCell(3); XSSFCell cell = (XSSFCell) sheet.getRow(0).createCell(3);
//System.out.println(cell.getCellStyle());
} }
@ -772,7 +769,6 @@ public class TestXSSFSheet extends TestCase {
XSSFSheet sheet = new XSSFSheet(ctSheet, ctWorksheet, (XSSFWorkbook) workbook); XSSFSheet sheet = new XSSFSheet(ctSheet, ctWorksheet, (XSSFWorkbook) workbook);
//one level //one level
System.out.println("livello 1");
sheet.groupColumn((short)2,(short)7); sheet.groupColumn((short)2,(short)7);
sheet.groupColumn((short)10,(short)11); sheet.groupColumn((short)10,(short)11);
CTCols cols=sheet.getWorksheet().getColsArray(0); CTCols cols=sheet.getWorksheet().getColsArray(0);
@ -784,7 +780,6 @@ public class TestXSSFSheet extends TestCase {
assertEquals(1, colArray[0].getOutlineLevel()); assertEquals(1, colArray[0].getOutlineLevel());
//two level //two level
System.out.println("\n livello 2");
sheet.groupColumn((short)1,(short)2); sheet.groupColumn((short)1,(short)2);
cols=sheet.getWorksheet().getColsArray(0); cols=sheet.getWorksheet().getColsArray(0);
assertEquals(4,cols.sizeOfColArray()); assertEquals(4,cols.sizeOfColArray());
@ -792,7 +787,6 @@ public class TestXSSFSheet extends TestCase {
assertEquals(2, colArray[1].getOutlineLevel()); assertEquals(2, colArray[1].getOutlineLevel());
//three level //three level
System.out.println("\n livello 3");
sheet.groupColumn((short)6,(short)8); sheet.groupColumn((short)6,(short)8);
sheet.groupColumn((short)2,(short)3); sheet.groupColumn((short)2,(short)3);
cols=sheet.getWorksheet().getColsArray(0); cols=sheet.getWorksheet().getColsArray(0);
@ -855,5 +849,13 @@ public class TestXSSFSheet extends TestCase {
assertEquals(1,sheet.getSheetTypeSheetFormatPr().getOutlineLevelRow()); assertEquals(1,sheet.getSheetTypeSheetFormatPr().getOutlineLevelRow());
} }
public void testSetZoom() {
Workbook workBook = new XSSFWorkbook();
XSSFSheet sheet1 = (XSSFSheet) workBook.createSheet("new sheet");
sheet1.setZoom(3,4); // 75 percent magnification
long zoom = sheet1.getSheetTypeSheetView().getZoomScale();
assertEquals(zoom, 75);
}
} }

21
src/ooxml/testcases/org/apache/poi/xssf/usermodel/TestXSSFWorkbook.java
View File

@ -247,7 +247,7 @@ public class TestXSSFWorkbook extends TestCase {
//get default font, then change 2 values and check against different values (height changes) //get default font, then change 2 values and check against different values (height changes)
Font font=workbook.createFont(); Font font=workbook.createFont();
font.setBoldweight(Font.BOLDWEIGHT_BOLD); ((XSSFFont)font).setBold(true);
font.setUnderline(Font.U_DOUBLE); font.setUnderline(Font.U_DOUBLE);
StylesSource styleSource=new StylesTable(); StylesSource styleSource=new StylesTable();
long index=styleSource.putFont(font); long index=styleSource.putFont(font);
@ -291,6 +291,25 @@ public class TestXSSFWorkbook extends TestCase {
assertNotNull(fontAt); assertNotNull(fontAt);
} }
public void testGetNumberOfFonts(){
XSSFWorkbook wb = new XSSFWorkbook();
XSSFFont f1=wb.createFont();
f1.setBold(true);
wb.createCellStyle().setFont(f1);
XSSFFont f2=wb.createFont();
f2.setUnderline(Font.U_DOUBLE);
wb.createCellStyle().setFont(f2);
XSSFFont f3=wb.createFont();
f3.setFontHeightInPoints((short)23);
wb.createCellStyle().setFont(f3);
assertEquals(4,wb.getNumberOfFonts());
assertEquals(Font.U_DOUBLE,wb.getFontAt((short)2).getUnderline());
}
public void testGetNumCellStyles(){ public void testGetNumCellStyles(){
XSSFWorkbook workbook = new XSSFWorkbook(); XSSFWorkbook workbook = new XSSFWorkbook();
short i = workbook.getNumCellStyles(); short i = workbook.getNumCellStyles();