sc/inc/sharedformula.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  */
   9
  10 #ifndef INCLUDED_SC_INC_SHAREDFORMULA_HXX
  11 #define INCLUDED_SC_INC_SHAREDFORMULA_HXX
  12
  13 #include "formulacell.hxx"
  14 #include "mtvelements.hxx"
  15
  16 #include <vector>
  17
  18 #define USE_FORMULA_GROUP_LISTENER 1
  19
  20 namespace sc {
  21
  22 class StartListeningContext;
  23
  24 class SharedFormulaUtil
  25 {
  26 public:
  27
  28     /**
  29      * Group formula cells stored in the passed container. The formula cells
  30      * in the container are assumed to be all <b>non-shared</b>.
  31      */
  32     template<typename Iter>
  33     static void groupFormulaCells(const Iter& itBeg, const Iter& itEnd)
  34     {
  35         Iter it = itBeg;
  36         ScFormulaCell* pPrev = *it;
  37         ScFormulaCell* pCur = nullptr;
  38         for (++it; it != itEnd; ++it, pPrev = pCur)
  39         {
  40             pCur = *it;
  41             ScFormulaCell::CompareState eState = pCur->CompareByTokenArray(*pPrev);
  42             if (eState == ScFormulaCell::NotEqual)
  43                 continue;
  44
  45             ScFormulaCellGroupRef xGroup = pPrev->GetCellGroup();
  46             if (xGroup)
  47             {
  48                 // Extend the group.
  49                 ++xGroup->mnLength;
  50                 pCur->SetCellGroup(xGroup);
  51                 continue;
  52             }
  53
  54             // Create a new group.
  55             xGroup = pPrev->CreateCellGroup(2, eState == ScFormulaCell::EqualInvariant);
  56             pCur->SetCellGroup(xGroup);
  57         }
  58     }
  59
  60     /** Get shared formula top cell from position, if any, else nullptr. */
  61     static const ScFormulaCell* getSharedTopFormulaCell(const CellStoreType::position_type& aPos);
  62
  63     /**
  64      * Split existing shared formula range at specified position. The cell at
  65      * specified position becomes the top cell of the lower shared formula
  66      * range after this call.  This method does nothing if the cell at
  67      * specified position is not a formula cell.
  68      *
  69      * @param aPos position of cell to examine.
  70      * @param pCxt context to be used, if any, may be nullptr.
  71      *
  72      * @return TRUE if there indeed was a split, else FALSE (e.g. split
  73      *         position was top or bottom cell or no formula group).
  74      */
  75     static bool splitFormulaCellGroup(const CellStoreType::position_type& aPos, sc::EndListeningContext* pCxt);
  76
  77     /**
  78      * Split existing shared formula ranges at specified row positions.
  79      *
  80      * @param rCells cell storage container
  81      * @param rBounds row positions at which to split existing shared formula
  82      *                ranges. Note that this method will directly modify this
  83      *                parameter to sort and remove duplicates.
  84      *
  85      * @return TRUE if there indeed was a split, else FALSE (e.g. split
  86      *         positions were only top or bottom cells or no formula group).
  87      */
  88     static bool splitFormulaCellGroups(CellStoreType& rCells, std::vector<SCROW>& rBounds);
  89
  90     /**
  91      * See if two specified adjacent formula cells can be merged, and if they
  92      * can, merge them into the same group.
  93      *
  94      * @param rPos position object of the first cell
  95      * @param rCell1 first cell
  96      * @param rCell2 second cell located immediately below the first cell.
  97      *
  98      * @return true if the cells are merged, false otherwise.  If the two
  99      *         cells already belong to the same group, it returns false.
 100      */
 101     static bool joinFormulaCells(
 102         const CellStoreType::position_type& rPos, ScFormulaCell& rCell1, ScFormulaCell& rCell2 );
 103     /**
 104      * Merge with an existing formula group (if any) located immediately above
 105      * if the cell at specified position is a formula cell, and its formula
 106      * tokens are identical to that of the above formula group.
 107      *
 108      * @param aPos position of cell to examine.
 109      *
 110      * @return true if the cells are merged, false otherwise.  If the two
 111      *         cells already belong to the same group, it returns false.
 112      */
 113     static bool joinFormulaCellAbove( const CellStoreType::position_type& aPos );
 114
 115     /**
 116      * Turn a shared formula cell into a non-shared one, and split it off from
 117      * the adjacent formula cell groups.
 118      *
 119      * @param aPos position of cell to examine
 120      * @param rCell formula cell instance
 121      */
 122     static void unshareFormulaCell(const CellStoreType::position_type& aPos, ScFormulaCell& rCell);
 123
 124     /**
 125      * Make specified formula cells non-shared ones, and split them off from
 126      * their respective adjacent formula cell groups.
 127      *
 128      * @param rCells cell storage container
 129      * @param rRows row positions at which to unshare formula cells.
 130      */
 131     static void unshareFormulaCells(CellStoreType& rCells, std::vector<SCROW>& rRows);
 132
 133     /**
 134      * Have all formula cells belonging to a group start listening to their
 135      * references.
 136      *
 137      * @param rCxt context object.
 138      * @param ppSharedTop memory position of the pointer of the topmost
 139      *                    formula cell instance in the cell storage.  The
 140      *                    caller is responsible for ensuring that it is indeed
 141      *                    the topmost cell of a shared formula group.
 142      */
 143     static void startListeningAsGroup( StartListeningContext& rCxt, ScFormulaCell** ppSharedTop );
 144 };
 145
 146 }
 147
 148 #endif
 149
 150 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */