PoiCssUtils.java
6.84 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
package com.bckefu.excel.util;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.hssf.usermodel.HSSFPalette;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.util.HSSFColor;
import org.apache.poi.xssf.usermodel.XSSFColor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.awt.*;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* @author : caoliang
* @date : 2017/11/20 下午3:53
*/
public class PoiCssUtils {
private static final Logger log = LoggerFactory.getLogger(PoiCssUtils.class);
private static final String COLOR_PATTERN_VALUE_SHORT = "^(#(?:[a-f]|\\d){3})$";
private static final String COLOR_PATTERN_VALUE_LONG = "^(#(?:[a-f]|\\d{2}){3})$";
private static final String COLOR_PATTERN_RGB = "^(rgb\\s*\\(\\s*(.+)\\s*,\\s*(.+)\\s*,\\s*(.+)\\s*\\))$";
private static final Pattern COLOR_PATTERN_VALUE_SHORT_PATTERN = Pattern.compile("([a-f]|\\d)");
private static final Pattern INT_PATTERN = Pattern.compile("^(\\d+)(?:\\w+|%)?$");
private static final Pattern INT_AND_PER_PATTERN = Pattern.compile("^(\\d*\\.?\\d+)\\s*(%)?$");
private static Map<String, HSSFColor> colors = new HashMap<String, HSSFColor>();
static {
for (Map.Entry<Integer, HSSFColor> color : HSSFColor.getIndexHash().entrySet()) {
colors.put(colorName(color.getValue().getClass()), color.getValue());
}
// light gray
HSSFColor color = colors.get(colorName(HSSFColor.GREY_25_PERCENT.class));
colors.put("lightgray", color);
colors.put("lightgrey", color);
// silver
colors.put("silver", colors.get(colorName(HSSFColor.GREY_40_PERCENT.class)));
// darkgray
color = colors.get(colorName(HSSFColor.GREY_50_PERCENT.class));
colors.put("darkgray", color);
colors.put("darkgrey", color);
// gray
color = colors.get(colorName(HSSFColor.GREY_80_PERCENT.class));
colors.put("gray", color);
colors.put("grey", color);
}
/**
* get color name
*
* @param color HSSFColor
* @return color name
*/
private static String colorName(Class<? extends HSSFColor> color) {
return color.getSimpleName().replace("_", "").toLowerCase();
}
/**
* get int value of string
*
* @param strValue string value
* @return int value
*/
public static int getInt(String strValue) {
int value = 0;
if (StringUtils.isNotBlank(strValue)) {
Matcher m = INT_PATTERN.matcher(strValue);
if (m.find()) {
value = Integer.parseInt(m.group(1));
}
}
return value;
}
/**
* check number string
*
* @param strValue string
* @return true if string is number
*/
public static boolean isNum(String strValue) {
return StringUtils.isNotBlank(strValue) && strValue.matches("^\\d+(\\w+|%)?$");
}
/**
* process color
*
* @param color color to process
* @return color after process
*/
public static String processColor(String color) {
log.info("Process Color [{}].", color);
String colorRtn = null;
if (StringUtils.isNotBlank(color)) {
HSSFColor poiColor = null;
// #rgb -> #rrggbb
if (color.matches(COLOR_PATTERN_VALUE_SHORT)) {
log.debug("Short Hex Color [{}] Found.", color);
StringBuffer sbColor = new StringBuffer();
Matcher m = COLOR_PATTERN_VALUE_SHORT_PATTERN.matcher(color);
while (m.find()) {
m.appendReplacement(sbColor, "$1$1");
}
colorRtn = sbColor.toString();
log.debug("Translate Short Hex Color [{}] To [{}].", color, colorRtn);
}
// #rrggbb
else if (color.matches(COLOR_PATTERN_VALUE_LONG)) {
colorRtn = color;
log.debug("Hex Color [{}] Found, Return.", color);
}
// rgb(r, g, b)
else if (color.matches(COLOR_PATTERN_RGB)) {
Matcher m = Pattern.compile(COLOR_PATTERN_RGB).matcher(color);
if (m.matches()) {
log.debug("RGB Color [{}] Found.", color);
colorRtn = convertColor(calcColorValue(m.group(2)), calcColorValue(m.group(3)),
calcColorValue(m.group(4)));
log.debug("Translate RGB Color [{}] To Hex [{}].", color, colorRtn);
}
}
// color name, red, green, ...
else if ((poiColor = getColor(color)) != null) {
log.debug("Color Name [{}] Found.", color);
short[] t = poiColor.getTriplet();
colorRtn = convertColor(t[0], t[1], t[2]);
log.debug("Translate Color Name [{}] To Hex [{}].", color, colorRtn);
}
}
return colorRtn;
}
/**
* parse color
*
* @param workBook work book
* @param color string color
* @return HSSFColor
*/
public static HSSFColor parseColor(HSSFWorkbook workBook, String color) {
HSSFColor poiColor = null;
if (StringUtils.isNotBlank(color)) {
Color awtColor = Color.decode(color);
if (awtColor != null) {
int r = awtColor.getRed();
int g = awtColor.getGreen();
int b = awtColor.getBlue();
HSSFPalette palette = workBook.getCustomPalette();
poiColor = palette.findColor((byte) r, (byte) g, (byte) b);
if (poiColor == null) {
poiColor = palette.findSimilarColor(r, g, b);
}
}
}
return poiColor;
}
public static XSSFColor parseColor(String color) {
XSSFColor poiColor = null;
if (StringUtils.isNotBlank(color)) {
Color awtColor = Color.decode(color);
if (awtColor != null) {
poiColor = new XSSFColor(awtColor);
}
}
return poiColor;
}
// --
// private methods
private static HSSFColor getColor(String color) {
return colors.get(color.replace("_", ""));
}
private static String convertColor(int r, int g, int b) {
return String.format("#%02x%02x%02x", r, g, b);
}
public static int calcColorValue(String color) {
int rtn = 0;
// matches 64 or 64%
Matcher m = INT_AND_PER_PATTERN.matcher(color);
if (m.matches()) {
// % not found
if (m.group(2) == null) {
rtn = Math.round(Float.parseFloat(m.group(1))) % 256;
} else {
rtn = Math.round(Float.parseFloat(m.group(1)) * 255 / 100) % 256;
}
}
return rtn;
}
}