File f = new File(root, entry.getName());\r
FileOutputStream out = new FileOutputStream(f);\r
\r
- if(entry.getName().endsWith(".xml") || entry.getName().endsWith(".vml")){\r
+ if(entry.getName().endsWith(".xml") || entry.getName().endsWith(".vml") || entry.getName().endsWith(".rels")){\r
//pass the xml through the Xerces serializer to produce nicely formatted output\r
Document doc = builder.parse(zip.getInputStream(entry));\r
\r
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;
*/
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());
}
doc.getStyleSheet().setCellStyleXfs(ctSXfs);
}
- // Style dxf
+ // Style dxfs
if(dxfs.size() > 0) {
CTDxfs ctDxfs = CTDxfs.Factory.newInstance();
ctDxfs.setCount(dxfs.size());
doc.getStyleSheet().setDxfs(ctDxfs);
}
-
-
// Save
doc.save(out, options);
}
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());
-
- CTFill ctFill = createDefaultFill();
- fills.add(ctFill);
-
- CTBorder ctBorder = createDefaultBorder();
- borders.add(ctBorder);
-
- CTXf styleXf = createDefaultXf();
- styleXfs.add(styleXf);
- CTXf xf = createDefaultXf();
- xf.setXfId(0);
- xfs.add(xf);
+ XSSFFont xssfFont = createDefaultFont();
+ fonts.add(xssfFont.getCTFont());
+
+ CTFill[] ctFill = createDefaultFills();
+ fills.add(ctFill[0]);
+/*
+ fills.add(ctFill[1]);
+*/
+ CTBorder ctBorder = createDefaultBorder();
+ borders.add(ctBorder);
+
+ 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() {
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);
}
--- /dev/null
+/* ====================================================================
+ 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");
+ }
+
+}
--- /dev/null
+/* ====================================================================
+ 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");
+ }
+
+
+}
--- /dev/null
+/* ====================================================================
+ 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");
+ }
+}
--- /dev/null
+/* ====================================================================
+ 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");
+ }
+
+
+}
+/* ====================================================================
+ 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;
/**
==================================================================== */
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;
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();
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());
}
- 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() {
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){
}
- 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();
}
}
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;
-
- case STUnderlineValues.INT_SINGLE_ACCOUNTING:
- return Font.U_SINGLE_ACCOUNTING;
-
- case STUnderlineValues.INT_NONE:
- return Font.U_NONE;
-
- case STUnderlineValues.INT_SINGLE:
- default:
- return Font.U_SINGLE;
- }
- }
- return Font.U_NONE;
+ /*
+ 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_NONE:
+ return Font.U_NONE;
+
+ case STUnderlineValues.INT_SINGLE:
+ default:
+ return Font.U_SINGLE;
+ }
+ }
+ return Font.U_NONE;
}
/**
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");
}
}
+
+ public void setCharSet(FontCharset charSet) {
+ setCharSet(charSet.getValue());
+ }
public void setColor(short color) {
CTColor ctColor=ctFont.sizeOfColorArray()==0?ctFont.addNewColor():ctFont.getColorArray(0);
}
-
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);
}
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) {
}
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);
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
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());
+ }
+
+
}
-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;
-
-
-}
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;
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());
}
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());
}
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();
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);
- 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 testRgbColor(){
+ CTFont ctFont=CTFont.Factory.newInstance();
+ CTColor color=ctFont.addNewColor();
+
+ color.setRgb(Integer.toHexString(0xFFFFFF).getBytes());
+ ctFont.setColorArray(0,color);
+
+ 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());
}
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());
}
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);
out.close();
}
-
}
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)
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);
}
assertNotNull(fontAt);
}
+
public void testGetNumberOfFonts(){
XSSFWorkbook wb = new XSSFWorkbook();
projects / poi.git / commitdiff