private void addTableCell(
     Tr tableRow,
     BandElement be,
     P paragraph,
     int width,
     Map<String, Object> style,
     int horizontalMergedCells,
     String verticalMergedVal,
     boolean isImage) {
   Tc tableCell = factory.createTc();
   if (isImage) {
     addImageCellStyle(tableCell, be, paragraph, style);
   } else {
     addHyperlinkCellStyle(tableCell, be, paragraph, style);
   }
   setCellWidth(tableCell, width);
   setCellVMerge(tableCell, verticalMergedVal);
   setCellHMerge(tableCell, horizontalMergedCells);
   if (!isImage) {
     if ((be != null) && !be.isWrapText()) {
       setCellNoWrap(tableCell);
     }
   }
   tableRow.getContent().add(tableCell);
 }
  // all properties of same type like Color or Font must have different hashCodes!
  private int getStyleKey(Map<String, Object> style, BandElement bandElement) {
    final int prime = 31;
    int hashCode = getFontKey(style);
    if (style.containsKey(StyleFormatConstants.BACKGROUND_COLOR)) {
      Color val = (Color) style.get(StyleFormatConstants.BACKGROUND_COLOR);
      hashCode = prime * hashCode + val.hashCode() * 3;
    }
    if (style.containsKey(StyleFormatConstants.HORIZONTAL_ALIGN_KEY)) {
      String val = (String) style.get(StyleFormatConstants.HORIZONTAL_ALIGN_KEY);
      hashCode = prime * hashCode + +val.hashCode();
    }
    if (style.containsKey(StyleFormatConstants.VERTICAL_ALIGN_KEY)) {
      String val = (String) style.get(StyleFormatConstants.VERTICAL_ALIGN_KEY);
      hashCode = prime * hashCode + val.hashCode();
    }
    if (style.containsKey(StyleFormatConstants.BORDER_LEFT)) {
      Float val = (Float) style.get(StyleFormatConstants.BORDER_LEFT) * 23;
      hashCode = prime * hashCode + val.hashCode();
    }
    if (style.containsKey(StyleFormatConstants.BORDER_RIGHT)) {
      Float val = (Float) style.get(StyleFormatConstants.BORDER_RIGHT) * 29;
      hashCode = prime * hashCode + val.hashCode();
    }
    if (style.containsKey(StyleFormatConstants.BORDER_TOP)) {
      Float val = (Float) style.get(StyleFormatConstants.BORDER_TOP) * 31;
      hashCode = prime * hashCode + val.hashCode();
    }
    if (style.containsKey(StyleFormatConstants.BORDER_BOTTOM)) {
      Float val = (Float) style.get(StyleFormatConstants.BORDER_BOTTOM) * 37;
      hashCode = prime * hashCode + val.hashCode();
    }
    if (style.containsKey(StyleFormatConstants.BORDER_LEFT_COLOR)) {
      Color val = (Color) style.get(StyleFormatConstants.BORDER_LEFT_COLOR);
      hashCode = prime * hashCode + val.hashCode() * 5;
    }
    if (style.containsKey(StyleFormatConstants.BORDER_RIGHT_COLOR)) {
      Color val = (Color) style.get(StyleFormatConstants.BORDER_RIGHT_COLOR);
      hashCode = prime * hashCode + val.hashCode() * 7;
    }
    if (style.containsKey(StyleFormatConstants.BORDER_TOP_COLOR)) {
      Color val = (Color) style.get(StyleFormatConstants.BORDER_TOP_COLOR);
      hashCode = prime * hashCode + val.hashCode() * 11;
    }
    if (style.containsKey(StyleFormatConstants.BORDER_BOTTOM_COLOR)) {
      Color val = (Color) style.get(StyleFormatConstants.BORDER_BOTTOM_COLOR);
      hashCode = prime * hashCode + val.hashCode() * 13;
    }
    if (style.containsKey(StyleFormatConstants.PATTERN)) {
      String val = (String) style.get(StyleFormatConstants.PATTERN);
      hashCode = prime * hashCode + val.hashCode() * 17;
    }

    if (bandElement != null) {
      hashCode = prime * hashCode + (bandElement.isWrapText() ? 19 : 41);
    }
    return hashCode;
  }
  private void addHyperlinkCellStyle(
      Tc tableCell, BandElement be, P hyperlink, Map<String, Object> style) {
    setCellMargins(tableCell, style);
    setBackground(tableCell, style);
    setVerticalAlignment(tableCell, style);
    setHorizontalAlignment(hyperlink, style);
    setCellBorders(tableCell, style);

    R run = (R) ((org.docx4j.wml.P.Hyperlink) hyperlink.getContent().get(0)).getContent().get(0);
    RPr runProperties = run.getRPr();
    setFont(tableCell, style, runProperties);
    if (be != null) {
      setTextDirection(tableCell, be.getTextRotation());
    }

    tableCell.getContent().add(hyperlink);
  }
 private void addTableCell(
     Tr tableRow,
     BandElement be,
     String content,
     int width,
     Map<String, Object> style,
     int horizontalMergedCells,
     String verticalMergedVal) {
   Tc tableCell = factory.createTc();
   addCellStyle(tableCell, be, content, style);
   setCellWidth(tableCell, width);
   setCellVMerge(tableCell, verticalMergedVal);
   setCellHMerge(tableCell, horizontalMergedCells);
   if ((be != null) && !be.isWrapText()) {
     setCellNoWrap(tableCell);
   }
   tableRow.getContent().add(tableCell);
 }
  private void addCellStyle(
      Tc tableCell, BandElement be, String content, P paragraph, Map<String, Object> style) {
    if (style != null) {

      // inner html text
      if (content.startsWith("<html>")) {
        try {
          wordMLPackage
              .getMainDocumentPart()
              .addAltChunk(AltChunkType.Html, content.getBytes(), tableCell);
          tableCell.getContent().add(paragraph);
        } catch (Docx4JException e) {
          e.printStackTrace();
        }
        return;
      }

      Text text = factory.createText();
      text.setValue(content);

      R run = factory.createR();
      run.getContent().add(text);

      paragraph.getContent().add(run);

      setHorizontalAlignment(paragraph, style);

      RPr runProperties = factory.createRPr();

      setFont(tableCell, style, runProperties);
      setCellMargins(tableCell, style);
      setBackground(tableCell, style);
      setVerticalAlignment(tableCell, style);
      setCellBorders(tableCell, style);
      if (be != null) {
        setTextDirection(tableCell, be.getTextRotation());
      }

      run.setRPr(runProperties);

      tableCell.getContent().add(paragraph);
    }
  }
  private void renderCell(
      BandElement bandElement,
      String bandName,
      Object value,
      int gridRow,
      int sheetRow,
      int sheetColumn,
      int rowSpan,
      int colSpan,
      boolean image) {

    if (bandElement instanceof ReportBandElement) {
      colSpan = 1;
    }
    XSSFCellStyle cellStyle =
        buildBandElementStyle(bandElement, value, gridRow, sheetColumn, colSpan);

    // if we have a subreport on the current grid row we have to take care of the sheetColumn
    if (ReportLayout.HEADER_BAND_NAME.equals(bandName)
        && (gridRow == prevSubreportFirstRow)
        && (prevSubreportLastColumn != -1)) {
      sheetColumn = prevSubreportLastColumn - prevSubreportFirstColumn - 1 + sheetColumn;
    }
    XSSFCell c = xlsRow.createCell(sheetColumn);

    if (image) {
      if ((value == null) || "".equals(value)) {
        c.setCellType(XSSFCell.CELL_TYPE_STRING);
        c.setCellValue(wb.getCreationHelper().createRichTextString(IMAGE_NOT_FOUND));
      } else {
        try {
          ImageBandElement ibe = (ImageBandElement) bandElement;
          byte[] imageBytes = getImage((String) value, ibe.getWidth(), ibe.getHeight());
          XSSFClientAnchor anchor =
              new XSSFClientAnchor(
                  0,
                  0,
                  0,
                  0,
                  (short) sheetColumn,
                  sheetRow,
                  (short) (sheetColumn + colSpan),
                  (sheetRow + rowSpan));
          int index = wb.addPicture(imageBytes, XSSFWorkbook.PICTURE_TYPE_JPEG);

          // image is created over the cells, so if it's height is bigger we set the row height
          short height = xlsRow.getHeight();
          int realImageHeight = getRealImageSize((String) value)[1];
          if (ibe.isScaled()) {
            realImageHeight = ibe.getHeight();
          }
          short imageHeight = (short) (realImageHeight * POINTS_FOR_PIXEL / 2.5);
          boolean doResize = false;
          if (imageHeight > height) {
            xlsRow.setHeight(imageHeight);
          } else {
            doResize = true;
          }

          Picture picture = patriarch.createPicture(anchor, index);
          if (doResize) {
            picture.resize();
          }
          anchor.setAnchorType(2);
        } catch (Exception ex) {
          c.setCellType(XSSFCell.CELL_TYPE_STRING);
          c.setCellValue(wb.getCreationHelper().createRichTextString(IMAGE_NOT_LOADED));
        }
      }

      if (cellStyle != null) {
        c.setCellStyle(cellStyle);
      }

    } else {
      if (bandElement instanceof HyperlinkBandElement) {
        Hyperlink hyp = ((HyperlinkBandElement) bandElement).getHyperlink();
        XSSFHyperlink link = wb.getCreationHelper().createHyperlink(XSSFHyperlink.LINK_URL);
        link.setAddress(hyp.getUrl());
        c.setHyperlink(link);
        c.setCellValue(wb.getCreationHelper().createRichTextString(hyp.getText()));
        c.setCellType(XSSFCell.CELL_TYPE_STRING);
      } else if (bandElement instanceof ReportBandElement) {
        Report report = ((ReportBandElement) bandElement).getReport();
        ExporterBean eb = null;
        try {
          eb = getSubreportExporterBean(report, true);
          XlsxExporter subExporter = new XlsxExporter(eb, cellStyle);
          subExporter.export();
          XSSFSheet subreportSheet = subExporter.getSubreportSheet();

          if (ReportLayout.HEADER_BAND_NAME.equals(bandName)
              && (gridRow == prevSubreportFirstRow)) {
            // other subreports on the same header line after the first
            sheetColumn = prevSubreportLastColumn;
            sheetRow -= addedPageRows;
            pageRow -= addedPageRows;
            addedPageRows = 0;
          } else {
            addedPageRows = subreportSheet.getLastRowNum();
            pageRow += addedPageRows;
            // if subreport is not on the first column we merge all cells in the columns before,
            // between the rows subreport occupies
            if (sheetColumn > 0) {
              for (int i = 0; i <= sheetColumn - 1; i++) {
                CellRangeAddress cra = new CellRangeAddress(sheetRow, pageRow, i, i);
                regions.add(new XlsxRegion(cra, null));
              }
            }
          }
          int cols = XlsxUtil.copyToSheet(xlsSheet, sheetRow, sheetColumn, subreportSheet);
          addRegions(xlsSheet, subExporter.getSubreportRegions(), wb);
          if (ReportLayout.HEADER_BAND_NAME.equals(bandName)) {
            prevSubreportFirstRow = gridRow;
            prevSubreportFirstColumn = sheetColumn;
            prevSubreportLastColumn = sheetColumn + cols;
          }
        } catch (Exception e) {
          e.printStackTrace();
        } finally {
          if ((eb != null) && (eb.getResult() != null)) {
            eb.getResult().close();
          }
        }
      } else if (bandElement instanceof ImageColumnBandElement) {
        try {
          ImageColumnBandElement icbe = (ImageColumnBandElement) bandElement;
          String v = StringUtil.getValueAsString(value, null);
          if (StringUtil.BLOB.equals(v)) {
            c.setCellType(XSSFCell.CELL_TYPE_STRING);
            c.setCellValue(wb.getCreationHelper().createRichTextString(StringUtil.BLOB));
          } else {
            byte[] imageD = StringUtil.decodeImage(v);
            byte[] imageBytes = getImage(imageD, icbe.getWidth(), icbe.getHeight());
            XSSFClientAnchor anchor =
                new XSSFClientAnchor(
                    0,
                    0,
                    0,
                    0,
                    (short) sheetColumn,
                    sheetRow,
                    (short) (sheetColumn + colSpan),
                    (sheetRow + rowSpan));
            int index = wb.addPicture(imageBytes, XSSFWorkbook.PICTURE_TYPE_JPEG);

            // image is created over the cells, so if it's height is bigger we set the row height
            short height = xlsRow.getHeight();
            int realImageHeight = getRealImageSize(imageBytes)[1];
            if (icbe.isScaled()) {
              realImageHeight = icbe.getHeight();
            }
            short imageHeight = (short) (realImageHeight * POINTS_FOR_PIXEL / 2.5);
            if (imageHeight > height) {
              xlsRow.setHeight(imageHeight);
            }

            Picture picture = patriarch.createPicture(anchor, index);
            picture.resize();
            anchor.setAnchorType(2);
          }
        } catch (Exception e) {
          e.printStackTrace();
          c.setCellType(XSSFCell.CELL_TYPE_STRING);
          c.setCellValue(wb.getCreationHelper().createRichTextString(IMAGE_NOT_LOADED));
        }

      } else {

        if (value == null) {
          c.setCellType(XSSFCell.CELL_TYPE_STRING);
          c.setCellValue(wb.getCreationHelper().createRichTextString(""));
        } else if (value instanceof Number) {
          c.setCellType(XSSFCell.CELL_TYPE_NUMERIC);
          c.setCellValue(((Number) value).doubleValue());
        } else {
          String pattern = null;
          if (bandElement instanceof FieldBandElement) {
            FieldBandElement fbe = (FieldBandElement) bandElement;
            pattern = fbe.getPattern();
          }
          if ((value instanceof java.sql.Date) || (value instanceof java.sql.Timestamp)) {
            Date date;
            if (value instanceof java.sql.Date) {
              date = new Date(((java.sql.Date) value).getTime());
            } else {
              date = (java.sql.Timestamp) value;
            }
            if (cellStyle != null) {
              if (pattern == null) {
                // use default pattern if none selected
                Locale locale = Locale.getDefault();
                pattern =
                    ((SimpleDateFormat) DateFormat.getDateInstance(SimpleDateFormat.MEDIUM, locale))
                        .toPattern();
              } else {
                pattern = StringUtil.getI18nString(pattern, getReportLanguage());
              }
              cellStyle.setDataFormat(wb.createDataFormat().getFormat(pattern));
            }
            c.setCellValue(date);
          } else {
            c.setCellType(XSSFCell.CELL_TYPE_STRING);
            String text = StringUtil.getValueAsString(value, pattern);
            if ((bandElement != null) && bandElement.isWrapText()) {
              // try to interpret new line characters
              // \\n is used here to be possible to add in designer grid cell with \n
              if (text.contains("\\n")
                  || text.contains("\n")
                  || text.contains("\r")
                  || text.contains("\r\n")) {
                String crLf = Character.toString((char) 13) + Character.toString((char) 10);
                int lines = countLines(text);
                if (text.contains("\r\n")) {
                  text = text.replaceAll("\r\n", crLf);
                } else {
                  text = text.replaceAll("(\n)|(\r)|(\\\\n)", crLf);
                }
                c.setCellValue(text);
                cellStyle.setWrapText(true);
                xlsRow.setHeightInPoints(lines * (cellStyle.getFont().getFontHeightInPoints() + 3));
              } else {
                c.setCellValue(wb.getCreationHelper().createRichTextString(text));
              }
            } else {
              c.setCellValue(wb.getCreationHelper().createRichTextString(text));
            }
          }
        }
      }

      if (cellStyle != null) {
        if (bandElement != null) {
          cellStyle.setRotation(bandElement.getTextRotation());
        }
        if (!(bandElement instanceof ReportBandElement)) {
          c.setCellStyle(cellStyle);
        }
      }

      if ((rowSpan > 1) || (colSpan > 1)) {
        CellRangeAddress cra =
            new CellRangeAddress(
                sheetRow, sheetRow + rowSpan - 1, sheetColumn, sheetColumn + colSpan - 1);
        Border beBorder = bandElement.getBorder();
        if (hasRowRenderConditions(bandElement, gridRow, value)) {
          // for row render conditions we must keep the row border
          beBorder = border;
        }
        regions.add(new XlsxRegion(cra, beBorder));
      }
    }
  }
  private XSSFCellStyle buildBandElementStyle(
      BandElement bandElement, Object value, int gridRow, int gridColumn, int colSpan) {
    Map<String, Object> style = buildCellStyleMap(bandElement, value, gridRow, gridColumn, colSpan);
    XSSFCellStyle cellStyle = null;
    XSSFFont cellFont = null;
    int fontKey = -1;
    int styleKey = -1;
    // we have to create new fonts and styles if some formatting conditions are met
    // also for subreports we may have a subreportCellStyle passed by ReportBandElement
    boolean cacheFont = false;
    boolean cacheAllFont = false;
    boolean cacheStyle = false;
    boolean cacheAllStyle = false;
    if ((modifiedStyle[gridRow][gridColumn]) || bean.isSubreport()) {
      fontKey = getFontKey(style);
      if (fontKey != -1) {
        cellFont = condFonts.get(fontKey);
      }
      if (cellFont == null) {
        cellFont = wb.createFont();
        cacheFont = true;
      }
      styleKey = getStyleKey(style, bandElement);
      if (styleKey != -1) {
        cellStyle = condStyles.get(styleKey);
      }
      if (cellStyle == null) {
        cellStyle = wb.createCellStyle();
        cacheStyle = true;
      }
      modifiedStyle[gridRow][gridColumn] = false;
    } else {
      fontKey = getFontKey(style);
      if (fontKey != -1) {
        cellFont = fonts.get(fontKey);
      }
      if ((cellFont == null) && (bandElement != null)) {
        cellFont = wb.createFont();
        cacheAllFont = true;
      }
      styleKey = getStyleKey(style, bandElement);
      if (styleKey != -1) {
        cellStyle = styles.get(styleKey);
      }
      if (cellStyle == null) {
        cellStyle = wb.createCellStyle();
        cacheAllStyle = true;
      }
    }

    // HSSFPalette cellPal = wb.getCustomPalette();
    if (style.containsKey(StyleFormatConstants.FONT_FAMILY_KEY)) {
      String val = (String) style.get(StyleFormatConstants.FONT_FAMILY_KEY);
      cellFont.setFontName(val);
    }
    if (style.containsKey(StyleFormatConstants.FONT_SIZE)) {
      Float val = (Float) style.get(StyleFormatConstants.FONT_SIZE);
      cellFont.setFontHeightInPoints(val.shortValue());
    }
    if (style.containsKey(StyleFormatConstants.FONT_COLOR)) {
      Color val = (Color) style.get(StyleFormatConstants.FONT_COLOR);
      cellFont.setColor(ExcelColorSupport.getNearestColor(val));
    }
    if (style.containsKey(StyleFormatConstants.FONT_STYLE_KEY)) {
      if (StyleFormatConstants.FONT_STYLE_NORMAL.equals(
          style.get(StyleFormatConstants.FONT_STYLE_KEY))) {
        cellFont.setBoldweight(XSSFFont.BOLDWEIGHT_NORMAL);
      }
      if (StyleFormatConstants.FONT_STYLE_BOLD.equals(
          style.get(StyleFormatConstants.FONT_STYLE_KEY))) {
        cellFont.setBoldweight(XSSFFont.BOLDWEIGHT_BOLD);
      }
      if (StyleFormatConstants.FONT_STYLE_ITALIC.equals(
          style.get(StyleFormatConstants.FONT_STYLE_KEY))) {
        cellFont.setItalic(true);
      }
      if (StyleFormatConstants.FONT_STYLE_BOLDITALIC.equals(
          style.get(StyleFormatConstants.FONT_STYLE_KEY))) {
        cellFont.setBoldweight(XSSFFont.BOLDWEIGHT_BOLD);
        cellFont.setItalic(true);
      }
    }

    if (cacheFont && (fontKey != -1)) {
      condFonts.put(fontKey, cellFont);
    }
    if (cacheAllFont && (fontKey != -1)) {
      fonts.put(fontKey, cellFont);
    }
    if (style.containsKey(StyleFormatConstants.BACKGROUND_COLOR)) {
      Color val = (Color) style.get(StyleFormatConstants.BACKGROUND_COLOR);
      cellStyle.setFillPattern(XSSFCellStyle.SOLID_FOREGROUND);
      cellStyle.setFillForegroundColor(ExcelColorSupport.getNearestColor(val));
    }
    if (style.containsKey(StyleFormatConstants.HORIZONTAL_ALIGN_KEY)) {
      if (StyleFormatConstants.HORIZONTAL_ALIGN_LEFT.equals(
          style.get(StyleFormatConstants.HORIZONTAL_ALIGN_KEY))) {
        cellStyle.setAlignment((short) 1);
      }
      if (StyleFormatConstants.HORIZONTAL_ALIGN_RIGHT.equals(
          style.get(StyleFormatConstants.HORIZONTAL_ALIGN_KEY))) {
        cellStyle.setAlignment((short) 3);
      }
      if (StyleFormatConstants.HORIZONTAL_ALIGN_CENTER.equals(
          style.get(StyleFormatConstants.HORIZONTAL_ALIGN_KEY))) {
        cellStyle.setAlignment((short) 2);
      }
    }

    if (style.containsKey(StyleFormatConstants.VERTICAL_ALIGN_KEY)) {
      if (StyleFormatConstants.VERTICAL_ALIGN_TOP.equals(
          style.get(StyleFormatConstants.VERTICAL_ALIGN_KEY))) {
        cellStyle.setVerticalAlignment(XSSFCellStyle.VERTICAL_TOP);
      }
      if (StyleFormatConstants.VERTICAL_ALIGN_MIDDLE.equals(
          style.get(StyleFormatConstants.VERTICAL_ALIGN_KEY))) {
        cellStyle.setVerticalAlignment(XSSFCellStyle.VERTICAL_CENTER);
      }
      if (StyleFormatConstants.VERTICAL_ALIGN_BOTTOM.equals(
          style.get(StyleFormatConstants.VERTICAL_ALIGN_KEY))) {
        cellStyle.setVerticalAlignment(XSSFCellStyle.VERTICAL_BOTTOM);
      }
    } else {
      cellStyle.setVerticalAlignment(XSSFCellStyle.VERTICAL_CENTER);
    }

    short left = 0, right = 0, top = 0, bottom = 0;
    Color leftColor = Color.BLACK,
        rightColor = Color.BLACK,
        topColor = Color.BLACK,
        bottomColor = Color.BLACK;
    if (style.containsKey(StyleFormatConstants.BORDER_LEFT)) {
      Float val = (Float) style.get(StyleFormatConstants.BORDER_LEFT);
      //
      left = val.shortValue();
      if (left == BORDER_THIN_VALUE) {
        cellStyle.setBorderLeft(XSSFCellStyle.BORDER_THIN);
      }
      if (left == BORDER_MEDIUM_VALUE) {
        cellStyle.setBorderLeft(XSSFCellStyle.BORDER_MEDIUM);
      }
      if (left == BORDER_THICK_VALUE) {
        cellStyle.setBorderLeft(XSSFCellStyle.BORDER_THICK);
      }

      Color color = (Color) style.get(StyleFormatConstants.BORDER_LEFT_COLOR);
      leftColor = color;
      cellStyle.setLeftBorderColor(ExcelColorSupport.getNearestColor(color));
    }
    if (style.containsKey(StyleFormatConstants.BORDER_RIGHT)) {
      Float val = (Float) style.get(StyleFormatConstants.BORDER_RIGHT);
      //
      right = val.shortValue();
      if (right == BORDER_THIN_VALUE) {
        cellStyle.setBorderRight(XSSFCellStyle.BORDER_THIN);
      }
      if (right == BORDER_MEDIUM_VALUE) {
        cellStyle.setBorderRight(XSSFCellStyle.BORDER_MEDIUM);
      }
      if (right == BORDER_THICK_VALUE) {
        cellStyle.setBorderRight(XSSFCellStyle.BORDER_THICK);
      }
      Color color = (Color) style.get(StyleFormatConstants.BORDER_RIGHT_COLOR);
      rightColor = color;
      cellStyle.setRightBorderColor(ExcelColorSupport.getNearestColor(color));
    }
    if (style.containsKey(StyleFormatConstants.BORDER_TOP)) {
      Float val = (Float) style.get(StyleFormatConstants.BORDER_TOP);
      //
      top = val.shortValue();
      if (top == BORDER_THIN_VALUE) {
        cellStyle.setBorderTop(XSSFCellStyle.BORDER_THIN);
      }
      if (top == BORDER_MEDIUM_VALUE) {
        cellStyle.setBorderTop(XSSFCellStyle.BORDER_MEDIUM);
      }
      if (top == BORDER_THICK_VALUE) {
        cellStyle.setBorderTop(XSSFCellStyle.BORDER_THICK);
      }
      Color color = (Color) style.get(StyleFormatConstants.BORDER_TOP_COLOR);
      topColor = color;
      cellStyle.setTopBorderColor(ExcelColorSupport.getNearestColor(color));
    }
    if (style.containsKey(StyleFormatConstants.BORDER_BOTTOM)) {
      Float val = (Float) style.get(StyleFormatConstants.BORDER_BOTTOM);
      //
      bottom = val.shortValue();
      if (bottom == BORDER_THIN_VALUE) {
        cellStyle.setBorderBottom(XSSFCellStyle.BORDER_THIN);
      }
      if (bottom == BORDER_MEDIUM_VALUE) {
        cellStyle.setBorderBottom(XSSFCellStyle.BORDER_MEDIUM);
      }
      if (bottom == BORDER_THICK_VALUE) {
        cellStyle.setBorderBottom(XSSFCellStyle.BORDER_THICK);
      }
      Color color = (Color) style.get(StyleFormatConstants.BORDER_BOTTOM_COLOR);
      bottomColor = color;
      cellStyle.setBottomBorderColor(ExcelColorSupport.getNearestColor(color));
    }
    border = new Border(left, right, top, bottom);
    border.setLeftColor(leftColor);
    border.setRightColor(rightColor);
    border.setTopColor(topColor);
    border.setBottomColor(bottomColor);

    if (cellFont != null) {
      cellStyle.setFont(cellFont);
    }

    if (style.containsKey(StyleFormatConstants.PATTERN)) {
      String pattern = (String) style.get(StyleFormatConstants.PATTERN);
      XSSFDataFormat format = wb.createDataFormat();
      cellStyle.setDataFormat(format.getFormat(pattern));
    } else {
      cellStyle.setDataFormat((short) 0);
    }

    if (bandElement != null) {
      cellStyle.setWrapText(bandElement.isWrapText());
    }

    cellStyle =
        updateSubreportBandElementStyle(
            cellStyle, bandElement, value, gridRow, gridColumn, colSpan);

    if (cacheStyle && (styleKey != -1)) {
      condStyles.put(styleKey, cellStyle);
    }
    if (cacheAllStyle && (styleKey != -1)) {
      styles.put(styleKey, cellStyle);
    }

    return cellStyle;
  }