org.apache.poi.xssf.usermodel.XSSFRichTextString Maven / Gradle / Ivy
/* ====================================================================
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.apache.poi.ss.usermodel.Font;
import org.apache.poi.ss.usermodel.RichTextString;
import org.apache.poi.util.Internal;
import org.apache.poi.xssf.model.StylesTable;
import org.apache.poi.xssf.model.ThemesTable;
import org.apache.xmlbeans.XmlCursor;
import org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STXstring;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTColor;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTFont;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTRElt;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTRPrElt;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTRst;
import javax.xml.namespace.QName;
import java.util.Iterator;
import java.util.Map;
import java.util.SortedMap;
import java.util.TreeMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* Rich text unicode string. These strings can have fonts applied to arbitary parts of the string.
*
*
* 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,
* and the string for the cell can be shared across the workbook. The following code illustrates the example.
*
*
*
*
* cell1.setCellValue(new XSSFRichTextString("Apache POI"));
* cell2.setCellValue(new XSSFRichTextString("Apache POI"));
* cell3.setCellValue(new XSSFRichTextString("Apache POI"));
*
*
* In the above example all three cells will use the same string cached on workbook level.
*
*
* Some strings in the workbook may have formatting applied at a level that is more granular than the cell level.
* For instance, specific characters within the string may be bolded, have coloring, italicizing, etc.
* In these cases, the formatting is stored along with the text in the string table, and is treated as
* a unique entry in the workbook. The following xml and code snippet illustrate this.
*
*
*
*
* XSSFRichTextString s1 = new XSSFRichTextString("Apache POI");
* s1.applyFont(boldArial);
* cell1.setCellValue(s1);
*
* XSSFRichTextString s2 = new XSSFRichTextString("Apache POI");
* s2.applyFont(italicCourier);
* cell2.setCellValue(s2);
*
*
*/
public class XSSFRichTextString implements RichTextString {
private static final Pattern utfPtrn = Pattern.compile("_x([0-9A-Fa-f]{4})_");
private CTRst st;
private StylesTable styles;
/**
* Create a rich text string
*/
public XSSFRichTextString(String str) {
st = CTRst.Factory.newInstance();
st.setT(str);
preserveSpaces(st.xgetT());
}
/**
* Create empty rich text string and initialize it with empty string
*/
public XSSFRichTextString() {
st = CTRst.Factory.newInstance();
}
/**
* Create a rich text string from the supplied XML bean
*/
@Internal
public XSSFRichTextString(CTRst st) {
this.st = st;
}
/**
* Applies a font to the specified characters of a string.
*
* @param startIndex The start index to apply the font to (inclusive)
* @param endIndex The end index to apply the font to (exclusive)
* @param fontIndex The font to use.
*/
public void applyFont(int startIndex, int endIndex, short fontIndex) {
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);
} else {
font = styles.getFontAt(fontIndex);
}
applyFont(startIndex, endIndex, font);
}
/**
* Applies a font to the specified characters of a string.
*
* @param startIndex The start index to apply the font to (inclusive)
* @param endIndex The end index to apply to font to (exclusive)
* @param font The index of the font to use.
*/
public void applyFont(int startIndex, int endIndex, Font font) {
if (startIndex > endIndex)
throw new IllegalArgumentException("Start index must be less than end index, but had " + startIndex + " and " + endIndex);
if (startIndex < 0 || endIndex > length())
throw new IllegalArgumentException("Start and end index not in range, but had " + startIndex + " and " + endIndex);
if (startIndex == endIndex)
return;
if(st.sizeOfRArray() == 0 && st.isSetT()) {
//convert string into a text run: string formats = getFormatMap(st);
CTRPrElt fmt = CTRPrElt.Factory.newInstance();
setRunAttributes(xssfFont.getCTFont(), fmt);
applyFont(formats, startIndex, endIndex, fmt);
CTRst newSt = buildCTRst(text, formats);
st.set(newSt);
}
/**
* Sets the font of the entire string.
* @param font The font to use.
*/
public void applyFont(Font font) {
String text = getString();
applyFont(0, text.length(), font);
}
/**
* Applies the specified font to the entire string.
*
* @param fontIndex the font to apply.
*/
public void applyFont(short fontIndex) {
XSSFFont font;
if(styles == null) {
font = new XSSFFont();
font.setFontName("#" + fontIndex);
} else {
font = styles.getFontAt(fontIndex);
}
String text = getString();
applyFont(0, text.length(), 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 null if no formatting is required
*/
public void append(String text, XSSFFont font){
if(st.sizeOfRArray() == 0 && st.isSetT()) {
//convert string into a text run: string
* Example: The Unicode character 0D is invalid in an XML 1.0 document,
* so it shall be escaped as _x000D_.
*
* See section 3.18.9 in the OOXML spec.
*
* @param value the string to decode
* @return the decoded string or null if the input string is null
*/
static String utfDecode(String value) {
if(value == null || !value.contains("_x")) {
return value;
}
StringBuilder buf = new StringBuilder();
Matcher m = utfPtrn.matcher(value);
int idx = 0;
while(m.find()) {
int pos = m.start();
if( pos > idx) {
buf.append(value, idx, pos);
}
String code = m.group(1);
int icode = Integer.decode("0x" + code);
buf.append((char)icode);
idx = m.end();
}
// small optimization: don't go via StringBuilder if not necessary,
// the encodings are very rare, so we should almost always go via this shortcut.
if(idx == 0) {
return value;
}
buf.append(value.substring(idx));
return buf.toString();
}
void applyFont(TreeMap formats, int startIndex, int endIndex, CTRPrElt fmt) {
// delete format runs that fit between startIndex and endIndex
// runs intersecting startIndex and endIndex remain
int runStartIdx = 0;
for (Iterator it = formats.keySet().iterator(); it.hasNext(); ) {
int runEndIdx = it.next();
if (runStartIdx >= startIndex && runEndIdx < endIndex) {
it.remove();
}
runStartIdx = runEndIdx;
}
if (startIndex > 0 && !formats.containsKey(startIndex)) {
// If there's a format that starts later in the string, make it start now
for (Map.Entry entry : formats.entrySet()) {
if (entry.getKey() > startIndex) {
formats.put(startIndex, entry.getValue());
break;
}
}
}
formats.put(endIndex, fmt);
// assure that the range [startIndex, endIndex] consists if a single run
// there can be two or three runs depending whether startIndex or endIndex
// intersected existing format runs
SortedMap sub = formats.subMap(startIndex, endIndex);
while (sub.size() > 1) sub.remove(sub.lastKey());
}
TreeMap getFormatMap(CTRst entry){
int length = 0;
TreeMap formats = new TreeMap<>();
//noinspection deprecation - for performance reasons!
for (CTRElt r : entry.getRArray()) {
String txt = r.getT();
CTRPrElt fmt = r.getRPr();
length += utfLength(txt);
formats.put(length, fmt);
}
return formats;
}
CTRst buildCTRst(String text, TreeMap formats){
if(text.length() != formats.lastKey()) {
throw new IllegalArgumentException("Text length was " + text.length() +
" but the last format index was " + formats.lastKey());
}
CTRst stf = CTRst.Factory.newInstance();
int runStartIdx = 0;
for (Map.Entry me : formats.entrySet()) {
int runEndIdx = me.getKey();
CTRElt run = stf.addNewR();
String fragment = text.substring(runStartIdx, runEndIdx);
run.setT(fragment);
preserveSpaces(run.xgetT());
CTRPrElt fmt = me.getValue();
if (fmt != null) {
run.setRPr(fmt);
}
runStartIdx = runEndIdx;
}
return stf;
}
private ThemesTable getThemesTable() {
if(styles == null) return null;
return styles.getTheme();
}
}