public DVParser(Collection strings) 
{
    type = LIST;
    errorStyle = STOP;
    condition = BETWEEN;
    // the options
    stringListGiven = true;
    emptyCellsAllowed = true;
    suppressArrow = false;
    showPrompt = true;
    showError = true;
    promptTitle = "\0";
    errorTitle = "\0";
    promptText = "\0";
    errorText = "\0";
    if (strings.size() == 0)
    {
      logger.warn("no validation strings - ignoring");
    }
    Iterator i = strings.iterator();
    StringBuffer formulaString = new StringBuffer();
    formulaString.append(i.next().toString());
    while (i.hasNext())
    {
      formulaString.append('\0");
      formulaString.append(' ");
      formulaString.append(i.next().toString());
    }
    // If the formula string exceeds
    // the maximum validation list length, then truncate and stop there
    if (formulaString.length()  > MAX_VALIDATION_LIST_LENGTH)
    {
      logger.warn("Validation list exceeds maximum number of characters - " +
                  "truncating");
      formulaString.delete(MAX_VALIDATION_LIST_LENGTH, 
                           formulaString.length());
    }
    // Put the string in quotes
    formulaString.insert(0, '\"");
    formulaString.append('\"");
    formula1String = formulaString.toString();
}

Constructor called when creating a data validation from the API

 public DVParser(String namedRange) 
{
   
    type = LIST;
    errorStyle = STOP;
    condition = BETWEEN;
    // the options
    stringListGiven = false;
    emptyCellsAllowed = true;
    suppressArrow = false;
    showPrompt = true;
    showError = true;
    promptTitle = "\0";
    errorTitle = "\0";
    promptText = "\0";
    errorText = "\0";
    formula1String = namedRange;
}

Constructor called when creating a data validation from the API

 public DVParser(DVParser copy) 
{
    type = copy.type;
    errorStyle = copy.errorStyle;
    condition = copy.condition;
    stringListGiven = copy.stringListGiven;
    emptyCellsAllowed = copy.emptyCellsAllowed;
    suppressArrow = copy.suppressArrow;
    showPrompt = copy.showPrompt;
    showError = copy.showError;
    promptTitle = copy.promptTitle;
    promptText = copy.promptText;
    errorTitle = copy.errorTitle;
    errorText = copy.errorText;
    // Don't copy the formula parsers - just take their string equivalents
    if (copy.formula1String != null)
    {
      formula1String = copy.formula1String;
      formula2String = copy.formula2String;
    }
    else
    {
      try
      {
        formula1String = copy.formula1.getFormula();
        formula2String = (copy.formula2 != null) ? 
          copy.formula2.getFormula() : null;
      }
      catch (FormulaException e)
      {
        logger.warn("Cannot parse validation formula:  " + e.getMessage());
      }
    }
    // Don't copy the cell references - these will be added later
}

Constructor called when doing a cell deep copy

 public DVParser(double val1,
    double val2,
    DVParser.Condition c) 
{
    type = DECIMAL;
    errorStyle = STOP;
    condition = c;
    // the options
    stringListGiven = false;
    emptyCellsAllowed = true;
    suppressArrow = false;
    showPrompt = true;
    showError = true;
    promptTitle = "\0";
    errorTitle = "\0";
    promptText = "\0";
    errorText = "\0";
    formula1String = DECIMAL_FORMAT.format(val1);
    if (!Double.isNaN(val2))
    {
      formula2String = DECIMAL_FORMAT.format(val2);
    }
}

Constructor called when creating a data validation from the API

 public DVParser(byte[] data,
    ExternalSheet es,
    WorkbookMethods nt,
    WorkbookSettings ws) throws FormulaException 
{
      
    Assert.verify(nt != null);
    int options = IntegerHelper.getInt(data[0], data[1], data[2], data[3]);
    int typeVal = options & 0xf;
    type = DVType.getType(typeVal);
    int errorStyleVal = (options & 0x70)  > > 4;
    errorStyle = ErrorStyle.getErrorStyle(errorStyleVal);
    int conditionVal = (options & 0xf00000)  > > 20;
    condition = Condition.getCondition(conditionVal);
    stringListGiven = (options & STRING_LIST_GIVEN_MASK) != 0;
    emptyCellsAllowed = (options & EMPTY_CELLS_ALLOWED_MASK) != 0;
    suppressArrow = (options & SUPPRESS_ARROW_MASK) != 0;
    showPrompt = (options & SHOW_PROMPT_MASK) != 0;
    showError = (options & SHOW_ERROR_MASK) != 0;
    int pos = 4;
    int length = IntegerHelper.getInt(data[pos], data[pos+1]);
    if (length  > 0 && data[pos + 2] == 0)
    {
      promptTitle = StringHelper.getString(data, length, pos + 3, ws);
      pos += length + 3;
    }
    else if (length  > 0)
    {
      promptTitle = StringHelper.getUnicodeString(data, length, pos + 3);
      pos += length * 2 + 3;
    }
    else
    {
      pos += 3;
    }
    length = IntegerHelper.getInt(data[pos], data[pos+1]);
    if (length  > 0 && data[pos + 2] == 0)
    {
      errorTitle = StringHelper.getString(data, length, pos + 3, ws);
      pos += length + 3;
    }
    else if (length  > 0)
    {
      errorTitle = StringHelper.getUnicodeString(data, length, pos + 3);
      pos += length * 2 + 3;
    }
    else
    {
      pos += 3;
    }
    length = IntegerHelper.getInt(data[pos], data[pos+1]);
    if (length  > 0 && data[pos + 2] == 0)
    {
      promptText = StringHelper.getString(data, length, pos + 3, ws);
      pos += length + 3;
    }
    else if (length  > 0)
    {
      promptText = StringHelper.getUnicodeString(data, length, pos + 3);
      pos += length * 2 + 3;
    }
    else
    {
      pos += 3;
    }
    length = IntegerHelper.getInt(data[pos], data[pos+1]);
    if (length  > 0 && data[pos + 2] == 0)
    {
      errorText = StringHelper.getString(data, length, pos + 3, ws);
      pos += length + 3;
    }
    else if (length  > 0)
    {
      errorText = StringHelper.getUnicodeString(data, length, pos + 3);
      pos += length * 2 + 3;
    }
    else
    {
      pos += 3;
    }
    int formula1Length = IntegerHelper.getInt(data[pos], data[pos+1]);
    pos += 4;
    int formula1Pos = pos;
    pos += formula1Length;
    int formula2Length = IntegerHelper.getInt(data[pos], data[pos+1]);
    pos += 4;
    int formula2Pos = pos;
    pos += formula2Length;
    pos += 2;
    row1 = IntegerHelper.getInt(data[pos], data[pos+1]);
    pos += 2;
    row2 = IntegerHelper.getInt(data[pos], data[pos+1]);
    pos += 2;
    column1 = IntegerHelper.getInt(data[pos], data[pos+1]);
    pos += 2;
    column2 = IntegerHelper.getInt(data[pos], data[pos+1]);
    pos += 2;
    // Do the formulas
    // First, create a temporary  blank cell for any formula relative 
    // references
    EmptyCell tmprt = new EmptyCell(column1, row1);
    if (formula1Length != 0)
    {
      byte[] tokens = new byte[formula1Length];
      System.arraycopy(data, formula1Pos, tokens, 0, formula1Length);
      formula1 = new FormulaParser(tokens, tmprt, es, nt,ws);
      formula1.parse();
    }
    if (formula2Length != 0)
    {
      byte[] tokens = new byte[formula2Length];
      System.arraycopy(data, formula2Pos, tokens, 0, formula2Length);
      formula2 = new FormulaParser(tokens, tmprt, es, nt, ws);
      formula2.parse();
    }
}

Constructor

 public DVParser(int c1,
    int r1,
    int c2,
    int r2) 
{
    type = LIST;
    errorStyle = STOP;
    condition = BETWEEN;
    // the options
    stringListGiven = false;
    emptyCellsAllowed = true;
    suppressArrow = false;
    showPrompt = true;
    showError = true;
    promptTitle = "\0";
    errorTitle = "\0";
    promptText = "\0";
    errorText = "\0";
    StringBuffer formulaString = new StringBuffer();
    CellReferenceHelper.getCellReference(c1,r1,formulaString);
    formulaString.append(':");
    CellReferenceHelper.getCellReference(c2,r2,formulaString);
    formula1String = formulaString.toString();
}

Constructor called when creating a data validation from the API

 public byte[] getData() 
{
    // Compute the length of the data
    byte[] f1Bytes = formula1 != null ? formula1.getBytes() : new byte[0];
    byte[] f2Bytes = formula2 != null ? formula2.getBytes() : new byte[0];
    int dataLength = 
      4 + // the options
      promptTitle.length() * 2 + 2 + // the prompt title
      errorTitle.length() * 2 + 2 + // the error title
      promptText.length() * 2 + 2 + // the prompt text
      errorText.length() * 2 + 2 + // the error text
      f1Bytes.length + 2 + // first formula
      f2Bytes.length + 2 + // second formula
      + 4 + // unused bytes
      10; // cell range
    byte[] data = new byte[dataLength];
    // The position
    int pos = 0;
    // The options
    int options = 0;
    options |= type.getValue();
    options |= errorStyle.getValue() < <  4;
    options |= condition.getValue() < <  20;
    if (stringListGiven) 
    {
      options |= STRING_LIST_GIVEN_MASK;
    }
    if (emptyCellsAllowed) 
    {
      options |= EMPTY_CELLS_ALLOWED_MASK;
    }
    if (suppressArrow)
    {
      options |= SUPPRESS_ARROW_MASK;
    }
    if (showPrompt)
    {
      options |= SHOW_PROMPT_MASK;
    }
    if (showError)
    {
      options |= SHOW_ERROR_MASK;
    }
    // The text
    IntegerHelper.getFourBytes(options, data, pos);
    pos += 4;
    IntegerHelper.getTwoBytes(promptTitle.length(), data, pos);
    pos += 2;
    StringHelper.getUnicodeBytes(promptTitle, data, pos);
    pos += promptTitle.length() * 2;
    IntegerHelper.getTwoBytes(errorTitle.length(), data, pos);
    pos += 2;
    StringHelper.getUnicodeBytes(errorTitle, data, pos);
    pos += errorTitle.length() * 2;
    IntegerHelper.getTwoBytes(promptText.length(), data, pos);
    pos += 2;
    StringHelper.getUnicodeBytes(promptText, data, pos);
    pos += promptText.length() * 2;
    IntegerHelper.getTwoBytes(errorText.length(), data, pos);
    pos += 2;
    StringHelper.getUnicodeBytes(errorText, data, pos);
    pos += errorText.length() * 2;
    // Formula 1
    IntegerHelper.getTwoBytes(f1Bytes.length, data, pos);
    pos += 4;
    System.arraycopy(f1Bytes, 0, data, pos, f1Bytes.length);
    pos += f1Bytes.length;
    // Formula 2
    IntegerHelper.getTwoBytes(f2Bytes.length, data, pos);
    pos += 4;
    System.arraycopy(f2Bytes, 0, data, pos, f2Bytes.length);
    pos += f2Bytes.length;
    // The cell ranges
    IntegerHelper.getTwoBytes(1, data, pos);
    pos += 2;
    IntegerHelper.getTwoBytes(row1, data, pos);
    pos += 2;
    IntegerHelper.getTwoBytes(row2, data, pos);
    pos += 2;
    IntegerHelper.getTwoBytes(column1, data, pos);
    pos += 2;
    IntegerHelper.getTwoBytes(column2, data, pos);
    pos += 2;
    return data;
}

Gets the data

 public int getFirstColumn() 
{
    return column1;
}

Accessor for first column

 public int getFirstRow() 
{
    return row1;
}

Accessor for first row

 public int getLastColumn() 
{
    return column2;
}

Accessor for the last column

 public int getLastRow() 
{
    return row2;
}

Accessor for the last row

 String getValidationFormula() throws FormulaException 
{
    if (type == LIST)
    {
      return formula1.getFormula();
    }
    String s1 = formula1.getFormula();
    String s2 = formula2 != null ? formula2.getFormula() : null;
    return condition.getConditionString(s1, s2) + 
      "; x " + type.getDescription();
}

Gets the formula present in the validation

 public  void insertColumn(int col) 
{
    if (formula1 != null)
    {
      formula1.columnInserted(0, col, true);
    }
    if (formula2 != null)
    {
      formula2.columnInserted(0, col, true);
    }
    if (column1  >= col)
    {
      column1++;
    }
    if (column2  >= col)
    {
      column2++;
    }
}

Inserts a column

 public  void insertRow(int row) 
{
    if (formula1 != null)
    {
      formula1.rowInserted(0, row, true);
    }
    if (formula2 != null)
    {
      formula2.rowInserted(0, row, true);
    }
    if (row1  >= row)
    {
      row1++;
    }
    if (row2  >= row)
    {
      row2++;
    }
}

Inserts a row

 public  void removeColumn(int col) 
{
    if (formula1 != null)
    {
      formula1.columnRemoved(0, col, true);
    }
    if (formula2 != null)
    {
      formula2.columnRemoved(0, col, true);
    }
    if (column1  > col)
    {
      column1--;
    }
    if (column2  >= col)
    {
      column2--;
    }
}

Removes a column

 public  void removeRow(int row) 
{
    if (formula1 != null)
    {
      formula1.rowRemoved(0, row, true);
    }
    if (formula2 != null)
    {
      formula2.rowRemoved(0, row, true);
    }
    if (row1  > row)
    {
      row1--;
    }
    if (row2  >= row)
    {
      row2--;
    }
}

Removes a row

 public  void setCell(int col,
    int row,
    ExternalSheet es,
    WorkbookMethods nt,
    WorkbookSettings ws) throws FormulaException 
{
    row1 = row;
    row2 = row;
    column1 = col;
    column2 = col;
    formula1 = new FormulaParser(formula1String,
                                 es, nt, ws);
    formula1.parse();
    if (formula2String != null)
    {
      formula2 = new FormulaParser(formula2String,
                                   es, nt, ws);
      formula2.parse();
    }
}

Called by the cell value when the cell features are added to the sheet