File indexing completed on 2025-03-23 03:32:46

 // xlsxcellformula.cpp
 
 #include <QtGlobal>
 #include <QObject>
 #include <QString>
 #include <QXmlStreamReader>
 #include <QXmlStreamWriter>
 #include <QDebug>
 
 #include "xlsxcellformula.h"
 #include "xlsxcellformula_p.h"
 #include "xlsxutility_p.h"
 
 QT_BEGIN_NAMESPACE_XLSX
 
 CellFormulaPrivate::CellFormulaPrivate(const QString &formula_, const CellRange &ref_, CellFormula::FormulaType type_)
     :formula(formula_), type(type_), reference(ref_), ca(false), si(0)
 {
     //Remove the formula '=' sign if exists
     if (formula.startsWith(QLatin1String("=")))
         formula.remove(0,1);
     else if (formula.startsWith(QLatin1String("{=")) && formula.endsWith(QLatin1String("}")))
         formula = formula.mid(2, formula.length()-3);
 }
 
 CellFormulaPrivate::CellFormulaPrivate(const CellFormulaPrivate &other)
     : QSharedData(other)
     , formula(other.formula), type(other.type), reference(other.reference)
     , ca(other.ca), si(other.si)
 {
 
 }
 
 CellFormulaPrivate::~CellFormulaPrivate()
 {
 
 }
 
 /*!
   \class CellFormula
   \inmodule QtXlsx
   \brief The CellFormula class provides a API that is used to handle the cell formula.
 
 */
 
 /*!
   \enum CellFormula::FormulaType
   \value NormalType
   \value ArrayType
   \value DataTableType
   \value SharedType
 */
 
 /*!
  *  Creates a new formula.
  */
 CellFormula::CellFormula()
 {
     //The d pointer is initialized with a null pointer
 }
 
 /*!
  *  Creates a new formula with the given \a formula and \a type.
  */
 CellFormula::CellFormula(const char *formula, FormulaType type)
     :d(new CellFormulaPrivate(QString::fromLatin1(formula), CellRange(), type))
 {
 
 }
 
 /*!
  *  Creates a new formula with the given \a formula and \a type.
  */
 CellFormula::CellFormula(const QString &formula, FormulaType type)
     :d(new CellFormulaPrivate(formula, CellRange(), type))
 {
 
 }
 
 /*!
  *  Creates a new formula with the given \a formula, \a ref and \a type.
  */
 CellFormula::CellFormula(const QString &formula, const CellRange &ref, FormulaType type)
     :d(new CellFormulaPrivate(formula, ref, type))
 {
 
 }
 
 /*!
    Creates a new formula with the same attributes as the \a other formula.
  */
 CellFormula::CellFormula(const CellFormula &other)
     :d(other.d)
 {
 }
 
 /*!
    Assigns the \a other formula to this formula, and returns a
    reference to this formula.
  */
 CellFormula &CellFormula::operator =(const CellFormula &other)
 {
     d = other.d;
     return *this;
 }
 
 /*!
  * Destroys this formula.
  */
 CellFormula::~CellFormula()
 {
 
 }
 
 /*!
  * Returns the type of the formula.
  */
 CellFormula::FormulaType CellFormula::formulaType() const
 {
     return d ? d->type : NormalType;
 }
 
 /*!
  * Returns the contents of the formula.
  */
 QString CellFormula::formulaText() const
 {
     return d ? d->formula : QString();
 }
 
 /*!
  * Returns the reference cells of the formula. For normal formula,
  * this will return an invalid CellRange object.
  */
 CellRange CellFormula::reference() const
 {
     return d ? d->reference : CellRange();
 }
 
 /*!
  * Returns whether the formula is valid.
  */
 bool CellFormula::isValid() const
 {
     return d;
 }
 
 /*!
  * Returns the shared index for shared formula.
  */
 int CellFormula::sharedIndex() const
 {
     return d && d->type == SharedType ? d->si : (-1);
 }
 
 /* aca (Always Calculate Array) // not-implmented attribute
  *
  * Only applies to array formulas.
  *
  * true indicates that the entire array shall be calculated in full.
  * If false the individual cells of the array shall be calculated as needed.
  *
  * The aca value shall be ignored unless the value of the corresponding
  *  t attribute is array.
  *
  *  [Note: The primary case where an array formula must be calculated in
  * part instead of in full is when some cells in the array depend on other
  * cells that are semi-calculated, e.g., contains the function =(). end note]
  *
  *  The possible values for this attribute are defined by the W3C XML Schema
  *  boolean datatype.
  */
 
 /* bx (Assigns Value to Name) // not-implmented attribute
  *
  * Specifies that this formula assigns a value to a name.
  *
  * The possible values for this attribute are defined by the W3C XML
  * Schema boolean datatype.
  */
 
 /* del1 (Input 1 Deleted) // not-implmented attribute
  *
  * Whether the first input cell for data table has been deleted.
  * Applies to data table formula only. Written on master cell of data table
  * formula only.
  *
  * The possible values for this attribute are defined by the W3C XML Schema
  * boolean datatype.
 */
 
 /* del2 (Input 2 Deleted) // not-impplmented attribute
  *
  * Whether the second input cell for data table has been deleted.
  * Applies to data table formula only. Written on master cell of data
  * table formula only.
  *
  * The possible values for this attribute are defined by the W3C XML Schema
  * boolean datatype.
  */
 
 /* dt2D (Data Table 2-D) // not-implmented attribute
  *
  * Data table is two-dimentional. Only applies to the data tables function.
  * Written on master cell of data table formula only.
  *
  * The possible values for this attribute are defined by the W3C XML Schema
  * boolean datatype.
  */
 
 /* dtr (Data Table Row) // not-implmented attribute
  *
  * true if one-dimentional data table is a row, otherwise it's a column.
  * Only applies to the data tables function. Written on master cell of data
  * table formula only.
  *
  * The possible values for this attribute are defined by the W3C XML Schema
  *  boolean datatype.
  */
 
 /* r1 (Data Table Cell 1) // not-implmented attribute
  *
  * First input cell for data table. Only applies to the data tables array
  * function "TABLE()". Written on master cell of data table formula only.
  *
  * The possible values for this attribute are defined by the ST_CellRef
  * simple type (§18.18.7).
  */
 
 /* r2 (Input Cell 2) // not-implmented attribute
  *
  * Second input cell for data table when dt2D is '1'. Only applies to the
  * data tables array function "TABLE()".Written on master cell of data table
  * formula only.
  *
  * The possible values for this attribute are defined by the ST_CellRef
  * simple type (§18.18.7).
  */
 
 /*!
  * \internal
  * \remark pair with loadFromXml()
  */
 bool CellFormula::saveToXml(QXmlStreamWriter &writer) const
 {
 
     // t (Formula Type)
     //
     // Type of formula.
     // The possible values for this attribute are defined by the
     // ST_CellFormulaType simple type (§18.18.6).
     //
     // 18.18.6 ST_CellFormulaType (Formula Type)
     // array (Array Formula)
     // dataTable (Table Formula)
     // normal (Normal)
     // shared (Shared Formula)
 
     QString t;
     switch (d->type)
     {
     case CellFormula::ArrayType:
         t = QStringLiteral("array");
         break;
     case CellFormula::SharedType:
         t = QStringLiteral("shared");
         break;
     case CellFormula::NormalType:
         t = QStringLiteral("normal");
         break;
     case CellFormula::DataTableType:
         t = QStringLiteral("dataTable");
         break;
     default: // undefined type
         return false;
         break;
     }
 
     // f (Formula)
     //
     // Formula for the cell. The formula expression is contained in the
     // character node of this element.
     writer.writeStartElement(QStringLiteral("f"));
 
     if (!t.isEmpty())
     {
         writer.writeAttribute(QStringLiteral("t"), t); // write type(t)
     }
 
     // ref (Range of Cells)
     //
     // Range of cells which the formula applies to.
     // Only required for shared formula, array formula or data table.
     // Only written on the master formula,
     // not subsequent formulas belonging to the same shared group, array,
     // or data table.
     // The possible values for this attribute are defined by the ST_Ref
     // simple type (§18.18.62).
 
     if ( d->type == CellFormula::SharedType ||
          d->type == CellFormula::ArrayType ||
          d->type == CellFormula::DataTableType )
     {
         if (d->reference.isValid())
         {
             writer.writeAttribute(QStringLiteral("ref"), d->reference.toString());
         }
     }
 
     // ca (Calculate Cell)
     //
     // Indicates that this formula needs to be recalculated the next time
     // calculation is performed. [Example: This is always set on volatile
     // functions, like =(), and circular references. end example]
     // The possible values for this attribute are defined by the W3C XML
     // Schema boolean datatype.
     //
     // 3.2.2 boolean
     // 3.2.2.1 Lexical representation
     // An instance of a datatype that is defined as ·boolean· can have the
     // following legal literals {true, false, 1, 0}.
 
     if (d->ca)
     {
         writer.writeAttribute(QStringLiteral("ca"), QStringLiteral("1"));
     }
 
     // si (Shared Group Index)
     // Optional attribute to optimize load performance by sharing formulas.
     //
     // When a formula is a shared formula (t value is shared) then this value
     // indicates the group to which this particular cell's formula belongs. The
     // first formula in a group of shared formulas is saved in the f element.
     // This is considered the 'master' formula cell. Subsequent cells sharing
     // this formula need not have the formula written in their f element.
     // Instead, the attribute si value for a particular cell is used to figure
     // what the formula expression should be based on the cell's relative
     // location to the master formula cell.
 
     if (d->type == CellFormula::SharedType)
     {
         int si = d->si;
         writer.writeAttribute(QStringLiteral("si"), QString::number(si));
     }
 
     if (!d->formula.isEmpty())
     {
         QString strFormula = d->formula;
         writer.writeCharacters(strFormula); // write formula
     }
 
     writer.writeEndElement(); // f
 
     return true;
 }
 
 /*!
  * \internal
  * \remark pair with saveToXml()
  */
 bool CellFormula::loadFromXml(QXmlStreamReader &reader)
 {
     Q_ASSERT(reader.name() == QLatin1String("f"));
     if (!d)
         d = new CellFormulaPrivate(QString(), CellRange(), NormalType);
 
     QXmlStreamAttributes attributes = reader.attributes();
     QString typeString = attributes.value(QLatin1String("t")).toString();
 
     // branch: shared-formula
     //
     if (typeString == QLatin1String("array")) {
         d->type = ArrayType;
     }
     else if (typeString == QLatin1String("shared")) {
         d->type = SharedType;
     }
     else if (typeString == QLatin1String("normal")) {
         d->type = NormalType;
     }
     else if (typeString == QLatin1String("dataTable")) {
         d->type = DataTableType;
     }
     else {
         /*
         // undefined type
         // qDebug() << "Undefined type" << typeString;
         return false;
         // */
 
         // dev40 {{
         // https://github.com/QtExcel/QXlsx/issues/38
         d->type = NormalType; // Change: normal Type is not mentioned in the xml file!!!!!
         // }}
     }
 
     // branch: shared-formula
     //
     // ref (Range of Cells)
     // Range of cells which the formula applies to.
     // Only required for shared formula, array formula or data table.
     if ( d->type == CellFormula::SharedType ||
          d->type == CellFormula::ArrayType ||
          d->type == CellFormula::DataTableType )
     {
         if (attributes.hasAttribute(QLatin1String("ref")))
         {
             QString refString = attributes.value(QLatin1String("ref")).toString();
             d->reference = CellRange(refString);
         }
     }
 
     // branch: shared-formula
     //
     // si (Shared Group Index)
     // Optional attribute to optimize load performance by sharing formulas.
     // When a formula is a shared formula (t value is shared) then this value
     // indicates the group to which this particular cell's formula belongs.
     if ( d->type == CellFormula::SharedType )
     {
         QString ca = attributes.value(QLatin1String("si")).toString();
         d->ca = parseXsdBoolean(ca, false);
 
         if (attributes.hasAttribute(QLatin1String("si")))
         {
             d->si = attributes.value(QLatin1String("si")).toInt();
         }
     }
 
     d->formula = reader.readElementText(); // read formula
 
     return true;
 }
 
 /*!
  * \internal
  */
 bool CellFormula::operator ==(const CellFormula &formula) const
 {
     return d->formula == formula.d->formula && d->type == formula.d->type
             && d->si ==formula.d->si;
 }
 
 /*!
  * \internal
  */
 bool CellFormula::operator !=(const CellFormula &formula) const
 {
     return d->formula != formula.d->formula || d->type != formula.d->type
             || d->si !=formula.d->si;
 }
 
 QT_END_NAMESPACE_XLSX