source: trunk/HeuristicLab.ExtLibs/HeuristicLab.EPPlus/4.0.3/EPPlus-4.0.3/ConditionalFormatting/ExcelConditionalFormattingIconDataBarValue.cs

/*******************************************************************************
 * You may amend and distribute as you like, but don't remove this header!
 *
 * EPPlus provides server-side generation of Excel 2007/2010 spreadsheets.
 * See http://www.codeplex.com/EPPlus for details.
 *
 * Copyright (C) 2011  Jan Källman
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.

 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
 * See the GNU Lesser General Public License for more details.
 *
 * The GNU Lesser General Public License can be viewed at http://www.opensource.org/licenses/lgpl-license.php
 * If you unfamiliar with this license or have questions about it, here is an http://www.gnu.org/licenses/gpl-faq.html
 *
 * All code and executables are provided "as is" with no warranty either express or implied. 
 * The author accepts no liability for any damage or loss of business that this product may cause.
 *
 * Code change notes:
 * 
 * Author             Change            Date
 * ******************************************************************************
 * Eyal Seagull        Added            2012-04-03
 *******************************************************************************/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;
using System.Xml;
using OfficeOpenXml.Utils;
using System.Text.RegularExpressions;
using System.Globalization;
using System.Security;

namespace OfficeOpenXml.ConditionalFormatting
{
  /// <summary>
  /// 18.3.1.11 cfvo (Conditional Format Value Object)
  /// Describes the values of the interpolation points in a gradient scale.
  /// </summary>
  public class ExcelConditionalFormattingIconDataBarValue
    : XmlHelper
  {
    /****************************************************************************************/

    #region Private Properties
    private eExcelConditionalFormattingRuleType _ruleType;
    private ExcelWorksheet _worksheet;
    #endregion Private Properties

    /****************************************************************************************/

    #region Constructors
    /// <summary>
    /// Initialize the cfvo (§18.3.1.11) node
    /// </summary>
    /// <param name="type"></param>
    /// <param name="value"></param>
    /// <param name="formula"></param>
    /// <param name="ruleType"></param>
    /// <param name="address"></param>
    /// <param name="priority"></param>
    /// <param name="worksheet"></param>
    /// <param name="itemElementNode">The cfvo (§18.3.1.11) node parent. Can be any of the following:
    /// colorScale (§18.3.1.16); dataBar (§18.3.1.28); iconSet (§18.3.1.49)</param>
    /// <param name="namespaceManager"></param>
    internal ExcelConditionalFormattingIconDataBarValue(
      eExcelConditionalFormattingValueObjectType type,
      double value,
      string formula,
      eExcelConditionalFormattingRuleType ruleType,
            ExcelAddress address,
            int priority,
      ExcelWorksheet worksheet,
      XmlNode itemElementNode,
      XmlNamespaceManager namespaceManager)
      : this(
            ruleType,
            address,
            worksheet,
            itemElementNode,
      namespaceManager)
    {
      Require.Argument(priority).IsInRange(1, int.MaxValue, "priority");

            // Check if the parent does not exists
      if (itemElementNode == null)
      {
        // Get the parent node path by the rule type
        string parentNodePath = ExcelConditionalFormattingValueObjectType.GetParentPathByRuleType(
          ruleType);

        // Check for en error (rule type does not have <cfvo>)
        if (parentNodePath == string.Empty)
        {
          throw new Exception(
            ExcelConditionalFormattingConstants.Errors.MissingCfvoParentNode);
        }

        // Point to the <cfvo> parent node
        itemElementNode = _worksheet.WorksheetXml.SelectSingleNode(
          string.Format(
            "//{0}[{1}='{2}']/{3}[{4}='{5}']/{6}",
          // {0}
            ExcelConditionalFormattingConstants.Paths.ConditionalFormatting,
          // {1}
            ExcelConditionalFormattingConstants.Paths.SqrefAttribute,
          // {2}
            address.Address,
          // {3}
            ExcelConditionalFormattingConstants.Paths.CfRule,
          // {4}
            ExcelConditionalFormattingConstants.Paths.PriorityAttribute,
          // {5}
            priority,
          // {6}
            parentNodePath),
          _worksheet.NameSpaceManager);

        // Check for en error (rule type does not have <cfvo>)
                if (itemElementNode == null)
        {
          throw new Exception(
            ExcelConditionalFormattingConstants.Errors.MissingCfvoParentNode);
        }
      }

            TopNode = itemElementNode;

      // Save the attributes
      RuleType = ruleType;
      Type = type;
      Value = value;
      Formula = formula;
    }
    /// <summary>
    /// Initialize the cfvo (§18.3.1.11) node
    /// </summary>
    /// <param name="ruleType"></param>
    /// <param name="address"></param>
    /// <param name="worksheet"></param>
    /// <param name="itemElementNode">The cfvo (§18.3.1.11) node parent. Can be any of the following:
    /// colorScale (§18.3.1.16); dataBar (§18.3.1.28); iconSet (§18.3.1.49)</param>
    /// <param name="namespaceManager"></param>
        internal ExcelConditionalFormattingIconDataBarValue(
            eExcelConditionalFormattingRuleType ruleType,
            ExcelAddress address,
            ExcelWorksheet worksheet,
            XmlNode itemElementNode,
            XmlNamespaceManager namespaceManager)
            : base(
                namespaceManager,
                itemElementNode)
        {
            Require.Argument(address).IsNotNull("address");
            Require.Argument(worksheet).IsNotNull("worksheet");

            // Save the worksheet for private methods to use
            _worksheet = worksheet;

            // Schema order list
            SchemaNodeOrder = new string[]
      {
                ExcelConditionalFormattingConstants.Nodes.Cfvo,
      };

            //Check if the parent does not exists
            if (itemElementNode == null)
            {
                // Get the parent node path by the rule type
                string parentNodePath = ExcelConditionalFormattingValueObjectType.GetParentPathByRuleType(
                    ruleType);

                // Check for en error (rule type does not have <cfvo>)
                if (parentNodePath == string.Empty)
                {
                    throw new Exception(
                        ExcelConditionalFormattingConstants.Errors.MissingCfvoParentNode);
                }
            }
            RuleType = ruleType;            
        }
    /// <summary>
    /// Initialize the <see cref="ExcelConditionalFormattingColorScaleValue"/>
    /// </summary>
    /// <param name="type"></param>
    /// <param name="value"></param>
    /// <param name="formula"></param>
    /// <param name="ruleType"></param>
    /// <param name="priority"></param>
    /// <param name="address"></param>
    /// <param name="worksheet"></param>
    /// <param name="namespaceManager"></param>
    internal ExcelConditionalFormattingIconDataBarValue(
      eExcelConditionalFormattingValueObjectType type,
      double value,
      string formula,
      eExcelConditionalFormattingRuleType ruleType,
            ExcelAddress address,
            int priority,
      ExcelWorksheet worksheet,
      XmlNamespaceManager namespaceManager)
      : this(
        type,
        value,
        formula,
        ruleType,
                address,
                priority,
        worksheet,
        null,
        namespaceManager)
    {
            
    }
    /// <summary>
    /// Initialize the <see cref="ExcelConditionalFormattingColorScaleValue"/>
    /// </summary>
    /// <param name="type"></param>
    /// <param name="color"></param>
    /// <param name="ruleType"></param>
    /// <param name="priority"></param>
    /// <param name="address"></param>
    /// <param name="worksheet"></param>
    /// <param name="namespaceManager"></param>
    internal ExcelConditionalFormattingIconDataBarValue(
      eExcelConditionalFormattingValueObjectType type,
      Color color,
      eExcelConditionalFormattingRuleType ruleType,
            ExcelAddress address,
            int priority,
      ExcelWorksheet worksheet,
      XmlNamespaceManager namespaceManager)
      : this(
        type,
        0,
        null,
        ruleType,
                address,
                priority,
        worksheet,
        null,
        namespaceManager)
    {
    }
    #endregion Constructors

    /****************************************************************************************/

    #region Methods
        #endregion

        /****************************************************************************************/

    #region Exposed Properties

    /// <summary>
    /// 
    /// </summary>
    internal eExcelConditionalFormattingRuleType RuleType
    {
      get { return _ruleType; }
      set { _ruleType = value; }
    }

    /// <summary>
    /// 
    /// </summary>
    public eExcelConditionalFormattingValueObjectType Type
    {
      get
      {
        var typeAttribute = GetXmlNodeString(ExcelConditionalFormattingConstants.Paths.TypeAttribute);

        return ExcelConditionalFormattingValueObjectType.GetTypeByAttrbiute(typeAttribute);
      }
      set
      {
                if ((_ruleType==eExcelConditionalFormattingRuleType.ThreeIconSet || _ruleType==eExcelConditionalFormattingRuleType.FourIconSet || _ruleType==eExcelConditionalFormattingRuleType.FiveIconSet) &&
                    (value == eExcelConditionalFormattingValueObjectType.Min || value == eExcelConditionalFormattingValueObjectType.Max))
                {
                    throw(new ArgumentException("Value type can't be Min or Max for icon sets"));
                }
                SetXmlNodeString(ExcelConditionalFormattingConstants.Paths.TypeAttribute, value.ToString().ToLower(CultureInfo.InvariantCulture));                
      }
    }

    /// <summary>
    /// Get/Set the 'cfvo' node @val attribute
    /// </summary>
    public Double Value
    {
      get
      {
                if ((Type == eExcelConditionalFormattingValueObjectType.Num)
                    || (Type == eExcelConditionalFormattingValueObjectType.Percent)
                    || (Type == eExcelConditionalFormattingValueObjectType.Percentile))
                {
                    return GetXmlNodeDouble(ExcelConditionalFormattingConstants.Paths.ValAttribute);
                }
                else
                {
                    return 0;
                }
            }
      set
      {
        string valueToStore = string.Empty;

        // Only some types use the @val attribute
        if ((Type == eExcelConditionalFormattingValueObjectType.Num)
          || (Type == eExcelConditionalFormattingValueObjectType.Percent)
          || (Type == eExcelConditionalFormattingValueObjectType.Percentile))
        {
          valueToStore = value.ToString(CultureInfo.InvariantCulture);
        }

                SetXmlNodeString(ExcelConditionalFormattingConstants.Paths.ValAttribute, valueToStore);
      }
    }

    /// <summary>
    /// Get/Set the Formula of the Object Value (uses the same attribute as the Value)
    /// </summary>
    public string Formula
    {
      get
      {
        // Return empty if the Object Value type is not Formula
        if (Type != eExcelConditionalFormattingValueObjectType.Formula)
        {
          return string.Empty;
        }

        // Excel stores the formula in the @val attribute
        return GetXmlNodeString(ExcelConditionalFormattingConstants.Paths.ValAttribute);
      }
      set
      {
        // Only store the formula if the Object Value type is Formula
        if (Type == eExcelConditionalFormattingValueObjectType.Formula)
        {
                    SetXmlNodeString(ExcelConditionalFormattingConstants.Paths.ValAttribute, value);
        }
      }
    }
    #endregion Exposed Properties

    /****************************************************************************************/
  }
}