i'm working with apache poi and XLSX file. i use xssf classes to dynamically create a spreadsheet.
i'd like to set cell's style in a for loop, but it doesn't seem to work...here's my code :
for(int i=1;i<=gc.getActualMaximum(GregorianCalendar.DAY_OF_MONTH);i++,gc.add(GregorianCalendar.DATE, 1),righe++){
Row r = foglio.createRow(righe);
if(getDayOfWeek(gc)== 6 || getDayOfWeek(gc) == 7){
XSSFCellStyle cs1 = wb.createCellStyle();
cs1.setFillBackgroundColor(IndexedColors.YELLOW.getIndex());
cs1.setFillPattern(CellStyle.SOLID_FOREGROUND);
XSSFFont f = wb.createFont();
f.setBold(true);
f.setColor(IndexedColors.RED.getIndex());
cs1.setFont(f);
Cell c1 = r.createCell(0);
c1.setCellValue(cost.getGiorni().get(getDayOfWeek(gc)-1).getNomeGiorno());
c1.setCellStyle(cs1);
Cell c2 = r.createCell(1);
c2.setCellValue(i);
c2.setCellStyle(cs1);
}
r.createCell(0).setCellValue(cost.getGiorni().get(getDayOfWeek(gc)-1).getNomeGiorno());
r.createCell(1).setCellValue(i);
...this i just a portion of the code...
i can't understand why is not working. Seems like the cellstyle is ignored or overwrited....
any clue ?
CellStyles are per-workbook, and there's a hard limit that Excel imposes on the numbers that a file is allowed to have, so you need to make sure you create the cell style once outside the loop.
Your code would then look something like:
XSSFCellStyle cs1 = wb.createCellStyle();
cs1.setFillBackgroundColor(IndexedColors.YELLOW.getIndex());
cs1.setFillPattern(CellStyle.SOLID_FOREGROUND);
XSSFFont f = wb.createFont();
f.setBold(true);
f.setColor(IndexedColors.RED.getIndex());
cs1.setFont(f);
for(int i=1;i<=gc.getActualMaximum(GregorianCalendar.DAY_OF_MONTH) i++,gc.add(GregorianCalendar.DATE, 1),righe++){
Row r = foglio.createRow(righe);
if(getDayOfWeek(gc)== 6 || getDayOfWeek(gc) == 7){
Cell c1 = r.createCell(0);
c1.setCellValue(cost.getGiorni().get(getDayOfWeek(gc)-1).getNomeGiorno());
c1.setCellStyle(cs1);
Cell c2 = r.createCell(1);
c2.setCellValue(i);
c2.setCellStyle(cs1);
}
}
If you're having issues with the styling not looking quite as you expect, the best option is to style a cell as you want it in Excel, save the file, read that into POI, and review the cell style that Excel wrote. Sometimes, Excel can do some strange things that take some getting used to, so check what it does to work out what you need to be doing!
You can use Following method, perhaps this will resolve your problem.
public static void setCellColorAndFontColor(XSSFCell cell, IndexedColors FGcolor, IndexedColors FontColor ){
XSSFWorkbook wb = cell.getRow().getSheet().getWorkbook();
CellStyle style = wb.createCellStyle();
XSSFFont font = wb.createFont();
font.setBold(true);
font.setColor(FontColor.getIndex());
style.setFont(font);
style.setFillForegroundColor(FGcolor.getIndex());
style.setFillPattern(CellStyle.SOLID_FOREGROUND);
cell.setCellStyle(style);
}
When you are calling this method the way should be like
setCellColorAndFontColor(cell, IndexedColors.BLACK, IndexedColors.WHITE);
will create bold & white font text color with black cell background color in the sheet.
I think the
.setFillPattern(CellStyle.SOLID_FOREGROUND);
got changed to
.setFillPattern(FillPatternType.SOLID_FOREGROUND);
this works for me:
//design settings for header row
Font headerFont = wb.createFont();
headerFont.setColor(IndexedColors.WHITE.getIndex());
CellStyle headerCellStyle = wb.createCellStyle();
headerCellStyle.setFont(headerFont);
headerCellStyle.setAlignment(HorizontalAlignment.CENTER);
headerCellStyle.setVerticalAlignment(VerticalAlignment.CENTER);
headerCellStyle.setFillForegroundColor(IndexedColors.BLACK.getIndex());
headerCellStyle.setFillPattern(FillPatternType.SOLID_FOREGROUND);
Related
I am generating excel sheets using Apache POI. When selecting a cell to edit the background of that cell becomes black. I have shared my code and a screenshot of the excel sheet. I didn't set the background to black from anywhere. I have struggled to solve this error for several hours. If anyone know how to solve this please help me.
public static void writeSummaryToExcel(int rowNumber, int columnNumber, String workBookName, String sheetName,
int sheetColumnSize, Map<String, List<CommonDto>> appDataMap,
List<CommonDto> summaryData) {
log.info("AppSummarySheetGenerator - writeSummaryToExcel() called");
PropertyTemplate propertyTemplate = new PropertyTemplate();
int rowCount = rowNumber;
int columnCount = columnNumber;
try {
File file = new File(workBookName);
// initialing workbook and sheet
workbook = CommonExcelUtils.getWorkbook(file, workBookName);
Sheet sheet = CommonExcelUtils.getWorkbookSheet(workbook, sheetName, sheetColumnSize, false);
Row row;
Cell cell;
if (workbook != null && sheet != null) {
//sheet setting up to first sheet
workbook.setSheetOrder(sheet.getSheetName(), 0);
// cell styles
CellStyle fontRightAlignStyle = workbook.createCellStyle();
fontRightAlignStyle.setAlignment(HorizontalAlignment.RIGHT);
Font boldFont = workbook.createFont();
boldFont.setBold(true);
boldFont.setFontHeightInPoints((short) 12);
CellStyle totalLCellStyle = getCommonTotalCellStyle(boldFont);
totalLCellStyle.setAlignment(HorizontalAlignment.LEFT);
CellStyle totalRCellStyle = getCommonTotalCellStyle(boldFont);
totalRCellStyle.setAlignment(HorizontalAlignment.RIGHT);
CellStyle appCategoryStyle = workbook.createCellStyle();
appCategoryStyle.setFont(boldFont);
appCategoryStyle.setFillPattern(FillPatternType.SOLID_FOREGROUND);
appCategoryStyle.setFillForegroundColor(IndexedColors.LEMON_CHIFFON.index);
appCategoryStyle.setAlignment(HorizontalAlignment.CENTER_SELECTION);
//other code
}
private static CellStyle getCommonTotalCellStyle(Font boldFont) {
CellStyle commonTotalCellStyle = workbook.createCellStyle();
commonTotalCellStyle.setFont(boldFont);
commonTotalCellStyle.setBorderBottom(BorderStyle.MEDIUM);
commonTotalCellStyle.setBorderTop(BorderStyle.MEDIUM);
commonTotalCellStyle.setBorderLeft(BorderStyle.MEDIUM);
commonTotalCellStyle.setBorderRight(BorderStyle.MEDIUM);
commonTotalCellStyle.setFillPattern(FillPatternType.SOLID_FOREGROUND);
commonTotalCellStyle.setFillForegroundColor(IndexedColors.YELLOW.index);
return commonTotalCellStyle;
}
Screenshot of the excel sheet
The only reason I am aware of that this may happen is if there is a cell style applied to the cell which has a fill background color set but either not has a fill pattern set or has a no-fill-pattern set. Then the fill background color gets visible if the cell is in edit mode.
Complete example to test:
import java.io.FileOutputStream;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
class CreateExcelCellBackgroudColor {
public static void main(String[] args) throws Exception {
try (Workbook workbook = new XSSFWorkbook();
FileOutputStream fileout = new FileOutputStream("./Excel.xlsx") ) {
CellStyle style = workbook.createCellStyle();
//style.setFillForegroundColor(IndexedColors.YELLOW.getIndex());
//style.setFillBackgroundColor(IndexedColors.BLACK.getIndex());
style.setFillBackgroundColor((short)0);
//style.setFillPattern(FillPatternType.SOLID_FOREGROUND);
style.setFillPattern(FillPatternType.NO_FILL);
Sheet sheet = workbook.createSheet();
Row row = sheet.createRow(0);
Cell cell = row.createCell(0);
cell.setCellStyle(style);
workbook.write(fileout);
}
}
}
Here cell A1 gets black when in edit mode.
Why is that?
In Excel the cell interiors have pattern fill. There fill foreground color is the color of the pattern and fill background color is the color behind the pattern. If there is a fill background color set but not a pattern, then the background color may get visible.
So the problem is not in the code you have shown. Have a look whether you set CellStyle.setFillBackgroundColor somewhere. But maybe the problem is in the source file already. If so, then the source file probably is not created by Excel.
I want to make the header row of my excel uneditable using poi.
I got various solutions around the internet which say to firstly do sheet.protectSheet("password") which ultimately makes entire sheet uneditable and then loop through all cells which can be editable and set cellStyle for them as cellStyle.setLocked(false).
In my case since the excel just contains headers and rest of the rows will be filled up by the user I can't make the entire sheet uneditable, I just want the headers to be uneditable by the user. How can I achieve this?
Using XSSF the following could be achieved:
Set a CellStyle having setLocked false as the default style for all columns. This is possible by setting a org.openxmlformats.schemas.spreadsheetml.x2006.main.CTCol element having min col 1 and max col 16384 having set that style.
Then take out row 1 from using that style by setting CustomFormat true for that row. So it does not use the default style for all columns. Additional set a CellStyle having setLocked true as the default style for that row. This is possible by getting a org.openxmlformats.schemas.spreadsheetml.x2006.main.CTRow element from that row and set CustomFormat and S(style) there.
Result: All cells are unlocked except row 1.
Example:
import java.io.*;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.xssf.usermodel.*;
public class CreateExcelSheetProtectOnlyFirstRow {
public static void main(String[] args) throws Exception {
Workbook workbook = new XSSFWorkbook();
//create a CellStyle having setLocked false
CellStyle cellstyleUnprotect = workbook.createCellStyle();
cellstyleUnprotect.setLocked(false);
//create a CellStyle having setLocked true
CellStyle cellstyleProtect = workbook.createCellStyle();
cellstyleProtect.setLocked(true);
Sheet sheet = workbook.createSheet("Sheet1");
//set the CellStyle having setLocked false as the default style for all columns
org.openxmlformats.schemas.spreadsheetml.x2006.main.CTCol cTCol =
((XSSFSheet)sheet).getCTWorksheet().getColsArray(0).addNewCol();
cTCol.setMin(1);
cTCol.setMax(16384);
cTCol.setWidth(12.7109375);
cTCol.setStyle(cellstyleUnprotect.getIndex());
Row row = sheet.createRow(0);
//set CustomFormat true for that row
//so it does not using the default style for all columns
//and set the CellStyle having setLocked true as the default style for that row
org.openxmlformats.schemas.spreadsheetml.x2006.main.CTRow cTRow =
((XSSFRow)row).getCTRow();
cTRow.setCustomFormat(true);
cTRow.setS(cellstyleProtect.getIndex());
for (int c = 0; c < 3; c++) {
row.createCell(c).setCellValue("Header " + (c+1));
}
sheet.protectSheet("password"); // protect sheet
workbook.write(new FileOutputStream("CreateExcelSheetProtectOnlyFirstRow.xlsx"));
workbook.close();
}
}
I have to open an existing Excel and set some values or change the background/foreground color at that cells.
This excel is about the worked days in a company, so I have an Excel already styled.
I have to change the foreground at some cells because, as you can imagine, in some days we don't work.
So, for every day ( that corresponds to a cell ), if it is not "enabled" it has to become yellow.
My code is :
for(int i=0;i<listDays.size();i++) {
int indiceColonna = 6+i;
/* Setto la cella GIALLA relativa alla desc corta giorno */
if(!listDays.get(i).isEnabled()) {
CellStyle cellaGialla = foglio.getRow(5).getCell(indiceColonna).getCellStyle();
cellaGialla.setFillForegroundColor(IndexedColors.LIGHT_YELLOW.getIndex());
cellaGialla.setFillPattern(FillPatternType.SOLID_FOREGROUND);
foglio.getRow(5).getCell(indiceColonna).setCellStyle(cellaGialla);
/* Colonne gialle : da G8 a G18 - a scendere */
for (int y = 0; y < 11; y++) {
Cell cella = foglio.getRow(7 + y).getCell(6 + i);
CellStyle cella2Gialla = cella.getCellStyle();
cella2Gialla.setFillForegroundColor(IndexedColors.LIGHT_YELLOW.getIndex());
cella2Gialla.setFillPattern(FillPatternType.SOLID_FOREGROUND);
cella.setCellStyle(cella2Gialla);
}
}
}
I want to take the actual CellStyle of the cell and change only the foreground color.
This code works partially because is setting the foreground color at other columns too :
wrong columns
How can I avoid this error?
I'm using Apache POI 3.16, but I tried with some older versions.
Thank you!
I was also facing similar issue and found the solution to be creating a new style for the workbook as mentioned by Gagravarr. Just change your code as below.
CellStyle cella2Gialla = WorkbookObject.createCellStyle();
How to change only font color of one cell without altering the workbooks previous style properties. Please look at the attachment "workbook" for clear understanding. The column delta contribution font color should be changed but its background style properties should not be altered.
EDIT:
I have changed the code.
The columns rank and mean contribution in the template have a predefined design of some alternate colors which are set in the excel itself. The template is designed by my team and I am afraid I can't change it from Java.
My work is to populate the last column Delta Contribution whose background styles should be same as the total sheet provided the color change according to the conditions.
String deltaContribution = line.getDeltaContribution() != null
? Double.parseDouble(line.getDeltaContribution()) + "" : "";
if (!deltaContribution.equals("")) {
XSSFCell cell = (XSSFCell) row.getCell(8);
XSSFCellStyle style = cell.getCellStyle();
XSSFFont redFont = style.getFont();
XSSFFont blueFont = style.getFont();
XSSFFont greenFont = style.getFont();
if(Double.parseDouble(deltaContribution) >= 0.20) {
redFont.setColor(IndexedColors.RED.getIndex());
CellUtil.setFont(cell, workbook, redFont);
//log.info("The colour is " + colour.getARGBHex());
}
else if(Double.parseDouble(deltaContribution) <= -0.20) {
greenFont.setColor(IndexedColors.GREEN.getIndex());
CellUtil.setFont(cell, workbook, greenFont);
//log.info("The colour is " + colour.getARGBHex());
}
else {
blueFont.setColor(IndexedColors.BLUE.getIndex());
CellUtil.setFont(cell, workbook, blueFont);
//log.info("The colour is " + colour.getARGBHex());
}
row.getCell(8).setCellValue(line.getDeltaContribution() != null
? formatDecimalPlaces(line.getDeltaContribution()) : "");
}
I should not change the previous styles applied to the sheet, I should just edit one property of style. After changing the code, whole column is populated with green color.Last column
workbook:
There are two approaches.
First approach is using conditional formatting. This is my preferred approach.
Example:
import org.apache.poi.xssf.usermodel.*;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.ss.util.CellRangeAddress;
import java.io.FileOutputStream;
class ConditionalFormattingCellValues {
public static void main(String[] args) throws Exception {
Workbook wb = new XSSFWorkbook();
Sheet sheet = wb.createSheet("Sheet1");
SheetConditionalFormatting sheetCF = sheet.getSheetConditionalFormatting();
ConditionalFormattingRule cfRule2 = sheetCF.createConditionalFormattingRule(ComparisonOperator.GE, "0.20");
FontFormatting fontFormatting = cfRule2.createFontFormatting();
fontFormatting.setFontStyle(false, false);
fontFormatting.setFontColorIndex(IndexedColors.RED.index);
ConditionalFormattingRule cfRule1 = sheetCF.createConditionalFormattingRule(ComparisonOperator.LT, "0.20");
fontFormatting = cfRule1.createFontFormatting();
fontFormatting.setFontStyle(false, false);
fontFormatting.setFontColorIndex(IndexedColors.BLUE.index);
ConditionalFormattingRule [] cfRules = {cfRule1, cfRule2};
CellRangeAddress[] regions = {CellRangeAddress.valueOf("I2:I10")};
sheetCF.addConditionalFormatting(regions, cfRules);
for (int r = 1; r < 10; r++) {
Row row = sheet.createRow(r);
Cell cell = row.createCell(8);
cell.setCellValue(1d/Math.sqrt(r)-0.2);
}
FileOutputStream fileOut = new FileOutputStream("ConditionalFormattingCellValues.xlsx");
wb.write(fileOut);
wb.close();
}
}
Second approach is using CellUtil. This provides "Various utility functions that make working with a cells and rows easier. The various methods that deal with style's allow you to create your CellStyles as you need them. When you apply a style change to a cell, the code will attempt to see if a style already exists that meets your needs. If not, then it will create a new style. This is to prevent creating too many styles. there is an upper limit in Excel on the number of styles that can be supported."
Example:
import org.apache.poi.xssf.usermodel.*;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.ss.util.CellUtil;
import java.io.FileOutputStream;
class DirectlyFormattingCellValues {
public static void main(String[] args) throws Exception {
Workbook wb = new XSSFWorkbook();
Font redFont = wb.createFont();
redFont.setColor(IndexedColors.RED.getIndex());
Font blueFont = wb.createFont();
blueFont.setColor(IndexedColors.BLUE.getIndex());
Sheet sheet = wb.createSheet("Sheet1");
for (int r = 1; r < 10; r++) {
Row row = sheet.createRow(r);
Cell cell = row.createCell(8);
String deltaContribution = String.valueOf(1d/Math.sqrt(r)-0.2);
if(Double.parseDouble(deltaContribution)>=0.20) {
CellUtil.setFont(cell, redFont);
} else {
CellUtil.setFont(cell, blueFont);
}
cell.setCellValue(Double.valueOf(deltaContribution));
}
FileOutputStream fileOut = new FileOutputStream("DirectlyFormattingCellValues.xlsx");
wb.write(fileOut);
wb.close();
}
}
As said already, using conditional formatting should be preferred.
But according your screen-shot all your numbers seems to be text strings instead of really numeric values. This should be avoided since Excel cannot using such text strings in formula calculation. And without changing that, only second approach will be usable since conditional formatting also needs really numeric values for comparison.
I need to store numeric in number category (right click->Catergory=number). I have tried using the below code, but it saves in general format.
String valueAsString = "2345";
HSSFCell cellE1 = row1.createCell((short) 4);
cellE1.setCellValue(new BigDecimal(valueAsString).doubleValue());
You need to set a cell style to the cell, which formats it as you want. Something like
Worbook wb = new HSSFWorkbook();
DataFormat fmts = wb.getCreationHelper().createDataFormat();
// Cell Styles apply to the whole workbook, only create once
CellStyle numericStyle = wb.createCellStyle();
numericStyle.setDataFormat(fmts.getFormat("0")); // Format string
....
// Apply to the cells
Row r = sheet.createRow(0);
Cell c = r.createCell(0); // A1
c.setCellStyle(numericStyle);
c.setCellValue(Double.parseDouble("12345"));