Merge pull request #203 from apptaro/master

Conditional Formatting Support (expression only)

Author: Olivier Chédru

README.md

@@ -76,6 +76,10 @@ Apply formatting to a cell containing a timestamp:
 ws.value(0, 0, LocalDateTime.now());
 ws.style(0, 0).format("yyyy-MM-dd H:mm:ss").set();
 ```
+Apply conditional formatting of expression type to a cell:
+```java
+ws.style(0, 0).fillColor("FF8800").set(new ConditionalFormattingExpressionRule("LENB(A1)>1", true));
+```
 
 ### Cell ranges
 

fastexcel-writer/src/main/java/org/dhatim/fastexcel/ConditionalFormatting.java

@@ -0,0 +1,40 @@
+package org.dhatim.fastexcel;
+
+import java.io.IOException;
+
+public class ConditionalFormatting {
+    private final Range range;
+    private final ConditionalFormattingRule conditionalFormattingRule;
+
+    /**
+     * Constructor
+     *
+     * @param range                     The Range this validation is applied to
+     * @param conditionalFormattingRule The Range of the list this validation references
+     */
+    ConditionalFormatting(Range range, ConditionalFormattingRule conditionalFormattingRule) {
+        this.range = range;
+        this.conditionalFormattingRule = conditionalFormattingRule;
+    }
+    
+    /**
+     * Get the conditional formatting rule of this conditional formatting.
+     *
+     * @return ConditionalFormattingRule conditional formatting rule.
+     */
+    ConditionalFormattingRule getConditionalFormattingRule() {
+        return this.conditionalFormattingRule;
+    }
+    
+    /**
+     * Write this conditionalFormatting as an XML element.
+     *
+     * @param w Output writer.
+     * @throws IOException If an I/O error occurs.
+     */
+    void write(Writer w) throws IOException {
+        w.append("<conditionalFormatting sqref=\"").append(range.toString()).append("\">");
+        conditionalFormattingRule.write(w);
+        w.append("</conditionalFormatting>");
+    }
+}

fastexcel-writer/src/main/java/org/dhatim/fastexcel/ConditionalFormattingExpressionRule.java

@@ -0,0 +1,36 @@
+package org.dhatim.fastexcel;
+
+import java.io.IOException;
+
+/**
+ * A ConditionalFormattingExpressionRule defines a conditional formatting rule for a worksheet of type = "expression"
+ */
+public class ConditionalFormattingExpressionRule extends ConditionalFormattingRule {
+    protected final static String TYPE = "expression";
+    protected final String expression;
+
+    /**
+     * Constructor
+     *
+     * @param expression When the expression evaluates to true, the specified style is applied
+     * @param stopIfTrue True indicates no rules with lower priority shall be applied over this rule, when this rule evaluates to true
+     */
+    public ConditionalFormattingExpressionRule(String expression, boolean stopIfTrue) {
+        super(TYPE, stopIfTrue);
+        this.expression = expression;
+    }
+
+    /**
+     * Write this conditionalFormatting as an XML element.
+     *
+     * @param w Output writer.
+     * @throws IOException If an I/O error occurs.
+     */
+    @Override
+    public void write(Writer w) throws IOException {
+        w
+            .append("<cfRule type=\"").append(TYPE).append("\" priority=\"").append(priority).append("\" stopIfTrue=\"").append(stopIfTrue ? "1" : "0").append("\" dxfId=\"").append(dxfId).append("\">")
+            .append("<formula>").append(expression).append("</formula>")
+            .append("</cfRule>");
+    }
+}

fastexcel-writer/src/main/java/org/dhatim/fastexcel/ConditionalFormattingRule.java

@@ -0,0 +1,50 @@
+package org.dhatim.fastexcel;
+
+import java.io.IOException;
+
+/**
+ * A ConditionalFormattingRule defines a base class of conditional formatting rule for a worksheet
+ */
+public abstract class ConditionalFormattingRule {
+    protected final String type;
+    protected int priority;
+    protected final boolean stopIfTrue;
+    protected int dxfId;
+    
+    /**
+     * Constructor
+     *
+     * @param type       Type of conditional formatting rule
+     * @param stopIfTrue True indicates no rules with lower priority shall be applied over this rule, when this rule evaluates to true
+     */
+    ConditionalFormattingRule(String type, boolean stopIfTrue) {
+        this.type = type;
+        this.stopIfTrue = stopIfTrue;
+    }
+
+    /**
+     * Set the priority
+     *
+     * @param priority The user interface display priority
+     */
+    void setPriority(int priority) {
+        this.priority = priority;
+    }
+
+    /**
+     * Set the dxfId
+     *
+     * @param dxfId The id of the style to apply when the conditional formatting rule criteria is met
+     */
+    void setDxfId(int dxfId) {
+        this.dxfId = dxfId;
+    }
+
+    /**
+     * Write this conditionalFormatting as an XML element.
+     *
+     * @param w Output writer.
+     * @throws IOException If an I/O error occurs.
+     */
+    abstract void write(Writer w) throws IOException;
+}

fastexcel-writer/src/main/java/org/dhatim/fastexcel/DifferentialFormat.java

@@ -0,0 +1,92 @@
+package org.dhatim.fastexcel;
+
+import java.io.IOException;
+import java.util.Objects;
+
+public class DifferentialFormat {
+    private final String valueFormatting;
+    private final Font font;
+    private final Fill fill;
+    private final Border border;
+    private final Alignment alignment;
+    private final Protection protection;
+    private int numFmtId;
+    
+    /**
+     * Constructor.
+     *
+     * @param numFmtId Id of the value formatting to use
+     * @param font Font to use
+     * @param fill Fill to use
+     * @param border Border to use
+     * @param alignment Alignment to use
+     * @param protection Proction to use
+     */
+    DifferentialFormat(String valueFormatting, Font font, Fill fill, Border border, Alignment alignment, Protection protection) {
+        this.valueFormatting = valueFormatting;
+        this.font = font;
+        this.fill = fill;
+        this.border = border;
+        this.alignment = alignment;
+        this.protection = protection;
+    }
+    
+    public String getValueFormatting() {
+        return valueFormatting;
+    }
+    
+    public void setNumFmtId(int numFmtId) {
+        this.numFmtId = numFmtId;
+    }
+    
+    @Override
+    public int hashCode() {
+        return Objects.hash(numFmtId, font, fill, border, alignment, protection);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        boolean result;
+        if (obj != null && obj.getClass() == this.getClass()) {
+            DifferentialFormat other = (DifferentialFormat) obj;
+            result = Objects.equals(valueFormatting, other.valueFormatting)
+                    && Objects.equals(font, other.font)
+                    && Objects.equals(fill, other.fill)
+                    && Objects.equals(border, other.border)
+                    && Objects.equals(alignment, other.alignment)
+                    && Objects.equals(protection, other.protection);
+        } else {
+            result = false;
+        }
+        return result;
+    }
+
+    /**
+     * Write this style as an XML element.
+     *
+     * @param w Output writer.
+     * @throws IOException If an I/O error occurs.
+     */
+    void write(Writer w) throws IOException {
+        w.append("<dxf>");
+        if (valueFormatting != null) {
+            w.append("<numFmt numFmtId=\"").append(numFmtId).append("\" formatCode=\"").append(valueFormatting).append("\"/>");
+        }
+        if (font != null) {
+            font.write(w);
+        }
+        if (fill != null) {
+            fill.write(w);
+        }
+        if (border != null) {
+            border.write(w);
+        }
+        if (alignment != null) {
+            alignment.write(w);
+        }
+        if (protection != null) {
+            protection.write(w);
+        }
+        w.append("</dxf>");
+    }
+}

fastexcel-writer/src/main/java/org/dhatim/fastexcel/StyleCache.java

@@ -36,7 +36,7 @@ final class StyleCache {
     private final ConcurrentMap<Fill, Integer> fills = new ConcurrentHashMap<>();
     private final ConcurrentMap<Border, Integer> borders = new ConcurrentHashMap<>();
     private final ConcurrentMap<Style, Integer> styles = new ConcurrentHashMap<>();
-    private final ConcurrentMap<Fill, Integer> dxfs = new ConcurrentHashMap<>();
+    private final ConcurrentMap<DifferentialFormat, Integer> dxfs = new ConcurrentHashMap<>();
 
     /**
      * Default constructor. Pre-cache Excel-reserved stuff.
@@ -121,7 +121,7 @@ int cacheBorder(Border b) {
      * @param f Fill pattern.
      * @return Index of the cached fill pattern.
      */
-    int cacheDxf(Fill f) {
+    int cacheDxf(DifferentialFormat f) {
         return cacheStuff(dxfs, f);
     }
 
@@ -166,9 +166,7 @@ void write(Writer w) throws IOException {
         w.append("<cellStyleXfs count=\"1\"><xf numFmtId=\"0\" fontId=\"0\" fillId=\"0\" borderId=\"0\"/></cellStyleXfs>");
         writeCache(w, styles, "cellXfs", e -> e.getKey().write(w));
         writeCache(w, dxfs, "dxfs", e -> {
-            w.append("<dxf>");
             e.getKey().write(w);
-            w.append("</dxf>");
         });
         w.append("</styleSheet>");
     }

fastexcel-writer/src/main/java/org/dhatim/fastexcel/StyleSetter.java

@@ -66,7 +66,7 @@ public class StyleSetter {
      * Italic flag.
      */
     private boolean italic;
-	/**
+    /**
      * Underlined flag.
      */
     private boolean underlined;
@@ -224,8 +224,8 @@ public StyleSetter italic() {
         this.italic = true;
         return this;
     }
-	
-	/**
+    
+    /**
      * Use underlined text.
      *
      * @return This style setter.
@@ -443,4 +443,32 @@ public void set() {
             range.shadeRows(Fill.fromColor(shadingFillColor, false), eachNRows);
         }
     }
+    
+    /**
+     * Apply style elements conditionally
+     * @param conditionalFormattingRule Conditional formatting rule to apply
+     */
+    public void set(ConditionalFormattingRule conditionalFormattingRule) {
+        Alignment alignment = null;
+        if (horizontalAlignment != null || verticalAlignment != null || wrapText) {
+            alignment = new Alignment(horizontalAlignment, verticalAlignment, wrapText);
+        }
+        Font font = null;
+        if (bold || italic || underlined || fontColor != null || fontName != null || fontSize != null) {
+            font = Font.build(bold, italic, underlined, fontName, fontSize, fontColor);
+        }
+        Fill fill = null;
+        if (fillColor != null) {
+            fill = Fill.fromColor(fillColor, false);
+        }
+        Protection protection = null;
+        if (protectionOptions != null) {
+            protection = new Protection(protectionOptions);
+        }
+        
+        int dxfId = range.getWorksheet().getWorkbook().cacheDifferentialFormat(new DifferentialFormat(valueFormatting, font, fill, border, alignment, protection));
+        conditionalFormattingRule.setDxfId(dxfId);
+        ConditionalFormatting conditionalFormatting = new ConditionalFormatting(range, conditionalFormattingRule);
+        range.getWorksheet().addConditionalFormatting(conditionalFormatting);
+    }
 }

fastexcel-writer/src/main/java/org/dhatim/fastexcel/Workbook.java

@@ -324,13 +324,15 @@ int mergeAndCacheStyle(int currentStyle, String numberingFormat, Font font, Fill
     }
 
     /**
-     * Cache shading color for alternate rows.
+     * Cache differential format.
      *
-     * @param fill Fill pattern attributes.
-     * @return Cached fill pattern index.
+     * @param differentialFormat DifferentialFormat object.
+     * @return Cached differential format index.
      */
-    int cacheShadingFillColor(Fill fill) {
-        return styleCache.cacheDxf(fill);
+    int cacheDifferentialFormat(DifferentialFormat differentialFormat) {
+        int numFmtId = styleCache.cacheValueFormatting(differentialFormat.getValueFormatting());
+        differentialFormat.setNumFmtId(numFmtId);
+        return styleCache.cacheDxf(differentialFormat);
     }
 
     /**