From cb432e9cff0112894d2138a2335791f89251c266 Mon Sep 17 00:00:00 2001 From: Luca Martini Date: Fri, 28 Oct 2016 13:57:08 +0200 Subject: [PATCH 1/3] added idea .gitignore --- .gitignore | 47 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+) create mode 100755 .gitignore diff --git a/.gitignore b/.gitignore new file mode 100755 index 0000000000..207cbc601e --- /dev/null +++ b/.gitignore @@ -0,0 +1,47 @@ +# Created by .ignore support plugin (hsz.mobi) +### JetBrains template +# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and Webstorm +# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839 + +# User-specific stuff: +.idea/workspace.xml +.idea/tasks.xml +.idea/dictionaries +.idea/vcs.xml +.idea/jsLibraryMappings.xml + +# Sensitive or high-churn files: +.idea/dataSources.ids +.idea/dataSources.xml +.idea/dataSources.local.xml +.idea/sqlDataSources.xml +.idea/dynamic.xml +.idea/uiDesigner.xml + +# Gradle: +.idea/gradle.xml +.idea/libraries + +# Mongo Explorer plugin: +.idea/mongoSettings.xml + +## File-based project format: +*.iws + +## Plugin-specific files: + +# IntelliJ +/out/ + +# mpeltonen/sbt-idea plugin +.idea_modules/ + +# JIRA plugin +atlassian-ide-plugin.xml + +# Crashlytics plugin (for Android Studio and IntelliJ) +com_crashlytics_export_strings.xml +crashlytics.properties +crashlytics-build.properties +fabric.properties + From d96581a3cb2ac5cd3bb54f228cc59ed437680b39 Mon Sep 17 00:00:00 2001 From: Luca Martini Date: Fri, 28 Oct 2016 15:30:45 +0200 Subject: [PATCH 2/3] added public void setFormattingRanges(CellRangeAddress[] ranges) method to the XSSFConditionalFormatting class Resolve Bug 60314 https://bz.apache.org/bugzilla/show_bug.cgi?id=60314 --- .../xssf/usermodel/XSSFConditionalFormatting.java | 128 ++++++++++++--------- .../usermodel/TestXSSFConditionalFormatting.java | 47 +++++++- 2 files changed, 116 insertions(+), 59 deletions(-) mode change 100644 => 100755 src/ooxml/java/org/apache/poi/xssf/usermodel/XSSFConditionalFormatting.java mode change 100644 => 100755 src/ooxml/testcases/org/apache/poi/xssf/usermodel/TestXSSFConditionalFormatting.java diff --git a/src/ooxml/java/org/apache/poi/xssf/usermodel/XSSFConditionalFormatting.java b/src/ooxml/java/org/apache/poi/xssf/usermodel/XSSFConditionalFormatting.java old mode 100644 new mode 100755 index 53eb41b122..9030f0f680 --- a/src/ooxml/java/org/apache/poi/xssf/usermodel/XSSFConditionalFormatting.java +++ b/src/ooxml/java/org/apache/poi/xssf/usermodel/XSSFConditionalFormatting.java @@ -25,6 +25,7 @@ import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTConditionalFormatting; import java.util.ArrayList; +import java.util.Collections; /** * @author Yegor Kozlov @@ -33,73 +34,94 @@ private final CTConditionalFormatting _cf; private final XSSFSheet _sh; - /*package*/ XSSFConditionalFormatting(XSSFSheet sh){ + /*package*/ XSSFConditionalFormatting(XSSFSheet sh) { _cf = CTConditionalFormatting.Factory.newInstance(); _sh = sh; } - /*package*/ XSSFConditionalFormatting(XSSFSheet sh, CTConditionalFormatting cf){ + /*package*/ XSSFConditionalFormatting( + XSSFSheet sh, CTConditionalFormatting cf) { _cf = cf; _sh = sh; } - /*package*/ CTConditionalFormatting getCTConditionalFormatting(){ + /*package*/ CTConditionalFormatting getCTConditionalFormatting() { return _cf; } /** - * @return array of CellRangeAddresss. Never null - */ - public CellRangeAddress[] getFormattingRanges(){ - ArrayList lst = new ArrayList(); - for (Object stRef : _cf.getSqref()) { - String[] regions = stRef.toString().split(" "); - for (int i = 0; i < regions.length; i++) { - lst.add(CellRangeAddress.valueOf(regions[i])); - } - } - return lst.toArray(new CellRangeAddress[lst.size()]); - } + * @return array of CellRangeAddresss. Never null + */ + @Override + public CellRangeAddress[] getFormattingRanges() { + ArrayList lst = new ArrayList(); + for (Object stRef : _cf.getSqref()) { + String[] regions = stRef.toString().split(" "); + for (final String region : regions) { + lst.add(CellRangeAddress.valueOf(region)); + } + } + return lst.toArray(new CellRangeAddress[lst.size()]); + } - /** - * Replaces an existing Conditional Formatting rule at position idx. - * Excel allows to create up to 3 Conditional Formatting rules. - * This method can be useful to modify existing Conditional Formatting rules. - * - * @param idx position of the rule. Should be between 0 and 2. - * @param cfRule - Conditional Formatting rule - */ - public void setRule(int idx, ConditionalFormattingRule cfRule){ - XSSFConditionalFormattingRule xRule = (XSSFConditionalFormattingRule)cfRule; - _cf.getCfRuleArray(idx).set(xRule.getCTCfRule()); - } + public void setFormattingRanges(CellRangeAddress[] ranges) { + final StringBuilder sb = new StringBuilder(); + boolean first = true; + for (CellRangeAddress range : ranges) { + if (!first) { + sb.append(" "); + } else { + first = false; + } + sb.append(range.formatAsString()); + } + _cf.setSqref(Collections.singletonList(sb.toString())); + } - /** - * Add a Conditional Formatting rule. - * Excel allows to create up to 3 Conditional Formatting rules. - * - * @param cfRule - Conditional Formatting rule - */ - public void addRule(ConditionalFormattingRule cfRule){ - XSSFConditionalFormattingRule xRule = (XSSFConditionalFormattingRule)cfRule; - _cf.addNewCfRule().set(xRule.getCTCfRule()); - } + /** + * Replaces an existing Conditional Formatting rule at position idx. + * Excel allows to create up to 3 Conditional Formatting rules. + * This method can be useful to modify existing Conditional Formatting rules. + * + * @param idx position of the rule. Should be between 0 and 2. + * @param cfRule - Conditional Formatting rule + */ + @Override + public void setRule(int idx, ConditionalFormattingRule cfRule) { + XSSFConditionalFormattingRule xRule = (XSSFConditionalFormattingRule) cfRule; + _cf.getCfRuleArray(idx).set(xRule.getCTCfRule()); + } - /** - * @return the Conditional Formatting rule at position idx. - */ - public XSSFConditionalFormattingRule getRule(int idx){ - return new XSSFConditionalFormattingRule(_sh, _cf.getCfRuleArray(idx)); - } + /** + * Add a Conditional Formatting rule. + * Excel allows to create up to 3 Conditional Formatting rules. + * + * @param cfRule - Conditional Formatting rule + */ + @Override + public void addRule(ConditionalFormattingRule cfRule) { + XSSFConditionalFormattingRule xRule = (XSSFConditionalFormattingRule) cfRule; + _cf.addNewCfRule().set(xRule.getCTCfRule()); + } - /** - * @return number of Conditional Formatting rules. - */ - public int getNumberOfRules(){ - return _cf.sizeOfCfRuleArray(); - } - - public String toString() { - return _cf.toString(); - } + /** + * @return the Conditional Formatting rule at position idx. + */ + @Override + public XSSFConditionalFormattingRule getRule(int idx) { + return new XSSFConditionalFormattingRule(_sh, _cf.getCfRuleArray(idx)); + } + + /** + * @return number of Conditional Formatting rules. + */ + @Override + public int getNumberOfRules() { + return _cf.sizeOfCfRuleArray(); + } + + @Override + public String toString() { + return _cf.toString(); + } } diff --git a/src/ooxml/testcases/org/apache/poi/xssf/usermodel/TestXSSFConditionalFormatting.java b/src/ooxml/testcases/org/apache/poi/xssf/usermodel/TestXSSFConditionalFormatting.java old mode 100644 new mode 100755 index a73a0cf7cf..e285d63cb7 --- a/src/ooxml/testcases/org/apache/poi/xssf/usermodel/TestXSSFConditionalFormatting.java +++ b/src/ooxml/testcases/org/apache/poi/xssf/usermodel/TestXSSFConditionalFormatting.java @@ -18,15 +18,15 @@ */ package org.apache.poi.xssf.usermodel; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; +import org.apache.poi.ss.usermodel.*; +import org.apache.poi.ss.util.CellRangeAddress; +import org.apache.poi.xssf.XSSFITestDataProvider; +import org.junit.Test; import java.io.IOException; -import org.apache.poi.ss.usermodel.BaseTestConditionalFormatting; -import org.apache.poi.ss.usermodel.Color; -import org.apache.poi.xssf.XSSFITestDataProvider; -import org.junit.Test; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; /** * XSSF-specific Conditional Formatting tests @@ -56,4 +56,39 @@ public void testRead() throws IOException { public void testReadOffice2007() throws IOException { testReadOffice2007("NewStyleConditionalFormattings.xlsx"); } + + @Test + public void testSetCellRangeAddress() throws Exception { + XSSFWorkbook wb = new XSSFWorkbook(); + final XSSFSheet sheet = wb.createSheet("S1"); + final XSSFSheetConditionalFormatting cf = sheet.getSheetConditionalFormatting(); + assertEquals(0, cf.getNumConditionalFormattings()); + ExtendedColor color = wb.getCreationHelper().createExtendedColor(); + color.setARGBHex("FF63BE7B"); + ConditionalFormattingRule rule1 = cf.createConditionalFormattingRule(color); + DataBarFormatting db1 = rule1.getDataBarFormatting(); + db1.getMinThreshold().setRangeType(ConditionalFormattingThreshold.RangeType.MIN); + db1.getMaxThreshold().setRangeType(ConditionalFormattingThreshold.RangeType.MAX); + + cf.addConditionalFormatting(new CellRangeAddress[] { + CellRangeAddress.valueOf("A1:A5") + }, rule1); + + assertEquals(1, cf.getNumConditionalFormattings()); + XSSFConditionalFormatting readCf = cf.getConditionalFormattingAt(0); + CellRangeAddress[] formattingRanges = readCf.getFormattingRanges(); + assertEquals(1, formattingRanges.length); + CellRangeAddress formattingRange = formattingRanges[0]; + assertEquals("A1:A5", formattingRange.formatAsString()); + + readCf.setFormattingRanges(new CellRangeAddress[] { + CellRangeAddress.valueOf("A1:A6") + }); + + readCf = cf.getConditionalFormattingAt(0); + formattingRanges = readCf.getFormattingRanges(); + assertEquals(1, formattingRanges.length); + formattingRange = formattingRanges[0]; + assertEquals("A1:A6", formattingRange.formatAsString()); + } } From 8b7b64b2cabde53ce8dbb6d76f51a23b5fbbc0c6 Mon Sep 17 00:00:00 2001 From: Luca Martini Date: Mon, 31 Oct 2016 10:37:10 +0100 Subject: [PATCH 3/3] Implemented setFormattingRanges for HSSF. Pulled up the setFormattingRanges to the ConditionalFormatting interfaces. Pulled up the unit test to the BaseTestConditionalFormatting class. Added some other unit tests to address corner cases. --- .../hssf/usermodel/HSSFConditionalFormatting.java | 12 +++ .../poi/ss/usermodel/ConditionalFormatting.java | 6 ++ .../xssf/usermodel/XSSFConditionalFormatting.java | 4 + .../usermodel/TestXSSFConditionalFormatting.java | 39 +--------- .../usermodel/BaseTestConditionalFormatting.java | 90 +++++++++++++++++++--- 5 files changed, 105 insertions(+), 46 deletions(-) mode change 100644 => 100755 src/java/org/apache/poi/hssf/usermodel/HSSFConditionalFormatting.java mode change 100644 => 100755 src/java/org/apache/poi/ss/usermodel/ConditionalFormatting.java mode change 100644 => 100755 src/testcases/org/apache/poi/ss/usermodel/BaseTestConditionalFormatting.java diff --git a/src/java/org/apache/poi/hssf/usermodel/HSSFConditionalFormatting.java b/src/java/org/apache/poi/hssf/usermodel/HSSFConditionalFormatting.java old mode 100644 new mode 100755 index fd31c2df92..26bdd6bd95 --- a/src/java/org/apache/poi/hssf/usermodel/HSSFConditionalFormatting.java +++ b/src/java/org/apache/poi/hssf/usermodel/HSSFConditionalFormatting.java @@ -94,10 +94,17 @@ CFRecordsAggregate getCFRecordsAggregate() { /** * @return array of CellRangeAddresss. never null */ + @Override public CellRangeAddress[] getFormattingRanges() { return cfAggregate.getHeader().getCellRanges(); } + @Override + public void setFormattingRanges( + final CellRangeAddress[] ranges) { + cfAggregate.getHeader().setCellRanges(ranges); + } + /** * Replaces an existing Conditional Formatting rule at position idx. * Older versions of Excel only allow up to 3 Conditional Formatting rules, @@ -111,6 +118,7 @@ public void setRule(int idx, HSSFConditionalFormattingRule cfRule) { cfAggregate.setRule(idx, cfRule.getCfRuleRecord()); } + @Override public void setRule(int idx, ConditionalFormattingRule cfRule){ setRule(idx, (HSSFConditionalFormattingRule)cfRule); } @@ -124,6 +132,7 @@ public void addRule(HSSFConditionalFormattingRule cfRule) { cfAggregate.addRule(cfRule.getCfRuleRecord()); } + @Override public void addRule(ConditionalFormattingRule cfRule){ addRule((HSSFConditionalFormattingRule)cfRule); } @@ -131,6 +140,7 @@ public void addRule(ConditionalFormattingRule cfRule){ /** * @return the Conditional Formatting rule at position idx. */ + @Override public HSSFConditionalFormattingRule getRule(int idx) { CFRuleBase ruleRecord = cfAggregate.getRule(idx); return new HSSFConditionalFormattingRule(sheet, ruleRecord); @@ -139,10 +149,12 @@ public HSSFConditionalFormattingRule getRule(int idx) { /** * @return number of Conditional Formatting rules. */ + @Override public int getNumberOfRules() { return cfAggregate.getNumberOfRules(); } + @Override public String toString() { return cfAggregate.toString(); } diff --git a/src/java/org/apache/poi/ss/usermodel/ConditionalFormatting.java b/src/java/org/apache/poi/ss/usermodel/ConditionalFormatting.java old mode 100644 new mode 100755 index f6e8ff441f..09d63a407d --- a/src/java/org/apache/poi/ss/usermodel/ConditionalFormatting.java +++ b/src/java/org/apache/poi/ss/usermodel/ConditionalFormatting.java @@ -81,6 +81,12 @@ CellRangeAddress[] getFormattingRanges(); /** + * Sets the cell ranges the rule conditional formatting must be applied to. + * @param ranges non-null array of CellRangeAddresss + */ + void setFormattingRanges(CellRangeAddress[] ranges); + + /** * Replaces an existing Conditional Formatting rule at position idx. * Excel pre-2007 allows to create up to 3 Conditional Formatting rules, * 2007 and later allow unlimited numbers. diff --git a/src/ooxml/java/org/apache/poi/xssf/usermodel/XSSFConditionalFormatting.java b/src/ooxml/java/org/apache/poi/xssf/usermodel/XSSFConditionalFormatting.java index 9030f0f680..915ba5d4bf 100755 --- a/src/ooxml/java/org/apache/poi/xssf/usermodel/XSSFConditionalFormatting.java +++ b/src/ooxml/java/org/apache/poi/xssf/usermodel/XSSFConditionalFormatting.java @@ -64,7 +64,11 @@ return lst.toArray(new CellRangeAddress[lst.size()]); } + @Override public void setFormattingRanges(CellRangeAddress[] ranges) { + if (ranges == null) { + throw new IllegalArgumentException("cellRanges must not be null"); + } final StringBuilder sb = new StringBuilder(); boolean first = true; for (CellRangeAddress range : ranges) { diff --git a/src/ooxml/testcases/org/apache/poi/xssf/usermodel/TestXSSFConditionalFormatting.java b/src/ooxml/testcases/org/apache/poi/xssf/usermodel/TestXSSFConditionalFormatting.java index e285d63cb7..c145c129e2 100755 --- a/src/ooxml/testcases/org/apache/poi/xssf/usermodel/TestXSSFConditionalFormatting.java +++ b/src/ooxml/testcases/org/apache/poi/xssf/usermodel/TestXSSFConditionalFormatting.java @@ -18,8 +18,8 @@ */ package org.apache.poi.xssf.usermodel; -import org.apache.poi.ss.usermodel.*; -import org.apache.poi.ss.util.CellRangeAddress; +import org.apache.poi.ss.usermodel.BaseTestConditionalFormatting; +import org.apache.poi.ss.usermodel.Color; import org.apache.poi.xssf.XSSFITestDataProvider; import org.junit.Test; @@ -56,39 +56,4 @@ public void testRead() throws IOException { public void testReadOffice2007() throws IOException { testReadOffice2007("NewStyleConditionalFormattings.xlsx"); } - - @Test - public void testSetCellRangeAddress() throws Exception { - XSSFWorkbook wb = new XSSFWorkbook(); - final XSSFSheet sheet = wb.createSheet("S1"); - final XSSFSheetConditionalFormatting cf = sheet.getSheetConditionalFormatting(); - assertEquals(0, cf.getNumConditionalFormattings()); - ExtendedColor color = wb.getCreationHelper().createExtendedColor(); - color.setARGBHex("FF63BE7B"); - ConditionalFormattingRule rule1 = cf.createConditionalFormattingRule(color); - DataBarFormatting db1 = rule1.getDataBarFormatting(); - db1.getMinThreshold().setRangeType(ConditionalFormattingThreshold.RangeType.MIN); - db1.getMaxThreshold().setRangeType(ConditionalFormattingThreshold.RangeType.MAX); - - cf.addConditionalFormatting(new CellRangeAddress[] { - CellRangeAddress.valueOf("A1:A5") - }, rule1); - - assertEquals(1, cf.getNumConditionalFormattings()); - XSSFConditionalFormatting readCf = cf.getConditionalFormattingAt(0); - CellRangeAddress[] formattingRanges = readCf.getFormattingRanges(); - assertEquals(1, formattingRanges.length); - CellRangeAddress formattingRange = formattingRanges[0]; - assertEquals("A1:A5", formattingRange.formatAsString()); - - readCf.setFormattingRanges(new CellRangeAddress[] { - CellRangeAddress.valueOf("A1:A6") - }); - - readCf = cf.getConditionalFormattingAt(0); - formattingRanges = readCf.getFormattingRanges(); - assertEquals(1, formattingRanges.length); - formattingRange = formattingRanges[0]; - assertEquals("A1:A6", formattingRange.formatAsString()); - } } diff --git a/src/testcases/org/apache/poi/ss/usermodel/BaseTestConditionalFormatting.java b/src/testcases/org/apache/poi/ss/usermodel/BaseTestConditionalFormatting.java old mode 100644 new mode 100755 index 28cfb2cf7b..d5a8124df9 --- a/src/testcases/org/apache/poi/ss/usermodel/BaseTestConditionalFormatting.java +++ b/src/testcases/org/apache/poi/ss/usermodel/BaseTestConditionalFormatting.java @@ -19,15 +19,6 @@ package org.apache.poi.ss.usermodel; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; -import static org.junit.Assert.fail; - -import java.io.IOException; - import org.apache.poi.hssf.usermodel.HSSFConditionalFormatting; import org.apache.poi.hssf.usermodel.HSSFConditionalFormattingRule; import org.apache.poi.ss.ITestDataProvider; @@ -36,6 +27,10 @@ import org.apache.poi.ss.util.CellRangeAddress; import org.junit.Test; +import java.io.IOException; + +import static org.junit.Assert.*; + /** * Base tests for Conditional Formatting, for both HSSF and XSSF */ @@ -1271,4 +1266,81 @@ public void testBug55380() throws IOException { sheet.getSheetConditionalFormatting().addConditionalFormatting(ranges, rule); wb.close(); } + + @Test + public void testSetCellRangeAddresswithSingleRange() throws Exception { + Workbook wb = _testDataProvider.createWorkbook(); + final Sheet sheet = wb.createSheet("S1"); + final SheetConditionalFormatting cf = sheet.getSheetConditionalFormatting(); + assertEquals(0, cf.getNumConditionalFormattings()); + ConditionalFormattingRule rule1 = cf.createConditionalFormattingRule("$A$1>0"); + cf.addConditionalFormatting(new CellRangeAddress[] { + CellRangeAddress.valueOf("A1:A5") + }, rule1); + + assertEquals(1, cf.getNumConditionalFormattings()); + ConditionalFormatting readCf = cf.getConditionalFormattingAt(0); + CellRangeAddress[] formattingRanges = readCf.getFormattingRanges(); + assertEquals(1, formattingRanges.length); + CellRangeAddress formattingRange = formattingRanges[0]; + assertEquals("A1:A5", formattingRange.formatAsString()); + + readCf.setFormattingRanges(new CellRangeAddress[] { + CellRangeAddress.valueOf("A1:A6") + }); + + readCf = cf.getConditionalFormattingAt(0); + formattingRanges = readCf.getFormattingRanges(); + assertEquals(1, formattingRanges.length); + formattingRange = formattingRanges[0]; + assertEquals("A1:A6", formattingRange.formatAsString()); + } + + @Test + public void testSetCellRangeAddressWithMultipleRanges() throws Exception { + Workbook wb = _testDataProvider.createWorkbook(); + final Sheet sheet = wb.createSheet("S1"); + final SheetConditionalFormatting cf = sheet.getSheetConditionalFormatting(); + assertEquals(0, cf.getNumConditionalFormattings()); + ConditionalFormattingRule rule1 = cf.createConditionalFormattingRule("$A$1>0"); + cf.addConditionalFormatting(new CellRangeAddress[] { + CellRangeAddress.valueOf("A1:A5") + }, rule1); + + assertEquals(1, cf.getNumConditionalFormattings()); + ConditionalFormatting readCf = cf.getConditionalFormattingAt(0); + CellRangeAddress[] formattingRanges = readCf.getFormattingRanges(); + assertEquals(1, formattingRanges.length); + CellRangeAddress formattingRange = formattingRanges[0]; + assertEquals("A1:A5", formattingRange.formatAsString()); + + readCf.setFormattingRanges(new CellRangeAddress[] { + CellRangeAddress.valueOf("A1:A6"), + CellRangeAddress.valueOf("B1:B6") + }); + + readCf = cf.getConditionalFormattingAt(0); + formattingRanges = readCf.getFormattingRanges(); + assertEquals(2, formattingRanges.length); + formattingRange = formattingRanges[0]; + assertEquals("A1:A6", formattingRange.formatAsString()); + formattingRange = formattingRanges[1]; + assertEquals("B1:B6", formattingRange.formatAsString()); + } + + @Test(expected = IllegalArgumentException.class) + public void testSetCellRangeAddressWithNullRanges() throws Exception { + Workbook wb = _testDataProvider.createWorkbook(); + final Sheet sheet = wb.createSheet("S1"); + final SheetConditionalFormatting cf = sheet.getSheetConditionalFormatting(); + assertEquals(0, cf.getNumConditionalFormattings()); + ConditionalFormattingRule rule1 = cf.createConditionalFormattingRule("$A$1>0"); + cf.addConditionalFormatting(new CellRangeAddress[] { + CellRangeAddress.valueOf("A1:A5") + }, rule1); + + assertEquals(1, cf.getNumConditionalFormattings()); + ConditionalFormatting readCf = cf.getConditionalFormattingAt(0); + readCf.setFormattingRanges(null); + } } \ No newline at end of file