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

XSSFFont improvements from patch #45874

Browse Source 
git-svn-id: https://svn.apache.org/repos/asf/poi/branches/ooxml@698651 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Yegor Kozlov 2008-09-24 16:56:12 +00:00
parent 6beba5ccc0
commit 6130d5cb83
11 changed files with 554 additions and 264 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/ooxml/java/org/apache/poi/xssf/dev/XSSFDump.java
View File

@ -69,7 +69,7 @@ public class XSSFDump {
File f = new File(root, entry.getName());
FileOutputStream out = new FileOutputStream(f);
if(entry.getName().endsWith(".xml") || entry.getName().endsWith(".vml")){
if(entry.getName().endsWith(".xml") || entry.getName().endsWith(".vml") || entry.getName().endsWith(".rels")){
//pass the xml through the Xerces serializer to produce nicely formatted output
Document doc = builder.parse(zip.getInputStream(entry));

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

@ -29,6 +29,8 @@ import java.util.Map.Entry;
import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.Font;
import org.apache.poi.ss.usermodel.StylesSource;
import org.apache.poi.xssf.usermodel.FontFamily;
import org.apache.poi.xssf.usermodel.FontScheme;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFFont;
import org.apache.poi.xssf.usermodel.extensions.XSSFCellBorder;
@ -103,37 +105,37 @@ public class StylesTable implements StylesSource, XSSFModel {
*/
public void readFrom(InputStream is) throws IOException {
try {
doc = StyleSheetDocument.Factory.parse(is);
// Grab all the different bits we care about
if(doc.getStyleSheet().getNumFmts() != null)
doc = StyleSheetDocument.Factory.parse(is);
// Grab all the different bits we care about
if(doc.getStyleSheet().getNumFmts() != null)
for (CTNumFmt nfmt : doc.getStyleSheet().getNumFmts().getNumFmtArray()) {
numberFormats.put(nfmt.getNumFmtId(), nfmt.getFormatCode());
numberFormats.put(nfmt.getNumFmtId(), nfmt.getFormatCode());
}
if(doc.getStyleSheet().getFonts() != null)
if(doc.getStyleSheet().getFonts() != null)
for (CTFont font : doc.getStyleSheet().getFonts().getFontArray()) {
fonts.add(font);
fonts.add(font);
}
if(doc.getStyleSheet().getFills() != null)
if(doc.getStyleSheet().getFills() != null)
for (CTFill fill : doc.getStyleSheet().getFills().getFillArray()) {
fills.add(fill);
fills.add(fill);
}
if(doc.getStyleSheet().getBorders() != null)
if(doc.getStyleSheet().getBorders() != null)
for (CTBorder border : doc.getStyleSheet().getBorders().getBorderArray()) {
borders.add(border);
borders.add(border);
}
if(doc.getStyleSheet().getCellXfs() != null)
if(doc.getStyleSheet().getCellXfs() != null)
for (CTXf xf : doc.getStyleSheet().getCellXfs().getXfArray()) {
xfs.add(xf);
xfs.add(xf);
}
if(doc.getStyleSheet().getCellStyleXfs() != null)
if(doc.getStyleSheet().getCellStyleXfs() != null)
for (CTXf xf : doc.getStyleSheet().getCellStyleXfs().getXfArray()) {
styleXfs.add(xf);
styleXfs.add(xf);
}
// dxf
if(doc.getStyleSheet().getDxfs() != null)
for (CTDxf dxf : doc.getStyleSheet().getDxfs().getDxfArray()) {
dxfs.add(dxf);
}
// dxf
if(doc.getStyleSheet().getDxfs() != null)
for (CTDxf dxf : doc.getStyleSheet().getDxfs().getDxfArray()) {
dxfs.add(dxf);
}
} catch (XmlException e) {
throw new IOException(e.getLocalizedMessage());
@ -350,7 +352,7 @@ public class StylesTable implements StylesSource, XSSFModel {
doc.getStyleSheet().setCellStyleXfs(ctSXfs);
}
// Style dxf
// Style dxfs
if(dxfs.size() > 0) {
CTDxfs ctDxfs = CTDxfs.Factory.newInstance();
ctDxfs.setCount(dxfs.size());
@ -359,8 +361,6 @@ public class StylesTable implements StylesSource, XSSFModel {
doc.getStyleSheet().setDxfs(ctDxfs);
}
// Save
doc.save(out, options);
}
@ -375,47 +375,51 @@ public class StylesTable implements StylesSource, XSSFModel {
private long putFont(XSSFFont font, ArrayList<CTFont> fonts) {
return font.putFont(fonts);
}
}
private void initialize() {
//CTFont ctFont = createDefaultFont();
XSSFFont xssfFont = createDefaultFont();
fonts.add(xssfFont.getCTFont());
XSSFFont xssfFont = createDefaultFont();
fonts.add(xssfFont.getCTFont());
CTFill ctFill = createDefaultFill();
fills.add(ctFill);
CTFill[] ctFill = createDefaultFills();
fills.add(ctFill[0]);
/*
fills.add(ctFill[1]);
*/
CTBorder ctBorder = createDefaultBorder();
borders.add(ctBorder);
CTBorder ctBorder = createDefaultBorder();
borders.add(ctBorder);
CTXf styleXf = createDefaultXf();
styleXfs.add(styleXf);
CTXf xf = createDefaultXf();
xf.setXfId(0);
xfs.add(xf);
CTXf styleXf = createDefaultXf();
styleXfs.add(styleXf);
CTXf xf = createDefaultXf();
xf.setXfId(0);
xfs.add(xf);
}
private CTXf createDefaultXf() {
CTXf ctXf = CTXf.Factory.newInstance();
ctXf.setNumFmtId(0);
ctXf.setFontId(0);
ctXf.setFillId(0);
ctXf.setBorderId(0);
return ctXf;
CTXf ctXf = CTXf.Factory.newInstance();
ctXf.setNumFmtId(0);
ctXf.setFontId(0);
ctXf.setFillId(0);
ctXf.setBorderId(0);
return ctXf;
}
private CTBorder createDefaultBorder() {
CTBorder ctBorder = CTBorder.Factory.newInstance();
ctBorder.addNewBottom();
ctBorder.addNewTop();
ctBorder.addNewLeft();
ctBorder.addNewRight();
ctBorder.addNewDiagonal();
return ctBorder;
CTBorder ctBorder = CTBorder.Factory.newInstance();
ctBorder.addNewBottom();
ctBorder.addNewTop();
ctBorder.addNewLeft();
ctBorder.addNewRight();
ctBorder.addNewDiagonal();
return ctBorder;
}
private CTFill createDefaultFill() {
CTFill ctFill = CTFill.Factory.newInstance();
ctFill.addNewPatternFill().setPatternType(STPatternType.NONE);
return ctFill;
private CTFill[] createDefaultFills() {
CTFill[] ctFill = new CTFill[]{CTFill.Factory.newInstance(),CTFill.Factory.newInstance()};
ctFill[0].addNewPatternFill().setPatternType(STPatternType.NONE);
ctFill[1].addNewPatternFill().setPatternType(STPatternType.DARK_GRAY);
return ctFill;
}
private XSSFFont createDefaultFont() {
@ -434,19 +438,17 @@ public class StylesTable implements StylesSource, XSSFModel {
xssfFont.setFontHeightInPoints(XSSFFont.DEFAULT_FONT_SIZE);
xssfFont.setColor(XSSFFont.DEFAULT_FONT_COLOR);//setTheme
xssfFont.setFontName(XSSFFont.DEFAULT_FONT_NAME);
xssfFont.setFamily(XSSFFont.FONT_FAMILY_SWISS);
xssfFont.setScheme(XSSFFont.SCHEME_MINOR);
xssfFont.setFamily(FontFamily.SWISS);
xssfFont.setScheme(FontScheme.MINOR);
return xssfFont;
}
public CTDxf getDxf(long idx) {
if(dxfs.size()==0)
return CTDxf.Factory.newInstance();
else
return dxfs.get((int) idx);
if(dxfs.size()==0)
return CTDxf.Factory.newInstance();
else
return dxfs.get((int) idx);
}

112
src/ooxml/java/org/apache/poi/xssf/usermodel/FontCharset.java Executable file
View File

@ -0,0 +1,112 @@
/* ====================================================================
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;
/**
* Charset represents the basic set of characters associated with a font (that it can display), and
* corresponds to the ANSI codepage (8-bit or DBCS) of that character set used by a given language.
*
* @author Gisella Bronzetti
*
*/
public enum FontCharset {
ANSI(0),
DEFAULT(1),
SYMBOL(2),
MAC(77),
SHIFTJIS(128),
HANGEUL(129),
HANGUL(129),
JOHAB(130),
GB2312(134),
CHINESEBIG5(136),
GREEK(161),
TURKISH(162),
VIETNAMESE(163),
HEBREW(177),
ARABIC(178),
BALTIC(186),
RUSSIAN(204),
THAI(222),
EASTEUROPE(238),
OEM(255);
private int charset;
FontCharset(int value){
charset = value;
}
/**
* Returns index of this charset
*
* @return index of this charset
*/
public byte getValue(){
return (byte)charset;
}
public static FontCharset valueOf(int value){
switch (value) {
case 0:
return ANSI;
case 1:
return DEFAULT;
case 2:
return SYMBOL;
case 77:
return MAC;
case 128:
return SHIFTJIS;
case 129:
return HANGEUL;
case 130:
return JOHAB;
case 134:
return GB2312;
case 136:
return CHINESEBIG5;
case 161:
return GREEK;
case 162:
return TURKISH;
case 163:
return VIETNAMESE;
case 177:
return HEBREW;
case 178:
return ARABIC;
case 186:
return BALTIC;
case 204:
return RUSSIAN;
case 222:
return THAI;
case 238:
return EASTEUROPE;
case 255:
return OEM;
}
throw new RuntimeException("Charset value ["+ value +"] not supported");
}
}

74
src/ooxml/java/org/apache/poi/xssf/usermodel/FontFamily.java Executable file
View File

@ -0,0 +1,74 @@
/* ====================================================================
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;
/**
*
* The font family this font belongs to. A font family is a set of fonts having common stroke width and serif
* characteristics. The font name overrides when there are conflicting values.
*
* @author Gisella Bronzetti
*
*/
public enum FontFamily {
NOT_APPLICABLE(0),
ROMAN(1),
SWISS(2),
MODERN(3),
SCRIPT(4),
DECORATIVE(5);
private int family;
FontFamily(int value){
family = value;
}
/**
* Returns index of this font family
*
* @return index of this font family
*/
public int getValue(){
return family;
}
public static FontFamily valueOf(int family){
switch (family) {
case 0:
return NOT_APPLICABLE;
case 1:
return ROMAN;
case 2:
return SWISS;
case 3:
return MODERN;
case 4:
return SCRIPT;
case 5:
return DECORATIVE;
}
throw new RuntimeException("Family value ["+ family +"] not supported");
}
}

68
src/ooxml/java/org/apache/poi/xssf/usermodel/FontScheme.java Executable file
View File

@ -0,0 +1,68 @@
/* ====================================================================
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 org.openxmlformats.schemas.spreadsheetml.x2006.main.STFontScheme;
/**
* Defines the font scheme to which this font belongs.
* When a font definition is part of a theme definition, then the font is categorized as either a major or minor font scheme component.
* When a new theme is chosen, every font that is part of a theme definition is updated to use the new major or minor font definition for that
* theme.
* Usually major fonts are used for styles like headings, and minor fonts are used for body & paragraph text.
*
* @author Gisella Bronzetti
*
*/
public enum FontScheme {
MAJOR(STFontScheme.MAJOR),
MINOR(STFontScheme.MINOR),
NONE(STFontScheme.NONE);
private STFontScheme.Enum scheme;
FontScheme(STFontScheme.Enum value){
scheme = value;
}
/**
* Returns STFontScheme.Enum value of this font scheme
*
* @return STFontScheme.Enum value of this font scheme
*/
public STFontScheme.Enum getValue(){
return scheme;
}
public static FontScheme valueOf(STFontScheme.Enum scheme){
switch (scheme.intValue()) {
case STFontScheme.INT_MAJOR:
return MAJOR;
case STFontScheme.INT_MINOR:
return MINOR;
case STFontScheme.INT_NONE:
return NONE;
}
throw new RuntimeException("Schema value ["+ scheme +"] not supported");
}
}

75
src/ooxml/java/org/apache/poi/xssf/usermodel/FontUnderline.java Executable file
View File

@ -0,0 +1,75 @@
/* ====================================================================
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 org.openxmlformats.schemas.spreadsheetml.x2006.main.STUnderlineValues;
/**
* the different types of possible underline formatting
*
* @author Gisella Bronzetti
*
*/
public enum FontUnderline {
/**
* Double-line underlining under each character in the
* cell. underlines are drawn through the descenders of
* characters such as g and p.
*/
DOUBLE(STUnderlineValues.DOUBLE),
DOUBLE_ACCOUNTING(STUnderlineValues.DOUBLE_ACCOUNTING),
NONE(STUnderlineValues.NONE),
SINGLE(STUnderlineValues.SINGLE),
SINGLE_ACCOUNTING(STUnderlineValues.SINGLE_ACCOUNTING);
private STUnderlineValues.Enum underline;
FontUnderline(STUnderlineValues.Enum value){
underline = value;
}
/**
* Returns index of this font family
*
* @return index of this font family
*/
public STUnderlineValues.Enum getValue(){
return underline;
}
public static FontUnderline valueOf(STUnderlineValues.Enum underline){
switch (underline.intValue()) {
case STUnderlineValues.INT_DOUBLE:
return DOUBLE;
case STUnderlineValues.INT_DOUBLE_ACCOUNTING:
return DOUBLE_ACCOUNTING;
case STUnderlineValues.INT_SINGLE:
return SINGLE;
case STUnderlineValues.INT_SINGLE_ACCOUNTING:
return SINGLE_ACCOUNTING;
case STUnderlineValues.INT_NONE:
return NONE;
}
throw new RuntimeException("Underline value ["+ underline +"] not supported");
}
}

17
src/ooxml/java/org/apache/poi/xssf/usermodel/IndexedColors.java
View File

@ -1,3 +1,20 @@
/* ====================================================================
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;
/**

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

@ -16,13 +16,12 @@
==================================================================== */
package org.apache.poi.xssf.usermodel;
import org.apache.poi.ss.usermodel.Font;
import java.util.ArrayList;
import org.apache.poi.xssf.util.Charset;
import org.apache.poi.ss.usermodel.Font;
import org.apache.poi.xssf.usermodel.extensions.XSSFColor;
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;
@ -30,27 +29,11 @@ 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;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.STFontScheme;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.STUnderlineValues;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.STVerticalAlignRun;
import java.util.ArrayList;
public class XSSFFont implements Font {
public static final int SCHEME_MAJOR=2;
public static final int SCHEME_MINOR=3;
public static final int SCHEME_NONE=0;
public static final int FONT_FAMILY_NOT_APPLICABLE=0;
public static final int FONT_FAMILY_ROMAN=1;
public static final int FONT_FAMILY_SWISS=2;
public static final int FONT_FAMILY_MODERN=3;
public static final int FONT_FAMILY_SCRIPT=4;
public static final int FONT_FAMILY_DECORATIVE=5;
public static final String DEFAULT_FONT_NAME="Calibri";
public static final short DEFAULT_FONT_SIZE=11;
public static final short DEFAULT_FONT_COLOR = IndexedColors.BLACK.getIndex();
@ -70,48 +53,27 @@ public class XSSFFont implements Font {
return ctFont;
}
/**
*
*/
public boolean getBold() {
CTBooleanProperty bold=ctFont.sizeOfBArray() == 0 ? null : ctFont.getBArray(0);
return (bold!=null && bold.getVal());
}
public byte getCharSet() {
CTIntProperty charset= ctFont.sizeOfCharsetArray() == 0?null:ctFont.getCharsetArray(0);
if(charset!=null){
//this value must be set -- can't be null
switch (charset.getVal()) {
case Charset.ANSI_CHARSET:
return Font.ANSI_CHARSET;
case Charset.DEFAULT_CHARSET:
return Font.DEFAULT_CHARSET;
case Charset.SYMBOL_CHARSET:
return Font.SYMBOL_CHARSET;
default://maight be correct to return this byte value???
return Byte.parseByte(Integer.toString(charset.getVal()));
}
}
else
return Font.ANSI_CHARSET;
return charset == null ? FontCharset.ANSI.getValue() : FontCharset.valueOf(charset.getVal()).getValue();
}
public short getColor() {
CTColor color=ctFont.sizeOfColorArray()==0?null: ctFont.getColorArray(0);
if(color == null) return Font.COLOR_NORMAL;
if(color == null) return IndexedColors.BLACK.getIndex();
long index=color.getIndexed();
if (index==XSSFFont.DEFAULT_FONT_COLOR){
return Font.COLOR_NORMAL;
return IndexedColors.BLACK.getIndex();
}
else if(index == IndexedColors.RED.getIndex()){
return Font.COLOR_RED;
return IndexedColors.RED.getIndex();
}
else{
return Short.parseShort(new Long(index).toString());
@ -119,9 +81,10 @@ public class XSSFFont implements Font {
}
public byte[] getRgbColor() {
CTColor color=ctFont.sizeOfColorArray()==0?null: ctFont.getColorArray(0);
return color.getRgb();
public XSSFColor getRgbColor() {
CTColor ctColor=ctFont.sizeOfColorArray()==0?null: ctFont.getColorArray(0);
XSSFColor color=new XSSFColor(ctColor);
return color;
}
public short getThemeColor() {
@ -134,13 +97,14 @@ public class XSSFFont implements Font {
public short getFontHeight() {
CTFontSize size=ctFont.sizeOfSzArray()==0?null: ctFont.getSzArray(0);
if(size!=null){
double fontHeight= size.getVal()/20;
double fontHeight= size.getVal();
return (short)fontHeight;
}
else
return DEFAULT_FONT_SIZE/20;
return DEFAULT_FONT_SIZE;
}
public short getFontHeightInPoints() {
CTFontSize size=ctFont.sizeOfSzArray()==0?null: ctFont.getSzArray(0);
if(size!=null){
@ -152,9 +116,9 @@ public class XSSFFont implements Font {
}
public String getFontName() {
CTFontName name=ctFont.sizeOfNameArray()==0?null:ctFont.getNameArray(0);
return name==null? null:name.getVal();
public String getFontName() {
CTFontName name = ctFont.sizeOfNameArray() == 0 ? null : ctFont.getNameArray(0);
return name == null ? null : name.getVal();
}
@ -187,26 +151,31 @@ public class XSSFFont implements Font {
}
public byte getUnderline() {
CTUnderlineProperty underline=ctFont.sizeOfUArray()==0?null:ctFont.getUArray(0);
if(underline!=null){
switch (underline.getVal().intValue()) {
case STUnderlineValues.INT_DOUBLE:
return Font.U_DOUBLE;
case STUnderlineValues.INT_DOUBLE_ACCOUNTING:
return Font.U_DOUBLE_ACCOUNTING;
/*
CTUnderlineProperty underline = ctFont.sizeOfUArray() == 0 ? null : ctFont.getUArray(0);
return underline == null ? (byte)FontUnderline.NONE.getValue().intValue() : (byte)FontUnderline.valueOf(underline.getVal()).getValue().intValue();
*/
CTUnderlineProperty underline=ctFont.sizeOfUArray()==0?null:ctFont.getUArray(0);
if(underline!=null){
FontUnderline fontUnderline=FontUnderline.valueOf(underline.getVal());
switch (fontUnderline.getValue().intValue()) {
case STUnderlineValues.INT_DOUBLE:
return Font.U_DOUBLE;
case STUnderlineValues.INT_DOUBLE_ACCOUNTING:
return Font.U_DOUBLE_ACCOUNTING;
case STUnderlineValues.INT_SINGLE_ACCOUNTING:
return Font.U_SINGLE_ACCOUNTING;
case STUnderlineValues.INT_SINGLE_ACCOUNTING:
return Font.U_SINGLE_ACCOUNTING;
case STUnderlineValues.INT_NONE:
return Font.U_NONE;
case STUnderlineValues.INT_NONE:
return Font.U_NONE;
case STUnderlineValues.INT_SINGLE:
default:
return Font.U_SINGLE;
}
}
return Font.U_NONE;
case STUnderlineValues.INT_SINGLE:
default:
return Font.U_SINGLE;
}
}
return Font.U_NONE;
}
/**
@ -218,20 +187,18 @@ public class XSSFFont implements Font {
ctBold.setVal(true);
}
/**
*
*/
public void setCharSet(byte charset) {
CTIntProperty charsetProperty=ctFont.sizeOfCharsetArray()==0?ctFont.addNewCharset():ctFont.getCharsetArray(0);
switch (charset) {
case Font.ANSI_CHARSET:
charsetProperty.setVal(Charset.ANSI_CHARSET);
charsetProperty.setVal(FontCharset.ANSI.getValue());
break;
case Font.SYMBOL_CHARSET:
charsetProperty.setVal(Charset.SYMBOL_CHARSET);
charsetProperty.setVal(FontCharset.SYMBOL.getValue());
break;
case Font.DEFAULT_CHARSET:
charsetProperty.setVal(Charset.DEFAULT_CHARSET);
charsetProperty.setVal(FontCharset.DEFAULT.getValue());
break;
default:
throw new RuntimeException("Attention: an attempt to set a type of unknow charset and charset");
@ -239,6 +206,10 @@ public class XSSFFont implements Font {
}
public void setCharSet(FontCharset charSet) {
setCharSet(charSet.getValue());
}
public void setColor(short color) {
CTColor ctColor=ctFont.sizeOfColorArray()==0?ctFont.addNewColor():ctFont.getColorArray(0);
@ -257,24 +228,24 @@ public class XSSFFont implements Font {
}
public void setFontHeight(short height) {
CTFontSize fontSize=ctFont.sizeOfSzArray()==0?ctFont.addNewSz():ctFont.getSzArray(0);
fontSize.setVal(height*20);
setFontHeight((double)height);
}
public void setFontHeight(double height) {
CTFontSize fontSize=ctFont.sizeOfSzArray()==0?ctFont.addNewSz():ctFont.getSzArray(0);
fontSize.setVal(height);
}
public void setFontHeightInPoints(short height) {
CTFontSize fontSize=ctFont.sizeOfSzArray()==0?ctFont.addNewSz():ctFont.getSzArray(0);
fontSize.setVal(height);
setFontHeight((double)height);
}
public void setRgbColor(XSSFColor color) {
CTColor ctColor=ctFont.sizeOfColorArray()==0?ctFont.addNewColor():ctFont.getColorArray(0);
ctColor.setRgb(color.getRgb());
}
public void setRgbColor(XSSFColor color) {
CTColor ctColor=ctFont.sizeOfColorArray()==0?ctFont.addNewColor():ctFont.getColorArray(0);
ctColor.setRgb(color.getRgb());
}
public void setThemeColor(short theme) {
CTColor ctColor=ctFont.sizeOfColorArray()==0?ctFont.addNewColor():ctFont.getColorArray(0);
@ -282,8 +253,8 @@ public class XSSFFont implements Font {
}
public void setFontName(String name) {
CTFontName fontName=ctFont.sizeOfNameArray()==0?ctFont.addNewName():ctFont.getNameArray(0);
fontName.setVal(name);
CTFontName fontName=ctFont.sizeOfNameArray()==0?ctFont.addNewName():ctFont.getNameArray(0);
fontName.setVal(name);
}
public void setItalic(boolean italic) {
@ -297,7 +268,7 @@ public class XSSFFont implements Font {
}
public void setTypeOffset(short offset) {
CTVerticalAlignFontProperty offsetProperty=ctFont.sizeOfVertAlignArray()==0?ctFont.addNewVertAlign(): ctFont.getVertAlignArray(0);
CTVerticalAlignFontProperty offsetProperty=ctFont.sizeOfVertAlignArray()==0?ctFont.addNewVertAlign(): ctFont.getVertAlignArray(0);
switch (offset) {
case Font.SS_NONE:
offsetProperty.setVal(STVerticalAlignRun.BASELINE);
@ -315,25 +286,36 @@ public class XSSFFont implements Font {
CTUnderlineProperty ctUnderline=ctFont.sizeOfUArray()==0?ctFont.addNewU():ctFont.getUArray(0);
switch (underline) {
case Font.U_DOUBLE:
ctUnderline.setVal(STUnderlineValues.DOUBLE);
ctUnderline.setVal(FontUnderline.DOUBLE.getValue());
break;
case Font.U_DOUBLE_ACCOUNTING:
ctUnderline.setVal(STUnderlineValues.DOUBLE_ACCOUNTING);
ctUnderline.setVal(FontUnderline.DOUBLE_ACCOUNTING.getValue());
break;
case Font.U_SINGLE_ACCOUNTING:
ctUnderline.setVal(STUnderlineValues.SINGLE_ACCOUNTING);
ctUnderline.setVal(FontUnderline.SINGLE_ACCOUNTING.getValue());
break;
case Font.U_NONE:
ctUnderline.setVal(STUnderlineValues.NONE);
ctUnderline.setVal(FontUnderline.NONE.getValue());
break;
case Font.U_SINGLE:
default:
ctUnderline.setVal(STUnderlineValues.SINGLE);
ctUnderline.setVal(FontUnderline.SINGLE.getValue());
break;
}
}
public void setUnderline(FontUnderline underline) {
CTUnderlineProperty ctUnderline=ctFont.sizeOfUArray()==0?ctFont.addNewU():ctFont.getUArray(0);
ctUnderline.setVal(underline.getValue());
}
public String toString(){
return "org.apache.poi.xssf.usermodel.XSSFFont{" +
ctFont +
"}";
}
public long putFont(ArrayList<CTFont> fonts) {
//TODO
@ -349,58 +331,37 @@ public class XSSFFont implements Font {
return fonts.size() - 1;
}
// solo di xssfFont - non di Font-
//sono utilizzati nel metodo createDefaultFont in StylesTable insta.
/*
this methds are used only for XSSFFont and aren't in Font interface
are used in method SthlesTable.createDefaultfont
*/
public int getScheme(){
public FontScheme getScheme(){
CTFontScheme scheme=ctFont.sizeOfSchemeArray()==0?null:ctFont.getSchemeArray(0);
if(scheme!=null){
int fontScheme = scheme.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;
}
}
return 0;
return scheme == null ? FontScheme.NONE : FontScheme.valueOf(scheme.getVal());
}
public void setScheme(int scheme){
public void setScheme(FontScheme scheme){
CTFontScheme ctFontScheme=ctFont.sizeOfSchemeArray()==0?ctFont.addNewScheme():ctFont.getSchemeArray(0);
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");
}
ctFontScheme.setVal(scheme.getValue());
}
public int getFamily(){
CTIntProperty family=ctFont.sizeOfFamilyArray()==0?ctFont.addNewFamily():ctFont.getFamilyArray(0);
if(family!=null)
return family.getVal();
else
return XSSFFont.FONT_FAMILY_SWISS;
CTIntProperty family = ctFont.sizeOfFamilyArray() == 0 ? ctFont.addNewFamily() : ctFont.getFamilyArray(0);
return family == null ? FontFamily.NOT_APPLICABLE.getValue() : FontFamily.valueOf(family.getVal()).getValue();
}
public void setFamily(int value){
CTIntProperty family=ctFont.sizeOfFamilyArray()==0?ctFont.addNewFamily():ctFont.getFamilyArray(0);
public void setFamily(int value){
CTIntProperty family = ctFont.sizeOfFamilyArray() == 0 ? ctFont.addNewFamily() : ctFont.getFamilyArray(0);
family.setVal(value);
}
public void setFamily(FontFamily family){
setFamily(family.getValue());
}
}

27
src/ooxml/java/org/apache/poi/xssf/util/Charset.java
View File

@ -1,27 +0,0 @@
package org.apache.poi.xssf.util;
public class Charset {
public static final int ANSI_CHARSET=0;
public static final int DEFAULT_CHARSET=1;
public static final int SYMBOL_CHARSET=2;
public static final int MAC_CHARSET=77;
public static final int SHIFTJIS_CHARSET=128;
public static final int HANGEUL_CHARSET=129;
public static final int HANGUL_CHARSET=129;
public static final int JOHAB_CHARSET=130;
public static final int GB2312_CHARSET=134;
public static final int CHINESEBIG5_CHARSET=136;
public static final int GREEK_CHARSET=161;
public static final int TURKISH_CHARSET=162;
public static final int VIETNAMESE_CHARSET=163;
public static final int HEBREW_CHARSET=177;
public static final int ARABIC_CHARSET=178;
public static final int BALTIC_CHARSET=186;
public static final int RUSSIAN_CHARSET=204;
public static final int THAI_CHARSET=222;
public static final int EASTEUROPE_CHARSET=238;
public static final int OEM_CHARSET=255;
}

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

@ -13,7 +13,7 @@ import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.Font;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.xssf.util.Charset;
import org.apache.poi.xssf.usermodel.extensions.XSSFColor;
import org.openxml4j.opc.Package;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTBooleanProperty;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTColor;
@ -54,14 +54,14 @@ public class TestXSSFFont extends TestCase{
public void testCharSet(){
CTFont ctFont=CTFont.Factory.newInstance();
CTIntProperty prop=ctFont.addNewCharset();
prop.setVal(Charset.ANSI_CHARSET);
prop.setVal(FontCharset.ANSI.getValue());
ctFont.setCharsetArray(0,prop);
XSSFFont xssfFont=new XSSFFont(ctFont);
assertEquals(Font.ANSI_CHARSET,xssfFont.getCharSet());
xssfFont.setCharSet(Font.DEFAULT_CHARSET);
assertEquals(Charset.DEFAULT_CHARSET,ctFont.getCharsetArray(0).getVal());
xssfFont.setCharSet(FontCharset.DEFAULT);
assertEquals(FontCharset.DEFAULT.getValue(),ctFont.getCharsetArray(0).getVal());
}
@ -118,10 +118,10 @@ public class TestXSSFFont extends TestCase{
ctFont.setSzArray(0,size);
XSSFFont xssfFont=new XSSFFont(ctFont);
assertEquals(11/20,xssfFont.getFontHeight());
assertEquals(11,xssfFont.getFontHeight());
xssfFont.setFontHeight((short)20);
assertEquals(new Double(20*20).doubleValue(),ctFont.getSzArray(0).getVal());
assertEquals(new Double(20).doubleValue(),ctFont.getSzArray(0).getVal());
}
@ -151,7 +151,11 @@ public class TestXSSFFont extends TestCase{
xssfFont.setUnderline(Font.U_DOUBLE);
assertEquals(ctFont.getUArray().length,1);
assertEquals(STUnderlineValues.DOUBLE,ctFont.getUArray(0).getVal());
}
xssfFont.setUnderline(FontUnderline.DOUBLE_ACCOUNTING);
assertEquals(ctFont.getUArray().length,1);
assertEquals(STUnderlineValues.DOUBLE_ACCOUNTING,ctFont.getUArray(0).getVal());
}
public void testColor(){
CTFont ctFont=CTFont.Factory.newInstance();
@ -160,47 +164,52 @@ public class TestXSSFFont extends TestCase{
ctFont.setColorArray(0,color);
XSSFFont xssfFont=new XSSFFont(ctFont);
assertEquals(Font.COLOR_NORMAL,xssfFont.getColor());
assertEquals(IndexedColors.BLACK.getIndex(),xssfFont.getColor());
xssfFont.setColor(IndexedColors.RED.getIndex());
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);
CTFont ctFont=CTFont.Factory.newInstance();
CTColor color=ctFont.addNewColor();
XSSFFont xssfFont=new XSSFFont(ctFont);
assertEquals(,xssfFont.getRgbColor());
color.setRgb(Integer.toHexString(0xFFFFFF).getBytes());
ctFont.setColorArray(0,color);
xssfFont.setRgbColor(new XSSFColor(new java.awt.Color(10,19,10)));
//assertEquals(,ctFont.getColorArray(0).getRgb());
XSSFFont xssfFont=new XSSFFont(ctFont);
assertEquals(ctFont.getColorArray(0).getRgb()[0],xssfFont.getRgbColor().getRgb()[0]);
assertEquals(ctFont.getColorArray(0).getRgb()[1],xssfFont.getRgbColor().getRgb()[1]);
assertEquals(ctFont.getColorArray(0).getRgb()[2],xssfFont.getRgbColor().getRgb()[2]);
assertEquals(ctFont.getColorArray(0).getRgb()[3],xssfFont.getRgbColor().getRgb()[3]);
color.setRgb(Integer.toHexString(0xF1F1F1).getBytes());
XSSFColor newColor=new XSSFColor(color);
xssfFont.setRgbColor(newColor);
assertEquals(ctFont.getColorArray(0).getRgb()[2],newColor.getRgb()[2]);
}
public void testThemeColor(){
CTFont ctFont=CTFont.Factory.newInstance();
CTColor color=ctFont.addNewColor();
color.setTheme();
ctFont.setColorArray(0,color);
CTFont ctFont=CTFont.Factory.newInstance();
CTColor color=ctFont.addNewColor();
color.setTheme((long)1);
ctFont.setColorArray(0,color);
XSSFFont xssfFont=new XSSFFont(ctFont);
assertEquals(,xssfFont.getThemeColor());
XSSFFont xssfFont=new XSSFFont(ctFont);
assertEquals(ctFont.getColorArray(0).getTheme(),xssfFont.getThemeColor());
xssfFont.setThemeColor(Font.COLOR_RED);
assertEquals(,ctFont.getColorArray(0).getTheme());
assertEquals(,ctFont.getColorArray(0).getTint());
xssfFont.setThemeColor(IndexedColors.RED.getIndex());
assertEquals(IndexedColors.RED.getIndex(),ctFont.getColorArray(0).getTheme());
}
*/
public void testFamily(){
CTFont ctFont=CTFont.Factory.newInstance();
CTIntProperty family=ctFont.addNewFamily();
family.setVal(XSSFFont.FONT_FAMILY_MODERN);
family.setVal(FontFamily.MODERN.getValue());
ctFont.setFamilyArray(0,family);
XSSFFont xssfFont=new XSSFFont(ctFont);
assertEquals(XSSFFont.FONT_FAMILY_MODERN,xssfFont.getFamily());
assertEquals(FontFamily.MODERN.getValue(),xssfFont.getFamily());
}
@ -211,9 +220,9 @@ public class TestXSSFFont extends TestCase{
ctFont.setSchemeArray(0,scheme);
XSSFFont font=new XSSFFont(ctFont);
assertEquals(XSSFFont.SCHEME_MAJOR,font.getScheme());
assertEquals(FontScheme.MAJOR,font.getScheme());
font.setScheme(XSSFFont.SCHEME_NONE);
font.setScheme(FontScheme.NONE);
assertEquals(STFontScheme.NONE,ctFont.getSchemeArray(0).getVal());
}
@ -332,7 +341,7 @@ public class TestXSSFFont extends TestCase{
Font font2=new XSSFFont();
font2.setFontHeight((short)1);
font2.setFontName("Courier");
font2.setColor(Font.COLOR_NORMAL);
font2.setColor(IndexedColors.BLACK.getIndex());
font2.setUnderline(Font.U_DOUBLE);
CellStyle cellStyle2=workbook.createCellStyle();
cellStyle2.setFont(font2);
@ -362,5 +371,4 @@ public class TestXSSFFont extends TestCase{
out.close();
}
}

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

@ -242,7 +242,7 @@ public class TestXSSFWorkbook extends TestCase {
public void testFindFont(){
//get dafault font and check against default value
XSSFWorkbook workbook = new XSSFWorkbook();
Font fontFind=workbook.findFont(Font.BOLDWEIGHT_NORMAL, Font.COLOR_NORMAL, (short)11, "Calibri", false, false, Font.SS_NONE, Font.U_NONE);
Font fontFind=workbook.findFont(Font.BOLDWEIGHT_NORMAL, IndexedColors.BLACK.getIndex(), (short)11, "Calibri", false, false, Font.SS_NONE, Font.U_NONE);
assertNotNull(fontFind);
//get default font, then change 2 values and check against different values (height changes)
@ -251,9 +251,8 @@ public class TestXSSFWorkbook extends TestCase {
font.setUnderline(Font.U_DOUBLE);
StylesSource styleSource=new StylesTable();
long index=styleSource.putFont(font);
System.out.println("index="+index);
workbook.setStylesSource(styleSource);
fontFind=workbook.findFont(Font.BOLDWEIGHT_BOLD, Font.COLOR_NORMAL, (short)15, "Calibri", false, false, Font.SS_NONE, Font.U_DOUBLE);
fontFind=workbook.findFont(Font.BOLDWEIGHT_BOLD, IndexedColors.BLACK.getIndex(), (short)15, "Calibri", false, false, Font.SS_NONE, Font.U_DOUBLE);
assertNull(fontFind);
}
@ -291,6 +290,7 @@ public class TestXSSFWorkbook extends TestCase {
assertNotNull(fontAt);
}
public void testGetNumberOfFonts(){
XSSFWorkbook wb = new XSSFWorkbook();