| /* ==================================================================== |
| Licensed to the Apache Software Foundation (ASF) under one or more |
| contributor license agreements. See the NOTICE file distributed with |
| this work for additional information regarding copyright ownership. |
| The ASF licenses this file to You under the Apache License, Version 2.0 |
| (the "License"); you may not use this file except in compliance with |
| the License. You may obtain a copy of the License at |
| |
| http://www.apache.org/licenses/LICENSE-2.0 |
| |
| Unless required by applicable law or agreed to in writing, software |
| distributed under the License is distributed on an "AS IS" BASIS, |
| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| See the License for the specific language governing permissions and |
| limitations under the License. |
| ==================================================================== */ |
| |
| package org.apache.poi.hssf.usermodel; |
| |
| import org.apache.poi.hssf.model.HSSFFormulaParser; |
| import org.apache.poi.hssf.record.CFRule12Record; |
| import org.apache.poi.hssf.record.CFRuleBase; |
| import org.apache.poi.hssf.record.CFRuleBase.ComparisonOperator; |
| import org.apache.poi.hssf.record.CFRuleRecord; |
| import org.apache.poi.hssf.record.cf.BorderFormatting; |
| import org.apache.poi.hssf.record.cf.ColorGradientFormatting; |
| import org.apache.poi.hssf.record.cf.FontFormatting; |
| import org.apache.poi.hssf.record.cf.IconMultiStateFormatting; |
| import org.apache.poi.hssf.record.cf.PatternFormatting; |
| import org.apache.poi.ss.formula.ptg.Ptg; |
| import org.apache.poi.ss.usermodel.ConditionType; |
| import org.apache.poi.ss.usermodel.ConditionalFormattingRule; |
| |
| /** |
| * |
| * High level representation of Conditional Formatting Rule. |
| * It allows to specify formula based conditions for the Conditional Formatting |
| * and the formatting settings such as font, border and pattern. |
| */ |
| public final class HSSFConditionalFormattingRule implements ConditionalFormattingRule { |
| private static final byte CELL_COMPARISON = CFRuleRecord.CONDITION_TYPE_CELL_VALUE_IS; |
| |
| private final CFRuleBase cfRuleRecord; |
| private final HSSFWorkbook workbook; |
| private final HSSFSheet sheet; |
| |
| HSSFConditionalFormattingRule(HSSFSheet pSheet, CFRuleBase pRuleRecord) { |
| if (pSheet == null) { |
| throw new IllegalArgumentException("pSheet must not be null"); |
| } |
| if (pRuleRecord == null) { |
| throw new IllegalArgumentException("pRuleRecord must not be null"); |
| } |
| sheet = pSheet; |
| workbook = pSheet.getWorkbook(); |
| cfRuleRecord = pRuleRecord; |
| } |
| |
| CFRuleBase getCfRuleRecord() { |
| return cfRuleRecord; |
| } |
| private CFRule12Record getCFRule12Record(boolean create) { |
| if (cfRuleRecord instanceof CFRule12Record) { |
| // Good |
| } else { |
| if (create) throw new IllegalArgumentException("Can't convert a CF into a CF12 record"); |
| return null; |
| } |
| return (CFRule12Record)cfRuleRecord; |
| } |
| |
| private HSSFFontFormatting getFontFormatting(boolean create) |
| { |
| FontFormatting fontFormatting = cfRuleRecord.getFontFormatting(); |
| if ( fontFormatting != null) |
| { |
| cfRuleRecord.setFontFormatting(fontFormatting); |
| return new HSSFFontFormatting(cfRuleRecord, workbook); |
| } |
| else if( create ) |
| { |
| fontFormatting = new FontFormatting(); |
| cfRuleRecord.setFontFormatting(fontFormatting); |
| return new HSSFFontFormatting(cfRuleRecord, workbook); |
| } |
| else |
| { |
| return null; |
| } |
| } |
| |
| /** |
| * @return - font formatting object if defined, <code>null</code> otherwise |
| */ |
| public HSSFFontFormatting getFontFormatting() |
| { |
| return getFontFormatting(false); |
| } |
| /** |
| * create a new font formatting structure if it does not exist, |
| * otherwise just return existing object. |
| * @return - font formatting object, never returns <code>null</code>. |
| */ |
| public HSSFFontFormatting createFontFormatting() |
| { |
| return getFontFormatting(true); |
| } |
| |
| private HSSFBorderFormatting getBorderFormatting(boolean create) |
| { |
| BorderFormatting borderFormatting = cfRuleRecord.getBorderFormatting(); |
| if ( borderFormatting != null) |
| { |
| cfRuleRecord.setBorderFormatting(borderFormatting); |
| return new HSSFBorderFormatting(cfRuleRecord, workbook); |
| } |
| else if( create ) |
| { |
| borderFormatting = new BorderFormatting(); |
| cfRuleRecord.setBorderFormatting(borderFormatting); |
| return new HSSFBorderFormatting(cfRuleRecord, workbook); |
| } |
| else |
| { |
| return null; |
| } |
| } |
| /** |
| * @return - border formatting object if defined, <code>null</code> otherwise |
| */ |
| public HSSFBorderFormatting getBorderFormatting() |
| { |
| return getBorderFormatting(false); |
| } |
| /** |
| * create a new border formatting structure if it does not exist, |
| * otherwise just return existing object. |
| * @return - border formatting object, never returns <code>null</code>. |
| */ |
| public HSSFBorderFormatting createBorderFormatting() |
| { |
| return getBorderFormatting(true); |
| } |
| |
| private HSSFPatternFormatting getPatternFormatting(boolean create) |
| { |
| PatternFormatting patternFormatting = cfRuleRecord.getPatternFormatting(); |
| if ( patternFormatting != null) |
| { |
| cfRuleRecord.setPatternFormatting(patternFormatting); |
| return new HSSFPatternFormatting(cfRuleRecord, workbook); |
| } |
| else if( create ) |
| { |
| patternFormatting = new PatternFormatting(); |
| cfRuleRecord.setPatternFormatting(patternFormatting); |
| return new HSSFPatternFormatting(cfRuleRecord, workbook); |
| } |
| else |
| { |
| return null; |
| } |
| } |
| |
| /** |
| * @return - pattern formatting object if defined, <code>null</code> otherwise |
| */ |
| public HSSFPatternFormatting getPatternFormatting() |
| { |
| return getPatternFormatting(false); |
| } |
| /** |
| * create a new pattern formatting structure if it does not exist, |
| * otherwise just return existing object. |
| * @return - pattern formatting object, never returns <code>null</code>. |
| */ |
| public HSSFPatternFormatting createPatternFormatting() |
| { |
| return getPatternFormatting(true); |
| } |
| |
| private HSSFIconMultiStateFormatting getMultiStateFormatting(boolean create) { |
| CFRule12Record cfRule12Record = getCFRule12Record(create); |
| IconMultiStateFormatting iconFormatting = cfRule12Record.getMultiStateFormatting(); |
| if (iconFormatting != null) |
| { |
| return new HSSFIconMultiStateFormatting(cfRule12Record, sheet); |
| } |
| else if( create ) |
| { |
| iconFormatting = cfRule12Record.createMultiStateFormatting(); |
| return new HSSFIconMultiStateFormatting(cfRule12Record, sheet); |
| } |
| else |
| { |
| return null; |
| } |
| } |
| /** |
| * @return icon / multi-state formatting object if defined, <code>null</code> otherwise |
| */ |
| public HSSFIconMultiStateFormatting getMultiStateFormatting() { |
| return getMultiStateFormatting(false); |
| } |
| /** |
| * create a new icon / multi-state formatting object if it does not exist, |
| * otherwise just return the existing object. |
| */ |
| public HSSFIconMultiStateFormatting createMultiStateFormatting() { |
| return getMultiStateFormatting(true); |
| } |
| |
| private HSSFColorScaleFormatting getColorScaleFormatting(boolean create) { |
| CFRule12Record cfRule12Record = getCFRule12Record(create); |
| ColorGradientFormatting colorFormatting = cfRule12Record.getColorGradientFormatting(); |
| if (colorFormatting != null) |
| { |
| return new HSSFColorScaleFormatting(cfRule12Record, sheet); |
| } |
| else if( create ) |
| { |
| colorFormatting = cfRule12Record.createColorGradientFormatting(); |
| return new HSSFColorScaleFormatting(cfRule12Record, sheet); |
| } |
| else |
| { |
| return null; |
| } |
| } |
| /** |
| * @return color scale / gradient formatting object if defined, <code>null</code> otherwise |
| */ |
| public HSSFColorScaleFormatting getColorScaleFormatting() { |
| return getColorScaleFormatting(false); |
| } |
| /** |
| * create a new color scale / gradient formatting object if it does not exist, |
| * otherwise just return the existing object. |
| */ |
| public HSSFColorScaleFormatting createColorScaleFormatting() { |
| return getColorScaleFormatting(true); |
| } |
| |
| /** |
| * @return - the conditiontype for the cfrule |
| */ |
| public byte getConditionType() { |
| return cfRuleRecord.getConditionType(); |
| } |
| /** |
| * @return - the conditiontype for the cfrule |
| */ |
| public ConditionType getConditionTypeType() { |
| return ConditionType.forId(getConditionType()); |
| } |
| |
| /** |
| * @return - the comparisionoperatation for the cfrule |
| */ |
| public byte getComparisonOperation() { |
| return cfRuleRecord.getComparisonOperation(); |
| } |
| |
| public String getFormula1() |
| { |
| return toFormulaString(cfRuleRecord.getParsedExpression1()); |
| } |
| |
| public String getFormula2() { |
| byte conditionType = cfRuleRecord.getConditionType(); |
| if (conditionType == CELL_COMPARISON) { |
| byte comparisonOperation = cfRuleRecord.getComparisonOperation(); |
| switch(comparisonOperation) { |
| case ComparisonOperator.BETWEEN: |
| case ComparisonOperator.NOT_BETWEEN: |
| return toFormulaString(cfRuleRecord.getParsedExpression2()); |
| } |
| } |
| return null; |
| } |
| |
| protected String toFormulaString(Ptg[] parsedExpression) { |
| return toFormulaString(parsedExpression, workbook); |
| } |
| protected static String toFormulaString(Ptg[] parsedExpression, HSSFWorkbook workbook) { |
| if(parsedExpression == null || parsedExpression.length == 0) { |
| return null; |
| } |
| return HSSFFormulaParser.toFormulaString(workbook, parsedExpression); |
| } |
| } |