MWAWCell.hxx

Go to the documentation of this file.

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

/* libmwaw
* 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.
*/

#ifndef MWAW_CELL_H
#  define MWAW_CELL_H

#include <string>
#include <vector>

#include "libmwaw_internal.hxx"

#include "MWAWEntry.hxx"
#include "MWAWFont.hxx"

class MWAWTable;

class MWAWCell
{
public:
  enum FormatType { F_TEXT, F_BOOLEAN, F_NUMBER, F_DATE, F_TIME, F_UNKNOWN };
  enum NumberType { F_NUMBER_CURRENCY, F_NUMBER_DECIMAL, F_NUMBER_FRACTION, F_NUMBER_GENERIC, F_NUMBER_SCIENTIFIC, F_NUMBER_PERCENT, F_NUMBER_UNKNOWN };
  struct Format {
    Format() : m_format(F_UNKNOWN), m_numberFormat(F_NUMBER_UNKNOWN), m_digits(-1), m_integerDigits(-1), m_numeratorDigits(-1), m_denominatorDigits(-1),
      m_thousandHasSeparator(false), m_parenthesesForNegative(false), m_currencySymbol("$"), m_DTFormat("")
    {
    }
    virtual ~Format() {}
    bool hasBasicFormat() const
    {
      return m_format==F_TEXT || m_format==F_UNKNOWN;
    }
    std::string getValueType() const;
    bool getNumberingProperties(librevenge::RVNGPropertyList &propList) const;
    static bool convertDTFormat(std::string const &dtFormat, librevenge::RVNGPropertyListVector &propListVector);
    friend std::ostream &operator<<(std::ostream &o, Format const &format);
    int compare(Format const &format) const;

    FormatType m_format;
    NumberType m_numberFormat;
    int m_digits;
    int m_integerDigits;
    int m_numeratorDigits;
    int m_denominatorDigits;
    bool m_thousandHasSeparator;
    bool m_parenthesesForNegative;
    std::string m_currencySymbol;
    std::string m_DTFormat;
  };
  struct CompareFormat {
    CompareFormat() {}
    bool operator()(Format const &c1, Format const &c2) const
    {
      return c1.compare(c2) < 0;
    }
  };
  enum HorizontalAlignment { HALIGN_LEFT, HALIGN_RIGHT, HALIGN_CENTER,
                             HALIGN_FULL, HALIGN_DEFAULT
                           };

  enum VerticalAlignment { VALIGN_TOP, VALIGN_CENTER, VALIGN_BOTTOM, VALIGN_DEFAULT };

  enum ExtraLine { E_None, E_Line1, E_Line2, E_Cross };

  MWAWCell() : m_position(0,0), m_numberCellSpanned(1,1), m_bdBox(),  m_bdSize(),
    m_format(), m_font(3,12), m_fontSet(false), m_hAlign(HALIGN_DEFAULT), m_vAlign(VALIGN_DEFAULT),
    m_backgroundColor(MWAWColor::white()), m_protected(false),
    m_bordersList(), m_extraLine(E_None), m_extraLineType() { }

  virtual ~MWAWCell() {}

  void addTo(librevenge::RVNGPropertyList &propList, shared_ptr<MWAWFontConverter> fontConverter) const;

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

  // interface with MWAWTable:

  virtual bool send(MWAWListenerPtr listener, MWAWTable &table);
  virtual bool sendContent(MWAWListenerPtr listener, MWAWTable &table);

  // position

  MWAWVec2i const &position() const
  {
    return m_position;
  }
  void setPosition(MWAWVec2i posi)
  {
    m_position = posi;
  }

  MWAWVec2i const &numSpannedCells() const
  {
    return m_numberCellSpanned;
  }
  void setNumSpannedCells(MWAWVec2i numSpanned)
  {
    m_numberCellSpanned=numSpanned;
  }

  MWAWBox2f const &bdBox() const
  {
    return m_bdBox;
  }
  void setBdBox(MWAWBox2f box)
  {
    m_bdBox = box;
  }

  MWAWVec2f const &bdSize() const
  {
    return m_bdSize;
  }
  void setBdSize(MWAWVec2f sz)
  {
    m_bdSize = sz;
  }

  static std::string getCellName(MWAWVec2i const &pos, MWAWVec2b const &absolute);

  static std::string getColumnName(int col);

  // format

  Format const &getFormat() const
  {
    return m_format;
  }
  void setFormat(Format const &format)
  {
    m_format=format;
  }

  bool isFontSet() const
  {
    return m_fontSet;
  }
  MWAWFont getFont() const
  {
    return m_font;
  }
  void setFont(MWAWFont const &font, bool isDefault=false)
  {
    m_font=font;
    m_fontSet=!isDefault;
  }

  bool isProtected() const
  {
    return m_protected;
  }
  void setProtected(bool fl)
  {
    m_protected = fl;
  }

  HorizontalAlignment hAlignment() const
  {
    return m_hAlign;
  }
  void setHAlignment(HorizontalAlignment align)
  {
    m_hAlign = align;
  }

  VerticalAlignment vAlignment() const
  {
    return m_vAlign;
  }
  void setVAlignment(VerticalAlignment align)
  {
    m_vAlign = align;
  }

  bool hasBorders() const
  {
    return m_bordersList.size() != 0;
  }
  std::vector<MWAWBorder> const &borders() const
  {
    return m_bordersList;
  }

  void resetBorders()
  {
    m_bordersList.resize(0);
  }
  void setBorders(int wh, MWAWBorder const &border);

  MWAWColor backgroundColor() const
  {
    return m_backgroundColor;
  }
  void setBackgroundColor(MWAWColor color)
  {
    m_backgroundColor = color;
  }
  bool hasExtraLine() const
  {
    return m_extraLine!=E_None && !m_extraLineType.isEmpty();
  }
  ExtraLine extraLine() const
  {
    return m_extraLine;
  }
  MWAWBorder const &extraLineType() const
  {
    return m_extraLineType;
  }
  void setExtraLine(ExtraLine extrLine, MWAWBorder const &type=MWAWBorder())
  {
    m_extraLine = extrLine;
    m_extraLineType=type;
  }
protected:
  MWAWVec2i m_position;
  MWAWVec2i m_numberCellSpanned;
  MWAWBox2f m_bdBox;
  MWAWVec2f m_bdSize;

  Format m_format;
  MWAWFont m_font;
  bool m_fontSet;
  HorizontalAlignment m_hAlign;
  VerticalAlignment m_vAlign;
  MWAWColor m_backgroundColor;
  bool m_protected;

  std::vector<MWAWBorder> m_bordersList;
  ExtraLine m_extraLine;
  MWAWBorder m_extraLineType;
};

class MWAWCellContent
{
public:
  struct FormulaInstruction {
    enum Type { F_Operator, F_Function, F_Cell, F_CellList, F_Long, F_Double, F_Text };
    FormulaInstruction() : m_type(F_Text), m_content(""), m_longValue(0), m_doubleValue(0), m_sheet("")
    {
      for (int i=0; i<2; ++i) {
        m_position[i]=MWAWVec2i(0,0);
        m_positionRelative[i]=MWAWVec2b(false,false);
      }
    }
    librevenge::RVNGPropertyList getPropertyList(MWAWFontConverter &fontConverter, int fontId) const;
    friend std::ostream &operator<<(std::ostream &o, FormulaInstruction const &inst);
    Type m_type;
    std::string m_content;
    double m_longValue;
    double m_doubleValue;
    MWAWVec2i m_position[2];
    MWAWVec2b m_positionRelative[2];
    std::string m_sheet;
  };

  enum Type { C_NONE, C_TEXT, C_NUMBER, C_FORMULA, C_UNKNOWN };
  MWAWCellContent() : m_contentType(C_UNKNOWN), m_value(0.0), m_valueSet(false), m_textEntry(), m_formula() { }
  ~MWAWCellContent() {}
  friend std::ostream &operator<<(std::ostream &o, MWAWCellContent const &cell);

  bool empty() const
  {
    if (m_contentType == C_NUMBER) return false;
    if (m_contentType == C_TEXT && m_textEntry.valid()) return false;
    if (m_contentType == C_FORMULA && (m_formula.size() || isValueSet())) return false;
    return true;
  }
  void setValue(double value)
  {
    m_value = value;
    m_valueSet = true;
  }
  bool isValueSet() const
  {
    return m_valueSet;
  }
  bool hasText() const
  {
    return m_textEntry.valid();
  }
  static bool double2Date(double val, int &Y, int &M, int &D);
  static bool double2Time(double val, int &H, int &M, int &S);
  static bool double2String(double val, MWAWCell::Format const &format, std::string &str);
  static bool date2Double(int Y, int M, int D, double &val);
  Type m_contentType;
  double m_value;
  bool m_valueSet;
  MWAWEntry m_textEntry;
  std::vector<FormulaInstruction> m_formula;
};

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