/* -*- Mode: C++; c-default-style: "k&r"; indent-tabs-mode: nil; tab-width: 2; c-basic-offset: 2 -*- */

/* libstaroffice

* Version: MPL 2.0 / LGPLv2+

*

* The contents of this file are subject to the Mozilla Public License Version

* 2.0 (the "License"); you may not use this file except in compliance with

* the License or as specified alternatively below. You may obtain a copy of

* the License at http://www.mozilla.org/MPL/

*

* Software distributed under the License is distributed on an "AS IS" basis,

* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License

* for the specific language governing rights and limitations under the

* License.

*

* Major Contributor(s):

* Copyright (C) 2002 William Lachance (wrlach@gmail.com)

* Copyright (C) 2002,2004 Marc Maurer (uwog@uwog.net)

* Copyright (C) 2004-2006 Fridrich Strba (fridrich.strba@bluewin.ch)

* Copyright (C) 2006, 2007 Andrew Ziem

* Copyright (C) 2011, 2012 Alonso Laurent (alonso@loria.fr)

*

*

* All Rights Reserved.

*

* For minor contributions see the git repository.

*

* Alternatively, the contents of this file may be used under the terms of

* the GNU Lesser General Public License Version 2 or later (the "LGPLv2+"),

* in which case the provisions of the LGPLv2+ are applicable

* instead of those above.

*/

/** \file STOFFCell.hxx

 * Defines STOFFCell (cell content and format)

 */

#ifndef STOFF_CELL_H

#  define STOFF_CELL_H

#include <string>

#include <vector>

#include "libstaroffice_internal.hxx"

#include "STOFFEntry.hxx"

#include "STOFFFont.hxx"

#include "STOFFCellStyle.hxx"

class STOFFTable;

/** a structure used to define a cell and its format */

class STOFFCell

{

public:

  /** the different format of a cell's content */

  enum FormatType { F_TEXT, F_BOOLEAN, F_NUMBER, F_DATE, F_TIME, F_DATETIME, F_UNKNOWN };

  /** the different number format of a cell's content */

  enum NumberType { F_NUMBER_CURRENCY, F_NUMBER_DECIMAL, F_NUMBER_FRACTION, F_NUMBER_GENERIC, F_NUMBER_SCIENTIFIC, F_NUMBER_PERCENT, F_NUMBER_UNKNOWN };

  /** a structure uses to define the format of a cell content */

  struct Format {

    //! constructor

    Format()

      : m_format(F_UNKNOWN)

      , m_numberFormat(F_NUMBER_UNKNOWN)

    {

    }

    //! destructor

    virtual ~Format();

    //! returns true if this is a basic format style

    bool hasBasicFormat() const

    {

      return m_format==F_TEXT || m_format==F_UNKNOWN;

    }

    //! returns a value type

    std::string getValueType() const;

    //! convert a DTFormat in a propertyList

    static bool convertDTFormat(std::string const &dtFormat, librevenge::RVNGPropertyListVector &propListVector);

    //! operator<<

    friend std::ostream &operator<<(std::ostream &o, Format const &format);

    //! the cell format : by default unknown

    FormatType m_format;

    //! the numeric format

    NumberType m_numberFormat;

  };

  //! constructor

  STOFFCell()

    : m_position(0,0)

    , m_bdBox()

    , m_bdSize()

    , m_format()

    , m_font()

    , m_cellStyle()

    , m_numberingStyle() { }

  //! destructor

  virtual ~STOFFCell() {}

  /** adds to the propList*/

  void addTo(librevenge::RVNGPropertyList &propList) const;

  //! operator<<

  friend std::ostream &operator<<(std::ostream &o, STOFFCell const &cell);

  // interface with STOFFTable:

  /** function called when a cell is send by STOFFTable to send a cell to a

      listener.

      By default: calls openTableCell(*this), sendContent and then closeTableCell() */

  virtual bool send(STOFFListenerPtr listener, STOFFTable &table);

  /** function called when the content of a cell must be send to the listener,

      ie. when STOFFTable::sendTable or STOFFTable::sendAsText is called.

      \note default behavior: does nothing and prints an error in debug mode.*/

  virtual bool sendContent(STOFFListenerPtr listener, STOFFTable &table);

  // position

  //! position  accessor

  STOFFVec2i const &position() const

  {

    return m_position;

  }

  //! set the cell positions :  0,0 -> A1, 0,1 -> A2

  void setPosition(STOFFVec2i posi)

  {

    m_position = posi;

  }

  //! bdbox  accessor

  STOFFBox2f const &bdBox() const

  {

    return m_bdBox;

  }

  //! set the bdbox (unit point)

  void setBdBox(STOFFBox2f box)

  {

    m_bdBox = box;

  }

  //! bdbox size accessor

  STOFFVec2f const &bdSize() const

  {

    return m_bdSize;

  }

  //! set the bdbox size(unit point)

  void setBdSize(STOFFVec2f sz)

  {

    m_bdSize = sz;

  }

  //! return the name of a cell (given row and column) : 0,0 -> A1, 0,1 -> A2

  static std::string getCellName(STOFFVec2i const &pos, STOFFVec2b const &absolute);

  //! return the column name

  static std::string getColumnName(int col);

  // format

  //! returns the cell format

  Format const &getFormat() const

  {

    return m_format;

  }

  //! set the cell format

  void setFormat(Format const &format)

  {

    m_format=format;

  }

  //! returns the font

  STOFFFont const &getFont() const

  {

    return m_font;

  }

  //! set the font

  void setFont(STOFFFont const &font)

  {

    m_font=font;

  }

  //! returns the cell style

  STOFFCellStyle const &getCellStyle() const

  {

    return m_cellStyle;

  }

  //! returns the cell style

  STOFFCellStyle &getCellStyle()

  {

    return m_cellStyle;

  }

  //! set the cell style

  void setCellStyle(STOFFCellStyle const &cellStyle)

  {

    m_cellStyle=cellStyle;

  }

  //! returns the numbering style

  librevenge::RVNGPropertyList const &getNumberingStyle() const

  {

    return m_numberingStyle;

  }

  //! returns the numbering style

  librevenge::RVNGPropertyList &getNumberingStyle()

  {

    return m_numberingStyle;

  }

  //! set the numbering style

  void setNumberingStyle(librevenge::RVNGPropertyList const &numberStyle)

  {

    m_numberingStyle=numberStyle;

  }

protected:

  //! the cell row and column : 0,0 -> A1, 0,1 -> A2

  STOFFVec2i m_position;

  /** the cell bounding box (unit in point)*/

  STOFFBox2f m_bdBox;

  /** the cell bounding size : unit point */

  STOFFVec2f m_bdSize;

  //! the cell format

  Format m_format;

  //! the cell font

  STOFFFont m_font;

  //! the cell cell style

  STOFFCellStyle m_cellStyle;

  //! the numbering style

  librevenge::RVNGPropertyList m_numberingStyle;

};

//! small class use to define a sheet cell content

class STOFFCellContent

{

public:

  //! small class use to define a formula instruction

  struct FormulaInstruction {

    enum Type { F_None, F_Operator, F_Function, F_Cell, F_CellList, F_Index, F_Long, F_Double, F_Text };

    //! constructor

    FormulaInstruction() : m_type(F_None), m_content(""), m_longValue(0), m_doubleValue(0), m_sheet(""),

      m_sheetId(-1), m_sheetIdRelative(false), m_extra("")

    {

      for (int i=0; i<2; ++i) {

        m_position[i]=STOFFVec2i(0,0);

        m_positionRelative[i]=STOFFVec2b(false,false);

      }

    }

    /** returns a proplist corresponding to a instruction */

    librevenge::RVNGPropertyList getPropertyList() const;

    //! operator<<

    friend std::ostream &operator<<(std::ostream &o, FormulaInstruction const &inst);

    //! the type

    Type m_type;

    //! the content ( if type == F_Operator or type = F_Function or type==F_Text)

    librevenge::RVNGString m_content;

    //! value ( if type==F_Long )

    long m_longValue;

    //! value ( if type==F_Double )

    double m_doubleValue;

    //! cell position ( if type==F_Cell or F_CellList )

    STOFFVec2i m_position[2];

    //! relative cell position ( if type==F_Cell or F_CellList )

    STOFFVec2b m_positionRelative[2];

    //! the sheet name (if not empty)

    librevenge::RVNGString m_sheet;

    //! the sheet id (if set)

    int m_sheetId;

    //! the sheet id relative flag

    bool m_sheetIdRelative;

    //! extra data

    std::string m_extra;

  };

  /** the different types of cell's field */

  enum Type { C_NONE, C_TEXT, C_TEXT_BASIC, C_NUMBER, C_FORMULA, C_UNKNOWN };

  /// constructor

  STOFFCellContent() : m_contentType(C_UNKNOWN), m_value(0.0), m_valueSet(false), m_text(), m_formula() { }

  /// destructor

  ~STOFFCellContent() {}

  //! operator<<

  friend std::ostream &operator<<(std::ostream &o, STOFFCellContent const &cell);

  //! returns true if the cell has no content

  bool empty() const

  {

    if (m_contentType == C_NUMBER || m_contentType == C_TEXT) return false;

    if (m_contentType == C_TEXT_BASIC && !m_text.empty()) return false;

    if (m_contentType == C_FORMULA && (m_formula.size() || isValueSet())) return false;

    return true;

  }

  //! sets the double value

  void setValue(double value)

  {

    m_value = value;

    m_valueSet = true;

  }

  //! returns true if the value has been setted

  bool isValueSet() const

  {

    return m_valueSet;

  }

  //! returns true if the text is set

  bool hasText() const

  {

    return m_contentType == C_TEXT || !m_text.empty();

  }

  /** conversion beetween double days since 1900 and a date, ie val=0

      corresponds to 1/1/1900, val=365 to 1/1/1901, ... */

  static bool double2Date(double val, int &Y, int &M, int &D);

  /** conversion beetween double: second since 0:00 and time */

  static bool double2Time(double val, int &H, int &M, int &S);

  /** conversion beetween date and double days since 1900 date */

  static bool date2Double(int Y, int M, int D, double &val);

  //! the content type ( by default unknown )

  Type m_contentType;

  //! the cell value

  double m_value;

  //! true if the value has been set

  bool m_valueSet;

  //! the text value (for C_TEXT_BASIC)

  std::vector<uint32_t> m_text;

  //! the formula list of instruction

  std::vector<FormulaInstruction> m_formula;

};

#endif

// vim: set filetype=cpp tabstop=2 shiftwidth=2 cindent autoindent smartindent noexpandtab: