diff options
Diffstat (limited to 'formula/source')
| -rw-r--r-- | formula/source/core/api/FormulaCompiler.cxx | 3105 | ||||
| -rw-r--r-- | formula/source/core/api/FormulaOpCodeMapperObj.cxx | 104 | ||||
| -rw-r--r-- | formula/source/core/api/grammar.cxx | 87 | ||||
| -rw-r--r-- | formula/source/core/api/token.cxx | 2032 | ||||
| -rw-r--r-- | formula/source/core/api/vectortoken.cxx | 109 | ||||
| -rw-r--r-- | formula/source/core/resource/core_resource.cxx | 23 | ||||
| -rw-r--r-- | formula/source/ui/dlg/ControlHelper.hxx | 106 | ||||
| -rw-r--r-- | formula/source/ui/dlg/FormulaHelper.cxx | 417 | ||||
| -rw-r--r-- | formula/source/ui/dlg/formula.cxx | 1960 | ||||
| -rw-r--r-- | formula/source/ui/dlg/funcpage.cxx | 257 | ||||
| -rw-r--r-- | formula/source/ui/dlg/funcpage.hxx | 87 | ||||
| -rw-r--r-- | formula/source/ui/dlg/funcutl.cxx | 486 | ||||
| -rw-r--r-- | formula/source/ui/dlg/parawin.cxx | 600 | ||||
| -rw-r--r-- | formula/source/ui/dlg/parawin.hxx | 145 | ||||
| -rw-r--r-- | formula/source/ui/dlg/structpg.cxx | 154 | ||||
| -rw-r--r-- | formula/source/ui/dlg/structpg.hxx | 74 |
16 files changed, 9746 insertions, 0 deletions
diff --git a/formula/source/core/api/FormulaCompiler.cxx b/formula/source/core/api/FormulaCompiler.cxx new file mode 100644 index 000000000..b39e618a5 --- /dev/null +++ b/formula/source/core/api/FormulaCompiler.cxx @@ -0,0 +1,3105 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ +#include <sal/macros.h> +#include <sal/log.hxx> +#include <rtl/math.hxx> +#include <formula/FormulaCompiler.hxx> +#include <formula/errorcodes.hxx> +#include <formula/token.hxx> +#include <formula/tokenarray.hxx> +#include <o3tl/string_view.hxx> +#include <core_resource.hxx> +#include <core_resource.hrc> + +#include <osl/mutex.hxx> + +#include <svl/zforlist.hxx> +#include <unotools/charclass.hxx> +#include <vcl/svapp.hxx> +#include <vcl/settings.hxx> +#include <comphelper/processfactory.hxx> +#include <com/sun/star/sheet/FormulaOpCodeMapEntry.hpp> +#include <com/sun/star/sheet/FormulaMapGroup.hpp> +#include <com/sun/star/sheet/FormulaMapGroupSpecialOffset.hpp> +#include <algorithm> + +namespace formula +{ + using namespace ::com::sun::star; + + static const char* pInternal[2] = { "TTT", "__DEBUG_VAR" }; + +namespace { + +class FormulaCompilerRecursionGuard +{ + private: + short& rRecursion; + public: + explicit FormulaCompilerRecursionGuard( short& rRec ) + : rRecursion( rRec ) { ++rRecursion; } + ~FormulaCompilerRecursionGuard() { --rRecursion; } +}; + +SvNumFormatType lcl_GetRetFormat( OpCode eOpCode ) +{ + switch (eOpCode) + { + case ocEqual: + case ocNotEqual: + case ocLess: + case ocGreater: + case ocLessEqual: + case ocGreaterEqual: + case ocAnd: + case ocOr: + case ocXor: + case ocNot: + case ocTrue: + case ocFalse: + case ocIsEmpty: + case ocIsString: + case ocIsNonString: + case ocIsLogical: + case ocIsRef: + case ocIsValue: + case ocIsFormula: + case ocIsNA: + case ocIsErr: + case ocIsError: + case ocIsEven: + case ocIsOdd: + case ocExact: + return SvNumFormatType::LOGICAL; + case ocGetActDate: + case ocGetDate: + case ocEasterSunday : + return SvNumFormatType::DATE; + case ocGetActTime: + return SvNumFormatType::DATETIME; + case ocGetTime: + return SvNumFormatType::TIME; + case ocNPV: + case ocPV: + case ocSYD: + case ocDDB: + case ocDB: + case ocVBD: + case ocSLN: + case ocPMT: + case ocFV: + case ocIpmt: + case ocPpmt: + case ocCumIpmt: + case ocCumPrinc: + return SvNumFormatType::CURRENCY; + case ocRate: + case ocIRR: + case ocMIRR: + case ocRRI: + case ocEffect: + case ocNominal: + case ocPercentSign: + return SvNumFormatType::PERCENT; + default: + return SvNumFormatType::NUMBER; + } +} + +void lclPushOpCodeMapEntry( ::std::vector< sheet::FormulaOpCodeMapEntry >& rVec, + const OUString* pTable, sal_uInt16 nOpCode ) +{ + sheet::FormulaOpCodeMapEntry aEntry; + aEntry.Token.OpCode = nOpCode; + aEntry.Name = pTable[nOpCode]; + rVec.push_back( aEntry); +} + +void lclPushOpCodeMapEntries( ::std::vector< sheet::FormulaOpCodeMapEntry >& rVec, + const OUString* pTable, sal_uInt16 nOpCodeBeg, sal_uInt16 nOpCodeEnd ) +{ + for (sal_uInt16 nOpCode = nOpCodeBeg; nOpCode < nOpCodeEnd; ++nOpCode) + lclPushOpCodeMapEntry( rVec, pTable, nOpCode ); +} + +void lclPushOpCodeMapEntries( ::std::vector< sheet::FormulaOpCodeMapEntry >& rVec, + const OUString* pTable, const sal_uInt16* pnOpCodes, size_t nCount ) +{ + for (const sal_uInt16* pnEnd = pnOpCodes + nCount; pnOpCodes < pnEnd; ++pnOpCodes) + lclPushOpCodeMapEntry( rVec, pTable, *pnOpCodes ); +} + +CharClass* createCharClassIfNonEnglishUI() +{ + const LanguageTag& rLanguageTag( Application::GetSettings().GetUILanguageTag()); + if (rLanguageTag.getLanguage() == "en") + return nullptr; + return new CharClass( ::comphelper::getProcessComponentContext(), rLanguageTag); +} + +class OpCodeList +{ +public: + + OpCodeList(const std::pair<const char*, int>* pSymbols, const FormulaCompiler::NonConstOpCodeMapPtr&, + FormulaCompiler::SeparatorType = FormulaCompiler::SeparatorType::SEMICOLON_BASE ); + OpCodeList(const std::pair<TranslateId, int>* pSymbols, const FormulaCompiler::NonConstOpCodeMapPtr&, + FormulaCompiler::SeparatorType = FormulaCompiler::SeparatorType::SEMICOLON_BASE ); + +private: + bool getOpCodeString( OUString& rStr, sal_uInt16 nOp ); + void putDefaultOpCode( const FormulaCompiler::NonConstOpCodeMapPtr& xMap, sal_uInt16 nOp, const CharClass* pCharClass ); + +private: + FormulaCompiler::SeparatorType meSepType; + const std::pair<const char*, int>* mpSymbols1; + const std::pair<TranslateId, int>* mpSymbols2; +}; + +OpCodeList::OpCodeList(const std::pair<const char*, int>* pSymbols, const FormulaCompiler::NonConstOpCodeMapPtr& xMap, + FormulaCompiler::SeparatorType eSepType) + : meSepType(eSepType) + , mpSymbols1(pSymbols) + , mpSymbols2(nullptr) +{ + std::unique_ptr<CharClass> xCharClass( xMap->isEnglish() ? nullptr : createCharClassIfNonEnglishUI()); + const CharClass* pCharClass = xCharClass.get(); + if (meSepType == FormulaCompiler::SeparatorType::RESOURCE_BASE) + { + for (sal_uInt16 i = 0; i <= SC_OPCODE_LAST_OPCODE_ID; ++i) + { + putDefaultOpCode( xMap, i, pCharClass); + } + } + else + { + for (sal_uInt16 i = 0; i <= SC_OPCODE_LAST_OPCODE_ID; ++i) + { + OUString aOpStr; + if ( getOpCodeString( aOpStr, i) ) + xMap->putOpCode( aOpStr, OpCode(i), pCharClass); + else + putDefaultOpCode( xMap, i, pCharClass); + } + } +} + +OpCodeList::OpCodeList(const std::pair<TranslateId, int>* pSymbols, const FormulaCompiler::NonConstOpCodeMapPtr& xMap, + FormulaCompiler::SeparatorType eSepType) + : meSepType(eSepType) + , mpSymbols1(nullptr) + , mpSymbols2(pSymbols) +{ + std::unique_ptr<CharClass> xCharClass( xMap->isEnglish() ? nullptr : createCharClassIfNonEnglishUI()); + const CharClass* pCharClass = xCharClass.get(); + if (meSepType == FormulaCompiler::SeparatorType::RESOURCE_BASE) + { + for (sal_uInt16 i = 0; i <= SC_OPCODE_LAST_OPCODE_ID; ++i) + { + putDefaultOpCode( xMap, i, pCharClass); + } + } + else + { + for (sal_uInt16 i = 0; i <= SC_OPCODE_LAST_OPCODE_ID; ++i) + { + OUString aOpStr; + if ( getOpCodeString( aOpStr, i) ) + xMap->putOpCode( aOpStr, OpCode(i), pCharClass); + else + putDefaultOpCode( xMap, i, pCharClass); + } + } +} + +bool OpCodeList::getOpCodeString( OUString& rStr, sal_uInt16 nOp ) +{ + switch (nOp) + { + case SC_OPCODE_SEP: + { + if (meSepType == FormulaCompiler::SeparatorType::SEMICOLON_BASE) + { + rStr = ";"; + return true; + } + } + break; + case SC_OPCODE_ARRAY_COL_SEP: + { + if (meSepType == FormulaCompiler::SeparatorType::SEMICOLON_BASE) + { + rStr = ";"; + return true; + } + } + break; + case SC_OPCODE_ARRAY_ROW_SEP: + { + if (meSepType == FormulaCompiler::SeparatorType::SEMICOLON_BASE) + { + rStr = "|"; + return true; + } + } + break; + } + + return false; +} + +void OpCodeList::putDefaultOpCode( const FormulaCompiler::NonConstOpCodeMapPtr& xMap, sal_uInt16 nOp, + const CharClass* pCharClass ) +{ + OUString sKey; + if (mpSymbols1) + { + const char* pKey = nullptr; + for (const std::pair<const char*, int>* pSymbol = mpSymbols1; pSymbol->first; ++pSymbol) + { + if (nOp == pSymbol->second) + { + pKey = pSymbol->first; + break; + } + } + if (!pKey) + return; + sKey = OUString::createFromAscii(pKey); + } + else if (mpSymbols2) + { + TranslateId pKey; + for (const std::pair<TranslateId, int>* pSymbol = mpSymbols2; pSymbol->first; ++pSymbol) + { + if (nOp == pSymbol->second) + { + pKey = pSymbol->first; + break; + } + } + if (!pKey) + return; + sKey = ForResId(pKey); + } + xMap->putOpCode(sKey, OpCode(nOp), pCharClass); +} + +// static +const sal_Unicode* lcl_UnicodeStrChr( const sal_Unicode* pStr, sal_Unicode c ) +{ + if ( !pStr ) + return nullptr; + while ( *pStr ) + { + if ( *pStr == c ) + return pStr; + pStr++; + } + return nullptr; +} + +struct OpCodeMapData +{ + FormulaCompiler::NonConstOpCodeMapPtr mxSymbolMap; + osl::Mutex maMtx; +}; + + +bool isPotentialRangeLeftOp( OpCode eOp ) +{ + switch (eOp) + { + case ocClose: + return true; + default: + return false; + } +} + +bool isRangeResultFunction( OpCode eOp ) +{ + switch (eOp) + { + case ocIndirect: + case ocOffset: + return true; + default: + return false; + } +} + +bool isRangeResultOpCode( OpCode eOp ) +{ + switch (eOp) + { + case ocRange: + case ocUnion: + case ocIntersect: + case ocIndirect: + case ocOffset: + return true; + default: + return false; + } +} + +/** + @param pToken + MUST be a valid token, caller has to ensure. + + @param bRight + If bRPN==false, bRight==false means opcodes for left side are + checked, bRight==true means opcodes for right side. If bRPN==true + it doesn't matter except for the ocSep converted to ocUnion case. + */ +bool isPotentialRangeType( FormulaToken const * pToken, bool bRPN, bool bRight ) +{ + switch (pToken->GetType()) + { + case svByte: // could be range result, but only a few + if (bRPN) + return isRangeResultOpCode( pToken->GetOpCode()); + else if (bRight) + return isRangeResultFunction( pToken->GetOpCode()); + else + return isPotentialRangeLeftOp( pToken->GetOpCode()); + case svSingleRef: + case svDoubleRef: + case svIndex: // could be range + //case svRefList: // um..what? + case svExternalSingleRef: + case svExternalDoubleRef: + case svExternalName: // could be range + return true; + case svSep: + // A special case if a previous ocSep was converted to ocUnion it + // stays svSep instead of svByte. + return bRPN && !bRight && pToken->GetOpCode() == ocUnion; + default: + // Separators are not part of RPN and right opcodes need to be + // other StackVar types or functions and thus svByte. + return !bRPN && !bRight && isPotentialRangeLeftOp( pToken->GetOpCode()); + } +} + +bool isIntersectable( FormulaToken** pCode1, FormulaToken** pCode2 ) +{ + FormulaToken* pToken1 = *pCode1; + FormulaToken* pToken2 = *pCode2; + if (pToken1 && pToken2) + return isPotentialRangeType( pToken1, true, false) && isPotentialRangeType( pToken2, true, true); + return false; +} + +bool isAdjacentRpnEnd( sal_uInt16 nPC, + FormulaToken const * const * const pCode, + FormulaToken const * const * const pCode1, + FormulaToken const * const * const pCode2 ) +{ + return nPC >= 2 && pCode1 && pCode2 && + (pCode2 - pCode1 == 1) && (pCode - pCode2 == 1) && + (*pCode1 != nullptr) && (*pCode2 != nullptr); +} + +bool isAdjacentOrGapRpnEnd( sal_uInt16 nPC, + FormulaToken const * const * const pCode, + FormulaToken const * const * const pCode1, + FormulaToken const * const * const pCode2 ) +{ + return nPC >= 2 && pCode1 && pCode2 && + (pCode2 > pCode1) && (pCode - pCode2 == 1) && + (*pCode1 != nullptr) && (*pCode2 != nullptr); +} + + +} // namespace + + +void FormulaCompiler::OpCodeMap::putExternal( const OUString & rSymbol, const OUString & rAddIn ) +{ + // Different symbols may map to the same AddIn, but the same AddIn may not + // map to different symbols, the first pair wins. Same symbol of course may + // not map to different AddIns, again the first pair wins and also the + // AddIn->symbol mapping is not inserted in other cases. + bool bOk = maExternalHashMap.emplace(rSymbol, rAddIn).second; + SAL_WARN_IF( !bOk, "formula.core", "OpCodeMap::putExternal: symbol not inserted, " << rSymbol << " -> " << rAddIn); + if (bOk) + { + bOk = maReverseExternalHashMap.emplace(rAddIn, rSymbol).second; + // Failed insertion of the AddIn is ok for different symbols mapping to + // the same AddIn. Make this INFO only. + SAL_INFO_IF( !bOk, "formula.core", "OpCodeMap::putExternal: AddIn not inserted, " << rAddIn << " -> " << rSymbol); + } +} + +void FormulaCompiler::OpCodeMap::putExternalSoftly( const OUString & rSymbol, const OUString & rAddIn ) +{ + // Same as putExternal() but no warning, instead info whether inserted or not. + bool bOk = maExternalHashMap.emplace(rSymbol, rAddIn).second; + SAL_INFO( "formula.core", "OpCodeMap::putExternalSoftly: symbol " << (bOk ? "" : "not ") << "inserted, " << rSymbol << " -> " << rAddIn); + if (bOk) + { + bOk = maReverseExternalHashMap.emplace(rAddIn, rSymbol).second; + SAL_INFO_IF( !bOk, "formula.core", "OpCodeMap::putExternalSoftly: AddIn not inserted, " << rAddIn << " -> " << rSymbol); + } +} + +uno::Sequence< sheet::FormulaToken > FormulaCompiler::OpCodeMap::createSequenceOfFormulaTokens( + const FormulaCompiler& rCompiler, const uno::Sequence< OUString >& rNames ) const +{ + const sal_Int32 nLen = rNames.getLength(); + uno::Sequence< sheet::FormulaToken > aTokens( nLen); + sheet::FormulaToken* pToken = aTokens.getArray(); + OUString const * pName = rNames.getConstArray(); + OUString const * const pStop = pName + nLen; + for ( ; pName < pStop; ++pName, ++pToken) + { + OpCodeHashMap::const_iterator iLook( maHashMap.find( *pName)); + if (iLook != maHashMap.end()) + pToken->OpCode = (*iLook).second; + else + { + OUString aIntName; + if (hasExternals()) + { + ExternalHashMap::const_iterator iExt( maExternalHashMap.find( *pName)); + if (iExt != maExternalHashMap.end()) + aIntName = (*iExt).second; + // Check for existence not needed here, only name-mapping is of + // interest. + } + if (aIntName.isEmpty()) + aIntName = rCompiler.FindAddInFunction(*pName, !isEnglish()); // bLocalFirst=false for english + if (aIntName.isEmpty()) + pToken->OpCode = getOpCodeUnknown(); + else + { + pToken->OpCode = ocExternal; + pToken->Data <<= aIntName; + } + } + } + return aTokens; +} + +uno::Sequence< sheet::FormulaOpCodeMapEntry > FormulaCompiler::OpCodeMap::createSequenceOfAvailableMappings( + const FormulaCompiler& rCompiler, const sal_Int32 nGroups ) const +{ + using namespace sheet; + + // Unfortunately uno::Sequence can't grow without cumbersome reallocs. As + // we don't know in advance how many elements it will have we use a + // temporary vector to add elements and then copy to Sequence :-( + ::std::vector< FormulaOpCodeMapEntry > aVec; + + if (nGroups == FormulaMapGroup::SPECIAL) + { + // Use specific order, keep in sync with + // offapi/com/sun/star/sheet/FormulaMapGroupSpecialOffset.idl + static const struct + { + sal_Int32 nOff; + OpCode eOp; + } aMap[] = { + { FormulaMapGroupSpecialOffset::PUSH , ocPush } , + { FormulaMapGroupSpecialOffset::CALL , ocCall } , + { FormulaMapGroupSpecialOffset::STOP , ocStop } , + { FormulaMapGroupSpecialOffset::EXTERNAL , ocExternal } , + { FormulaMapGroupSpecialOffset::NAME , ocName } , + { FormulaMapGroupSpecialOffset::NO_NAME , ocNoName } , + { FormulaMapGroupSpecialOffset::MISSING , ocMissing } , + { FormulaMapGroupSpecialOffset::BAD , ocBad } , + { FormulaMapGroupSpecialOffset::SPACES , ocSpaces } , + { FormulaMapGroupSpecialOffset::MAT_REF , ocMatRef } , + { FormulaMapGroupSpecialOffset::DB_AREA , ocDBArea } , + /* TODO: { FormulaMapGroupSpecialOffset::TABLE_REF , ocTableRef } , */ + { FormulaMapGroupSpecialOffset::MACRO , ocMacro } , + { FormulaMapGroupSpecialOffset::COL_ROW_NAME , ocColRowName } , + { FormulaMapGroupSpecialOffset::WHITESPACE , ocWhitespace } + }; + const size_t nCount = SAL_N_ELEMENTS(aMap); + // Preallocate vector elements. + FormulaOpCodeMapEntry aEntry; + aEntry.Token.OpCode = getOpCodeUnknown(); + aVec.resize(nCount, aEntry); + + for (auto& i : aMap) + { + size_t nIndex = static_cast< size_t >( i.nOff ); + if (aVec.size() <= nIndex) + { + // The offsets really should be aligned with the size, so if + // the vector was preallocated above this code to resize it is + // just a measure in case the table isn't in sync with the API, + // usually it isn't executed. + aEntry.Token.OpCode = getOpCodeUnknown(); + aVec.resize( nIndex + 1, aEntry ); + } + aEntry.Token.OpCode = i.eOp; + aVec[nIndex] = aEntry; + } + } + else + { + /* FIXME: Once we support error constants in formulas we'll need a map + * group for that, e.g. FormulaMapGroup::ERROR_CONSTANTS, and fill + * SC_OPCODE_START_ERRORS to SC_OPCODE_STOP_ERRORS. */ + + // Anything else but SPECIAL. + if ((nGroups & FormulaMapGroup::SEPARATORS) != 0) + { + static const sal_uInt16 aOpCodes[] = { + SC_OPCODE_OPEN, + SC_OPCODE_CLOSE, + SC_OPCODE_SEP, + }; + lclPushOpCodeMapEntries( aVec, mpTable.get(), aOpCodes, SAL_N_ELEMENTS(aOpCodes) ); + } + if ((nGroups & FormulaMapGroup::ARRAY_SEPARATORS) != 0) + { + static const sal_uInt16 aOpCodes[] = { + SC_OPCODE_ARRAY_OPEN, + SC_OPCODE_ARRAY_CLOSE, + SC_OPCODE_ARRAY_ROW_SEP, + SC_OPCODE_ARRAY_COL_SEP + }; + lclPushOpCodeMapEntries( aVec, mpTable.get(), aOpCodes, SAL_N_ELEMENTS(aOpCodes) ); + } + if ((nGroups & FormulaMapGroup::UNARY_OPERATORS) != 0) + { + // Due to the nature of the percent operator following its operand + // it isn't sorted into unary operators for compiler interna. + lclPushOpCodeMapEntry( aVec, mpTable.get(), ocPercentSign ); + // "+" can be used as unary operator too, push only if binary group is not set + if ((nGroups & FormulaMapGroup::BINARY_OPERATORS) == 0) + lclPushOpCodeMapEntry( aVec, mpTable.get(), ocAdd ); + // regular unary operators + for (sal_uInt16 nOp = SC_OPCODE_START_UN_OP; nOp < SC_OPCODE_STOP_UN_OP && nOp < mnSymbols; ++nOp) + { + lclPushOpCodeMapEntry( aVec, mpTable.get(), nOp ); + } + } + if ((nGroups & FormulaMapGroup::BINARY_OPERATORS) != 0) + { + for (sal_uInt16 nOp = SC_OPCODE_START_BIN_OP; nOp < SC_OPCODE_STOP_BIN_OP && nOp < mnSymbols; ++nOp) + { + switch (nOp) + { + // AND and OR in fact are functions but for legacy reasons + // are sorted into binary operators for compiler interna. + case SC_OPCODE_AND : + case SC_OPCODE_OR : + break; // nothing, + default: + lclPushOpCodeMapEntry( aVec, mpTable.get(), nOp ); + } + } + } + if ((nGroups & FormulaMapGroup::FUNCTIONS) != 0) + { + // Function names are not consecutive, skip the gaps between + // functions with no parameter, functions with 1 parameter + lclPushOpCodeMapEntries( aVec, mpTable.get(), SC_OPCODE_START_NO_PAR, + ::std::min< sal_uInt16 >( SC_OPCODE_STOP_NO_PAR, mnSymbols ) ); + lclPushOpCodeMapEntries( aVec, mpTable.get(), SC_OPCODE_START_1_PAR, + ::std::min< sal_uInt16 >( SC_OPCODE_STOP_1_PAR, mnSymbols ) ); + // Additional functions not within range of functions. + static const sal_uInt16 aOpCodes[] = { + SC_OPCODE_IF, + SC_OPCODE_IF_ERROR, + SC_OPCODE_IF_NA, + SC_OPCODE_CHOOSE, + SC_OPCODE_AND, + SC_OPCODE_OR + }; + lclPushOpCodeMapEntries( aVec, mpTable.get(), aOpCodes, SAL_N_ELEMENTS(aOpCodes) ); + // functions with 2 or more parameters. + for (sal_uInt16 nOp = SC_OPCODE_START_2_PAR; nOp < SC_OPCODE_STOP_2_PAR && nOp < mnSymbols; ++nOp) + { + switch (nOp) + { + // NO_NAME is in SPECIAL. + case SC_OPCODE_NO_NAME : + break; // nothing, + default: + lclPushOpCodeMapEntry( aVec, mpTable.get(), nOp ); + } + } + // If AddIn functions are present in this mapping, use them, and only those. + if (hasExternals()) + { + for (auto const& elem : maExternalHashMap) + { + FormulaOpCodeMapEntry aEntry; + aEntry.Name = elem.first; + aEntry.Token.Data <<= elem.second; + aEntry.Token.OpCode = ocExternal; + aVec.push_back( aEntry); + } + } + else + { + rCompiler.fillAddInToken( aVec, isEnglish()); + } + } + } + return uno::Sequence< FormulaOpCodeMapEntry >(aVec.data(), aVec.size()); +} + + +void FormulaCompiler::OpCodeMap::putOpCode( const OUString & rStr, const OpCode eOp, const CharClass* pCharClass ) +{ + if (0 < eOp && sal_uInt16(eOp) < mnSymbols) + { + bool bPutOp = mpTable[eOp].isEmpty(); + bool bRemoveFromMap = false; + if (!bPutOp) + { + switch (eOp) + { + // These OpCodes are meant to overwrite and also remove an + // existing mapping. + case ocCurrency: + bPutOp = true; + bRemoveFromMap = true; + break; + // These separator OpCodes are meant to overwrite and also + // remove an existing mapping if it is not used for one of the + // other separators. + case ocArrayColSep: + bPutOp = true; + bRemoveFromMap = (mpTable[ocArrayRowSep] != mpTable[eOp] && mpTable[ocSep] != mpTable[eOp]); + break; + case ocArrayRowSep: + bPutOp = true; + bRemoveFromMap = (mpTable[ocArrayColSep] != mpTable[eOp] && mpTable[ocSep] != mpTable[eOp]); + break; + // For ocSep keep the ";" in map but remove any other if it is + // not used for ocArrayColSep or ocArrayRowSep. + case ocSep: + bPutOp = true; + bRemoveFromMap = (mpTable[eOp] != ";" && + mpTable[ocArrayColSep] != mpTable[eOp] && + mpTable[ocArrayRowSep] != mpTable[eOp]); + break; + // These OpCodes are known to be duplicates in the Excel + // external API mapping because of different parameter counts + // in different BIFF versions. Names are identical and entries + // are ignored. + case ocLinest: + case ocTrend: + case ocLogest: + case ocGrowth: + case ocTrunc: + case ocFixed: + case ocGetDayOfWeek: + case ocHLookup: + case ocVLookup: + case ocGetDiffDate360: + if (rStr == mpTable[eOp]) + return; + [[fallthrough]]; + // These OpCodes are known to be added to an existing mapping, + // but only for the OOXML external API mapping. This is *not* + // FormulaLanguage::OOXML. Keep the first + // (correct) definition for the OpCode, all following are + // additional alias entries in the map. + case ocErrorType: + case ocMultiArea: + case ocBackSolver: + case ocEasterSunday: + case ocCurrent: + case ocStyle: + if (mbEnglish && + FormulaGrammar::extractFormulaLanguage( meGrammar) == FormulaGrammar::GRAM_EXTERNAL) + { + // Both bPutOp and bRemoveFromMap stay false. + break; + } + [[fallthrough]]; + default: + SAL_WARN("formula.core", + "OpCodeMap::putOpCode: reusing OpCode " << static_cast<sal_uInt16>(eOp) + << ", replacing '" << mpTable[eOp] << "' with '" << rStr << "' in " + << (mbEnglish ? "" : "non-") << "English map 0x" << ::std::hex << meGrammar); + } + } + + // Case preserving opcode -> string, upper string -> opcode + if (bRemoveFromMap) + { + OUString aUpper( pCharClass ? pCharClass->uppercase( mpTable[eOp]) : rStr.toAsciiUpperCase()); + // Ensure we remove a mapping only for the requested OpCode. + OpCodeHashMap::const_iterator it( maHashMap.find( aUpper)); + if (it != maHashMap.end() && (*it).second == eOp) + maHashMap.erase( it); + } + if (bPutOp) + mpTable[eOp] = rStr; + OUString aUpper( pCharClass ? pCharClass->uppercase( rStr) : rStr.toAsciiUpperCase()); + maHashMap.emplace(aUpper, eOp); + } + else + { + SAL_WARN( "formula.core", "OpCodeMap::putOpCode: OpCode out of range"); + } +} + + +FormulaCompiler::FormulaCompiler( FormulaTokenArray& rArr, bool bComputeII, bool bMatrixFlag ) + : + nCurrentFactorParam(0), + pArr( &rArr ), + maArrIterator( rArr ), + pCode( nullptr ), + pStack( nullptr ), + eLastOp( ocPush ), + nRecursion( 0 ), + nNumFmt( SvNumFormatType::UNDEFINED ), + pc( 0 ), + meGrammar( formula::FormulaGrammar::GRAM_UNSPECIFIED ), + bAutoCorrect( false ), + bCorrected( false ), + glSubTotal( false ), + needsRPNTokenCheck( false ), + mbJumpCommandReorder(true), + mbStopOnError(true), + mbComputeII(bComputeII), + mbMatrixFlag(bMatrixFlag) +{ +} + +FormulaTokenArray FormulaCompiler::smDummyTokenArray; + +FormulaCompiler::FormulaCompiler(bool bComputeII, bool bMatrixFlag) + : + nCurrentFactorParam(0), + pArr( nullptr ), + maArrIterator( smDummyTokenArray ), + pCode( nullptr ), + pStack( nullptr ), + eLastOp( ocPush ), + nRecursion(0), + nNumFmt( SvNumFormatType::UNDEFINED ), + pc( 0 ), + meGrammar( formula::FormulaGrammar::GRAM_UNSPECIFIED ), + bAutoCorrect( false ), + bCorrected( false ), + glSubTotal( false ), + needsRPNTokenCheck( false ), + mbJumpCommandReorder(true), + mbStopOnError(true), + mbComputeII(bComputeII), + mbMatrixFlag(bMatrixFlag) +{ +} + +FormulaCompiler::~FormulaCompiler() +{ +} + +FormulaCompiler::OpCodeMapPtr FormulaCompiler::GetOpCodeMap( const sal_Int32 nLanguage ) const +{ + const bool bTemporary = !HasOpCodeMap(nLanguage); + OpCodeMapPtr xMap = GetFinalOpCodeMap(nLanguage); + if (bTemporary) + const_cast<FormulaCompiler*>(this)->DestroyOpCodeMap(nLanguage); + return xMap; +} + +FormulaCompiler::OpCodeMapPtr FormulaCompiler::GetFinalOpCodeMap( const sal_Int32 nLanguage ) const +{ + FormulaCompiler::OpCodeMapPtr xMap; + using namespace sheet; + switch (nLanguage) + { + case FormulaLanguage::ODFF : + if (!mxSymbolsODFF) + InitSymbolsODFF( InitSymbols::INIT); + xMap = mxSymbolsODFF; + break; + case FormulaLanguage::ODF_11 : + if (!mxSymbolsPODF) + InitSymbolsPODF( InitSymbols::INIT); + xMap = mxSymbolsPODF; + break; + case FormulaLanguage::ENGLISH : + if (!mxSymbolsEnglish) + InitSymbolsEnglish( InitSymbols::INIT); + xMap = mxSymbolsEnglish; + break; + case FormulaLanguage::NATIVE : + if (!mxSymbolsNative) + InitSymbolsNative( InitSymbols::INIT); + xMap = mxSymbolsNative; + break; + case FormulaLanguage::XL_ENGLISH: + if (!mxSymbolsEnglishXL) + InitSymbolsEnglishXL( InitSymbols::INIT); + xMap = mxSymbolsEnglishXL; + break; + case FormulaLanguage::OOXML: + if (!mxSymbolsOOXML) + InitSymbolsOOXML( InitSymbols::INIT); + xMap = mxSymbolsOOXML; + break; + case FormulaLanguage::API : + if (!mxSymbolsAPI) + InitSymbolsAPI( InitSymbols::INIT); + xMap = mxSymbolsAPI; + break; + default: + ; // nothing, NULL map returned + } + return xMap; +} + +void FormulaCompiler::DestroyOpCodeMap( const sal_Int32 nLanguage ) +{ + using namespace sheet; + switch (nLanguage) + { + case FormulaLanguage::ODFF : + InitSymbolsODFF( InitSymbols::DESTROY); + break; + case FormulaLanguage::ODF_11 : + InitSymbolsPODF( InitSymbols::DESTROY); + break; + case FormulaLanguage::ENGLISH : + InitSymbolsEnglish( InitSymbols::DESTROY); + break; + case FormulaLanguage::NATIVE : + InitSymbolsNative( InitSymbols::DESTROY); + break; + case FormulaLanguage::XL_ENGLISH: + InitSymbolsEnglishXL( InitSymbols::DESTROY); + break; + case FormulaLanguage::OOXML: + InitSymbolsOOXML( InitSymbols::DESTROY); + break; + case FormulaLanguage::API : + InitSymbolsAPI( InitSymbols::DESTROY); + break; + default: + ; // nothing + } +} + +bool FormulaCompiler::HasOpCodeMap( const sal_Int32 nLanguage ) const +{ + using namespace sheet; + switch (nLanguage) + { + case FormulaLanguage::ODFF : + return InitSymbolsODFF( InitSymbols::ASK); + case FormulaLanguage::ODF_11 : + return InitSymbolsPODF( InitSymbols::ASK); + case FormulaLanguage::ENGLISH : + return InitSymbolsEnglish( InitSymbols::ASK); + case FormulaLanguage::NATIVE : + return InitSymbolsNative( InitSymbols::ASK); + case FormulaLanguage::XL_ENGLISH: + return InitSymbolsEnglishXL( InitSymbols::ASK); + case FormulaLanguage::OOXML: + return InitSymbolsOOXML( InitSymbols::ASK); + case FormulaLanguage::API : + return InitSymbolsAPI( InitSymbols::ASK); + default: + ; // nothing + } + return false; +} + +OUString FormulaCompiler::FindAddInFunction( const OUString& /*rUpperName*/, bool /*bLocalFirst*/ ) const +{ + return OUString(); +} + +FormulaCompiler::OpCodeMapPtr FormulaCompiler::CreateOpCodeMap( + const uno::Sequence< + const sheet::FormulaOpCodeMapEntry > & rMapping, + bool bEnglish ) +{ + using sheet::FormulaOpCodeMapEntry; + // Filter / API maps are never Core + NonConstOpCodeMapPtr xMap = std::make_shared<OpCodeMap>( SC_OPCODE_LAST_OPCODE_ID + 1, false, + FormulaGrammar::mergeToGrammar( FormulaGrammar::setEnglishBit( + FormulaGrammar::GRAM_EXTERNAL, bEnglish), FormulaGrammar::CONV_UNSPECIFIED)); + std::unique_ptr<CharClass> xCharClass( xMap->isEnglish() ? nullptr : createCharClassIfNonEnglishUI()); + const CharClass* pCharClass = xCharClass.get(); + for (auto const& rMapEntry : rMapping) + { + OpCode eOp = OpCode(rMapEntry.Token.OpCode); + if (eOp != ocExternal) + xMap->putOpCode( rMapEntry.Name, eOp, pCharClass); + else + { + OUString aExternalName; + if (rMapEntry.Token.Data >>= aExternalName) + xMap->putExternal( rMapEntry.Name, aExternalName); + else + { + SAL_WARN( "formula.core", "FormulaCompiler::CreateOpCodeMap: no Token.Data external name"); + } + } + } + return xMap; +} + +static bool lcl_fillNativeSymbols( FormulaCompiler::NonConstOpCodeMapPtr& xMap, FormulaCompiler::InitSymbols eWhat = FormulaCompiler::InitSymbols::INIT ) +{ + static OpCodeMapData aSymbolMap; + osl::MutexGuard aGuard(&aSymbolMap.maMtx); + + if (eWhat == FormulaCompiler::InitSymbols::ASK) + { + return bool(aSymbolMap.mxSymbolMap); + } + else if (eWhat == FormulaCompiler::InitSymbols::DESTROY) + { + aSymbolMap.mxSymbolMap.reset(); + } + else if (!aSymbolMap.mxSymbolMap) + { + // Core + aSymbolMap.mxSymbolMap = + std::make_shared<FormulaCompiler::OpCodeMap>( + SC_OPCODE_LAST_OPCODE_ID + 1, true, FormulaGrammar::GRAM_NATIVE_UI); + OpCodeList aOpCodeListSymbols(RID_STRLIST_FUNCTION_NAMES_SYMBOLS, aSymbolMap.mxSymbolMap); + OpCodeList aOpCodeListNative(RID_STRLIST_FUNCTION_NAMES, aSymbolMap.mxSymbolMap); + // No AddInMap for native core mapping. + } + + xMap = aSymbolMap.mxSymbolMap; + + return true; +} + +const OUString& FormulaCompiler::GetNativeSymbol( OpCode eOp ) +{ + NonConstOpCodeMapPtr xSymbolsNative; + lcl_fillNativeSymbols( xSymbolsNative); + return xSymbolsNative->getSymbol( eOp ); +} + +sal_Unicode FormulaCompiler::GetNativeSymbolChar( OpCode eOp ) +{ + return GetNativeSymbol(eOp)[0]; +} + +bool FormulaCompiler::InitSymbolsNative( FormulaCompiler::InitSymbols eWhat ) const +{ + return lcl_fillNativeSymbols( mxSymbolsNative, eWhat); +} + +bool FormulaCompiler::InitSymbolsEnglish( FormulaCompiler::InitSymbols eWhat ) const +{ + static OpCodeMapData aMap; + osl::MutexGuard aGuard(&aMap.maMtx); + if (eWhat == InitSymbols::ASK) + return bool(aMap.mxSymbolMap); + else if (eWhat == InitSymbols::DESTROY) + aMap.mxSymbolMap.reset(); + else if (!aMap.mxSymbolMap) + loadSymbols(RID_STRLIST_FUNCTION_NAMES_ENGLISH, FormulaGrammar::GRAM_ENGLISH, aMap.mxSymbolMap); + mxSymbolsEnglish = aMap.mxSymbolMap; + return true; +} + +bool FormulaCompiler::InitSymbolsPODF( FormulaCompiler::InitSymbols eWhat ) const +{ + static OpCodeMapData aMap; + osl::MutexGuard aGuard(&aMap.maMtx); + if (eWhat == InitSymbols::ASK) + return bool(aMap.mxSymbolMap); + else if (eWhat == InitSymbols::DESTROY) + aMap.mxSymbolMap.reset(); + else if (!aMap.mxSymbolMap) + loadSymbols(RID_STRLIST_FUNCTION_NAMES_ENGLISH_PODF, FormulaGrammar::GRAM_PODF, aMap.mxSymbolMap, SeparatorType::RESOURCE_BASE); + mxSymbolsPODF = aMap.mxSymbolMap; + return true; +} + +bool FormulaCompiler::InitSymbolsAPI( FormulaCompiler::InitSymbols eWhat ) const +{ + static OpCodeMapData aMap; + osl::MutexGuard aGuard(&aMap.maMtx); + if (eWhat == InitSymbols::ASK) + return bool(aMap.mxSymbolMap); + else if (eWhat == InitSymbols::DESTROY) + aMap.mxSymbolMap.reset(); + else if (!aMap.mxSymbolMap) + loadSymbols(RID_STRLIST_FUNCTION_NAMES_ENGLISH_API, FormulaGrammar::GRAM_API, aMap.mxSymbolMap, SeparatorType::RESOURCE_BASE); + mxSymbolsAPI = aMap.mxSymbolMap; + return true; +} + +bool FormulaCompiler::InitSymbolsODFF( FormulaCompiler::InitSymbols eWhat ) const +{ + static OpCodeMapData aMap; + osl::MutexGuard aGuard(&aMap.maMtx); + if (eWhat == InitSymbols::ASK) + return bool(aMap.mxSymbolMap); + else if (eWhat == InitSymbols::DESTROY) + aMap.mxSymbolMap.reset(); + else if (!aMap.mxSymbolMap) + loadSymbols(RID_STRLIST_FUNCTION_NAMES_ENGLISH_ODFF, FormulaGrammar::GRAM_ODFF, aMap.mxSymbolMap, SeparatorType::RESOURCE_BASE); + mxSymbolsODFF = aMap.mxSymbolMap; + return true; +} + +bool FormulaCompiler::InitSymbolsEnglishXL( FormulaCompiler::InitSymbols eWhat ) const +{ + static OpCodeMapData aMap; + osl::MutexGuard aGuard(&aMap.maMtx); + if (eWhat == InitSymbols::ASK) + return bool(aMap.mxSymbolMap); + else if (eWhat == InitSymbols::DESTROY) + aMap.mxSymbolMap.reset(); + else if (!aMap.mxSymbolMap) + loadSymbols(RID_STRLIST_FUNCTION_NAMES_ENGLISH, FormulaGrammar::GRAM_ENGLISH, aMap.mxSymbolMap); + mxSymbolsEnglishXL = aMap.mxSymbolMap; + if (eWhat != InitSymbols::INIT) + return true; + + // TODO: For now, just replace the separators to the Excel English + // variants. Later, if we want to properly map Excel functions with Calc + // functions, we'll need to do a little more work here. + mxSymbolsEnglishXL->putOpCode( OUString(','), ocSep, nullptr); + mxSymbolsEnglishXL->putOpCode( OUString(','), ocArrayColSep, nullptr); + mxSymbolsEnglishXL->putOpCode( OUString(';'), ocArrayRowSep, nullptr); + + return true; +} + +bool FormulaCompiler::InitSymbolsOOXML( FormulaCompiler::InitSymbols eWhat ) const +{ + static OpCodeMapData aMap; + osl::MutexGuard aGuard(&aMap.maMtx); + if (eWhat == InitSymbols::ASK) + return bool(aMap.mxSymbolMap); + else if (eWhat == InitSymbols::DESTROY) + aMap.mxSymbolMap.reset(); + else if (!aMap.mxSymbolMap) + loadSymbols(RID_STRLIST_FUNCTION_NAMES_ENGLISH_OOXML, FormulaGrammar::GRAM_OOXML, aMap.mxSymbolMap, SeparatorType::RESOURCE_BASE); + mxSymbolsOOXML = aMap.mxSymbolMap; + return true; +} + + +void FormulaCompiler::loadSymbols(const std::pair<const char*, int>* pSymbols, FormulaGrammar::Grammar eGrammar, + NonConstOpCodeMapPtr& rxMap, SeparatorType eSepType) const +{ + if ( rxMap ) + return; + + // not Core + rxMap = std::make_shared<OpCodeMap>( SC_OPCODE_LAST_OPCODE_ID + 1, eGrammar != FormulaGrammar::GRAM_ODFF, eGrammar ); + OpCodeList aOpCodeList(pSymbols, rxMap, eSepType); + + fillFromAddInMap( rxMap, eGrammar); + // Fill from collection for AddIns not already present. + if (FormulaGrammar::GRAM_ENGLISH == eGrammar) + fillFromAddInCollectionEnglishName( rxMap); + else + { + fillFromAddInCollectionUpperName( rxMap); + if (FormulaGrammar::GRAM_API == eGrammar) + { + // Add known but not in AddInMap English names, e.g. from the + // PricingFunctions AddIn or any user supplied AddIn. + fillFromAddInCollectionEnglishName( rxMap); + } + } +} + +void FormulaCompiler::fillFromAddInCollectionUpperName( const NonConstOpCodeMapPtr& /*xMap */) const +{ +} + +void FormulaCompiler::fillFromAddInCollectionEnglishName( const NonConstOpCodeMapPtr& /*xMap */) const +{ +} + +void FormulaCompiler::fillFromAddInMap( const NonConstOpCodeMapPtr& /*xMap*/, FormulaGrammar::Grammar /*_eGrammar */) const +{ +} + +OpCode FormulaCompiler::GetEnglishOpCode( const OUString& rName ) const +{ + FormulaCompiler::OpCodeMapPtr xMap = GetOpCodeMap( sheet::FormulaLanguage::ENGLISH); + + formula::OpCodeHashMap::const_iterator iLook( xMap->getHashMap().find( rName ) ); + bool bFound = (iLook != xMap->getHashMap().end()); + return bFound ? (*iLook).second : ocNone; +} + +bool FormulaCompiler::IsOpCodeVolatile( OpCode eOp ) +{ + bool bRet = false; + switch (eOp) + { + // no parameters: + case ocRandom: + case ocGetActDate: + case ocGetActTime: + // one parameter: + case ocFormula: + case ocInfo: + // more than one parameters: + // ocIndirect otherwise would have to do + // StopListening and StartListening on a reference for every + // interpreted value. + case ocIndirect: + // ocOffset results in indirect references. + case ocOffset: + // ocDebugVar shows internal value that may change as the internal state changes. + case ocDebugVar: + bRet = true; + break; + default: + bRet = false; + break; + } + return bRet; +} + +bool FormulaCompiler::IsOpCodeJumpCommand( OpCode eOp ) +{ + switch (eOp) + { + case ocIf: + case ocIfError: + case ocIfNA: + case ocChoose: + return true; + default: + ; + } + return false; +} + +// Remove quotes, escaped quotes are unescaped. +bool FormulaCompiler::DeQuote( OUString& rStr ) +{ + sal_Int32 nLen = rStr.getLength(); + if ( nLen > 1 && rStr[0] == '\'' && rStr[ nLen-1 ] == '\'' ) + { + rStr = rStr.copy( 1, nLen-2 ); + rStr = rStr.replaceAll( "''", "'" ); + return true; + } + return false; +} + +void FormulaCompiler::fillAddInToken( + ::std::vector< sheet::FormulaOpCodeMapEntry >& /*_rVec*/, + bool /*_bIsEnglish*/) const +{ +} + +bool FormulaCompiler::IsMatrixFunction( OpCode eOpCode ) +{ + switch (eOpCode) + { + case ocDde : + case ocGrowth : + case ocTrend : + case ocLogest : + case ocLinest : + case ocFrequency : + case ocMatTrans : + case ocMatMult : + case ocMatInv : + case ocMatrixUnit : + case ocModalValue_Multi : + case ocFourier : + return true; + default: + { + // added to avoid warnings + } + } + return false; +} + + +void FormulaCompiler::OpCodeMap::putCopyOpCode( const OUString& rSymbol, OpCode eOp ) +{ + SAL_WARN_IF( !mpTable[eOp].isEmpty() && rSymbol.isEmpty(), "formula.core", + "OpCodeMap::putCopyOpCode: NOT replacing OpCode " << static_cast<sal_uInt16>(eOp) + << " '" << mpTable[eOp] << "' with empty name!"); + if (!mpTable[eOp].isEmpty() && rSymbol.isEmpty()) + maHashMap.emplace(mpTable[eOp], eOp); + else + { + mpTable[eOp] = rSymbol; + maHashMap.emplace(rSymbol, eOp); + } +} + +void FormulaCompiler::OpCodeMap::copyFrom( const OpCodeMap& r ) +{ + maHashMap = OpCodeHashMap( mnSymbols); + + sal_uInt16 n = r.getSymbolCount(); + SAL_WARN_IF( n != mnSymbols, "formula.core", + "OpCodeMap::copyFrom: unequal size, this: " << mnSymbols << " that: " << n); + if (n > mnSymbols) + n = mnSymbols; + + // OpCode 0 (ocPush) should never be in a map. + SAL_WARN_IF( !mpTable[0].isEmpty() || !r.mpTable[0].isEmpty(), "formula.core", + "OpCodeMap::copyFrom: OpCode 0 assigned, this: '" + << mpTable[0] << "' that: '" << r.mpTable[0] << "'"); + + // For bOverrideKnownBad when copying from the English core map (ODF 1.1 + // and API) to the native map (UI "use English function names") replace the + // known bad legacy function names with correct ones. + if (r.mbCore && + FormulaGrammar::extractFormulaLanguage( meGrammar) == sheet::FormulaLanguage::NATIVE && + FormulaGrammar::extractFormulaLanguage( r.meGrammar) == sheet::FormulaLanguage::ENGLISH) + { + for (sal_uInt16 i = 1; i < n; ++i) + { + OUString aSymbol; + OpCode eOp = OpCode(i); + switch (eOp) + { + case ocRRI: + aSymbol = "RRI"; + break; + case ocTableOp: + aSymbol = "MULTIPLE.OPERATIONS"; + break; + default: + aSymbol = r.mpTable[i]; + } + putCopyOpCode( aSymbol, eOp); + } + } + else + { + for (sal_uInt16 i = 1; i < n; ++i) + { + OpCode eOp = OpCode(i); + const OUString& rSymbol = r.mpTable[i]; + putCopyOpCode( rSymbol, eOp); + } + } + + // This was meant to copy to native map that does not have AddIn symbols + // but needs them from the source map. It is unclear what should happen if + // the destination already had externals, so do it only if it doesn't. + if (!hasExternals()) + { + maExternalHashMap = r.maExternalHashMap; + maReverseExternalHashMap = r.maReverseExternalHashMap; + mbCore = r.mbCore; + if (mbEnglish != r.mbEnglish) + { + // For now keep mbEnglishLocale setting, which is false for a + // non-English native map we're copying to. + /* TODO: + if (!mbEnglish && r.mbEnglish) + mbEnglishLocale = "getUseEnglishLocaleFromConfiguration()"; + or set from outside i.e. via ScCompiler. + */ + mbEnglish = r.mbEnglish; + } + } +} + + +FormulaError FormulaCompiler::GetErrorConstant( const OUString& rName ) const +{ + FormulaError nError = FormulaError::NONE; + OpCodeHashMap::const_iterator iLook( mxSymbols->getHashMap().find( rName)); + if (iLook != mxSymbols->getHashMap().end()) + { + switch ((*iLook).second) + { + // Not all may make sense in a formula, but these we know as + // opcodes. + case ocErrNull: + nError = FormulaError::NoCode; + break; + case ocErrDivZero: + nError = FormulaError::DivisionByZero; + break; + case ocErrValue: + nError = FormulaError::NoValue; + break; + case ocErrRef: + nError = FormulaError::NoRef; + break; + case ocErrName: + nError = FormulaError::NoName; + break; + case ocErrNum: + nError = FormulaError::IllegalFPOperation; + break; + case ocErrNA: + nError = FormulaError::NotAvailable; + break; + default: + ; // nothing + } + } + else + { + // Per convention recognize detailed "#ERRxxx!" constants, always + // untranslated. Error numbers are sal_uInt16 so at most 5 decimal + // digits. + if (rName.startsWithIgnoreAsciiCase("#ERR") && rName.getLength() <= 10 && rName[rName.getLength()-1] == '!') + { + sal_uInt32 nErr = o3tl::toUInt32(rName.subView( 4, rName.getLength() - 5)); + if (0 < nErr && nErr <= SAL_MAX_UINT16 && isPublishedFormulaError(static_cast<FormulaError>(nErr))) + nError = static_cast<FormulaError>(nErr); + } + } + return nError; +} + +void FormulaCompiler::EnableJumpCommandReorder( bool bEnable ) +{ + mbJumpCommandReorder = bEnable; +} + +void FormulaCompiler::EnableStopOnError( bool bEnable ) +{ + mbStopOnError = bEnable; +} + +void FormulaCompiler::AppendErrorConstant( OUStringBuffer& rBuffer, FormulaError nError ) const +{ + OpCode eOp; + switch (nError) + { + case FormulaError::NoCode: + eOp = ocErrNull; + break; + case FormulaError::DivisionByZero: + eOp = ocErrDivZero; + break; + case FormulaError::NoValue: + eOp = ocErrValue; + break; + case FormulaError::NoRef: + eOp = ocErrRef; + break; + case FormulaError::NoName: + eOp = ocErrName; + break; + case FormulaError::IllegalFPOperation: + eOp = ocErrNum; + break; + case FormulaError::NotAvailable: + eOp = ocErrNA; + break; + default: + { + // Per convention create detailed "#ERRxxx!" constants, always + // untranslated. + rBuffer.append("#ERR"); + rBuffer.append(static_cast<sal_Int32>(nError)); + rBuffer.append('!'); + return; + } + } + rBuffer.append( mxSymbols->getSymbol( eOp)); +} + +constexpr short nRecursionMax = 100; + +bool FormulaCompiler::GetToken() +{ + FormulaCompilerRecursionGuard aRecursionGuard( nRecursion ); + if ( nRecursion > nRecursionMax ) + { + SetError( FormulaError::StackOverflow ); + mpLastToken = mpToken = new FormulaByteToken( ocStop ); + return false; + } + if ( bAutoCorrect && !pStack ) + { // don't merge stacked subroutine code into entered formula + aCorrectedFormula += aCorrectedSymbol; + aCorrectedSymbol.clear(); + } + bool bStop = false; + if (pArr->GetCodeError() != FormulaError::NONE && mbStopOnError) + bStop = true; + else + { + FormulaTokenRef pSpacesToken; + short nWasColRowName; + if ( pArr->OpCodeBefore( maArrIterator.GetIndex() ) == ocColRowName ) + nWasColRowName = 1; + else + nWasColRowName = 0; + OpCode eTmpOp; + mpToken = maArrIterator.Next(); + while (mpToken && ((eTmpOp = mpToken->GetOpCode()) == ocSpaces || eTmpOp == ocWhitespace)) + { + if (eTmpOp == ocSpaces) + { + // For significant whitespace remember last ocSpaces token. + // Usually there's only one even for multiple spaces. + pSpacesToken = mpToken; + if ( nWasColRowName ) + nWasColRowName++; + } + if ( bAutoCorrect && !pStack ) + CreateStringFromToken( aCorrectedFormula, mpToken.get() ); + mpToken = maArrIterator.Next(); + } + if ( bAutoCorrect && !pStack && mpToken ) + CreateStringFromToken( aCorrectedSymbol, mpToken.get() ); + if( !mpToken ) + { + if( pStack ) + { + PopTokenArray(); + // mpLastToken was popped as well and corresponds to the + // then current last token during PushTokenArray(), e.g. for + // HandleRange(). + return GetToken(); + } + else + bStop = true; + } + else + { + if ( nWasColRowName >= 2 && mpToken->GetOpCode() == ocColRowName ) + { // convert an ocSpaces to ocIntersect in RPN + mpLastToken = mpToken = new FormulaByteToken( ocIntersect ); + maArrIterator.StepBack(); // we advanced to the second ocColRowName, step back + } + else if (pSpacesToken && FormulaGrammar::isExcelSyntax( meGrammar) && + mpLastToken && mpToken && + isPotentialRangeType( mpLastToken.get(), false, false) && + isPotentialRangeType( mpToken.get(), false, true)) + { + // Let IntersectionLine() <- Factor() decide how to treat this, + // once the actual arguments are determined in RPN. + mpLastToken = mpToken = pSpacesToken; + maArrIterator.StepBack(); // step back from next non-spaces token + return true; + } + } + } + if( bStop ) + { + mpLastToken = mpToken = new FormulaByteToken( ocStop ); + return false; + } + + // Remember token for next round and any PushTokenArray() calls that may + // occur in handlers. + mpLastToken = mpToken; + + if ( mpToken->IsExternalRef() ) + { + return HandleExternalReference(*mpToken); + } + else + { + switch (mpToken->GetOpCode()) + { + case ocSubTotal: + case ocAggregate: + glSubTotal = true; + break; + case ocName: + if( HandleRange()) + { + // Expanding ocName might have introduced tokens such as ocStyle that prevent formula threading, + // but those wouldn't be present in the raw tokens array, so ensure RPN tokens will be checked too. + needsRPNTokenCheck = true; + return true; + } + return false; + case ocColRowName: + return HandleColRowName(); + case ocDBArea: + return HandleDbData(); + case ocTableRef: + return HandleTableRef(); + case ocPush: + if( mbComputeII ) + HandleIIOpCode(mpToken.get(), nullptr, 0); + break; + default: + ; // nothing + } + } + return true; +} + + +// RPN creation by recursion +void FormulaCompiler::Factor() +{ + if (pArr->GetCodeError() != FormulaError::NONE && mbStopOnError) + return; + + CurrentFactor pFacToken( this ); + + OpCode eOp = mpToken->GetOpCode(); + if (eOp == ocPush || eOp == ocColRowNameAuto || eOp == ocMatRef || eOp == ocDBArea + || eOp == ocTableRef + || (!mbJumpCommandReorder && ((eOp == ocName) || (eOp == ocColRowName) || (eOp == ocBad))) + ) + { + PutCode( mpToken ); + eOp = NextToken(); + if( eOp == ocOpen ) + { + // PUSH( is an error that may be caused by an unknown function. + SetError( + ( mpToken->GetType() == svString + || mpToken->GetType() == svSingleRef ) + ? FormulaError::NoName : FormulaError::OperatorExpected ); + if ( bAutoCorrect && !pStack ) + { // assume multiplication + aCorrectedFormula += mxSymbols->getSymbol( ocMul); + bCorrected = true; + NextToken(); + eOp = Expression(); + if( eOp != ocClose ) + SetError( FormulaError::PairExpected); + else + NextToken(); + } + } + } + else if( eOp == ocOpen ) + { + NextToken(); + eOp = Expression(); + while ((eOp == ocSep) && (pArr->GetCodeError() == FormulaError::NONE || !mbStopOnError)) + { // range list (A1;A2) converted to (A1~A2) + pFacToken = mpToken; + NextToken(); + CheckSetForceArrayParameter( mpToken, 0); + eOp = Expression(); + // Do not ignore error here, regardless of mbStopOnError, to not + // change the formula expression in case of an unexpected state. + if (pArr->GetCodeError() == FormulaError::NONE && pc >= 2) + { + // Left and right operands must be reference or function + // returning reference to form a range list. + const FormulaToken* p = pCode[-2]; + if (p && isPotentialRangeType( p, true, false)) + { + p = pCode[-1]; + if (p && isPotentialRangeType( p, true, true)) + { + pFacToken->NewOpCode( ocUnion, FormulaToken::PrivateAccess()); + // XXX NOTE: the token's eType is still svSep here! + PutCode( pFacToken); + } + } + } + } + if (eOp != ocClose) + SetError( FormulaError::PairExpected); + else + NextToken(); + + /* TODO: if no conversion to ocUnion is involved this could collect + * such expression as a list or (matrix) vector to be passed as + * argument for one parameter (which in fact the ocUnion svRefList is a + * special case of), which would require a new StackVar type and needed + * to be handled by the interpreter for functions that could support it + * (i.e. already handle VAR_ARGS or svRefList parameters). This is also + * not defined by ODF. + * Does Excel handle =SUM((1;2))? + * As is, the interpreter catches extraneous uncalculated + * subexpressions like 1 of (1;2) as error. */ + } + else + { + if( nNumFmt == SvNumFormatType::UNDEFINED ) + nNumFmt = lcl_GetRetFormat( eOp ); + + if ( IsOpCodeVolatile( eOp) ) + pArr->SetExclusiveRecalcModeAlways(); + else + { + switch( eOp ) + { + // Functions recalculated on every document load. + // ONLOAD_LENIENT here to be able to distinguish and not + // force a recalc (if not in an ALWAYS or ONLOAD_MUST + // context) but keep an imported result from for example + // OOXML a DDE call. Will be recalculated for ODFF. + case ocConvertOOo : + case ocDde: + case ocMacro: + case ocWebservice: + pArr->AddRecalcMode( ScRecalcMode::ONLOAD_LENIENT ); + break; + // RANDBETWEEN() is volatile like RAND(). Other Add-In + // functions may have to be recalculated or not, we don't + // know, classify as ONLOAD_LENIENT. + case ocExternal: + if (mpToken->GetExternal() == "com.sun.star.sheet.addin.Analysis.getRandbetween") + pArr->SetExclusiveRecalcModeAlways(); + else + pArr->AddRecalcMode( ScRecalcMode::ONLOAD_LENIENT ); + break; + // If the referred cell is moved the value changes. + case ocColumn : + case ocRow : + pArr->SetRecalcModeOnRefMove(); + break; + // ocCell needs recalc on move for some possible type values. + // And recalc mode on load, tdf#60645 + case ocCell : + pArr->SetRecalcModeOnRefMove(); + pArr->AddRecalcMode( ScRecalcMode::ONLOAD_MUST ); + break; + case ocHyperLink : + // Cell with hyperlink needs to be calculated on load to + // get its matrix result generated. + pArr->AddRecalcMode( ScRecalcMode::ONLOAD_MUST ); + pArr->SetHyperLink( true); + break; + default: + ; // nothing + } + } + if (SC_OPCODE_START_NO_PAR <= eOp && eOp < SC_OPCODE_STOP_NO_PAR) + { + pFacToken = mpToken; + eOp = NextToken(); + if (eOp != ocOpen) + { + SetError( FormulaError::PairExpected); + PutCode( pFacToken ); + } + else + { + eOp = NextToken(); + if (eOp != ocClose) + SetError( FormulaError::PairExpected); + PutCode( pFacToken); + NextToken(); + } + } + else if (SC_OPCODE_START_1_PAR <= eOp && eOp < SC_OPCODE_STOP_1_PAR) + { + if (eOp == ocIsoWeeknum && FormulaGrammar::isODFF( meGrammar )) + { + // tdf#50950 ocIsoWeeknum can have 2 arguments when saved by older versions of Calc; + // the opcode then has to be changed to ocWeek for backward compatibility + pFacToken = mpToken; + eOp = NextToken(); + bool bNoParam = false; + if (eOp == ocOpen) + { + eOp = NextToken(); + if (eOp == ocClose) + bNoParam = true; + else + { + CheckSetForceArrayParameter( mpToken, 0); + eOp = Expression(); + } + } + else + SetError( FormulaError::PairExpected); + sal_uInt32 nSepCount = 0; + const sal_uInt16 nSepPos = maArrIterator.GetIndex() - 1; // separator position, if any + if( !bNoParam ) + { + nSepCount++; + while ((eOp == ocSep) && (pArr->GetCodeError() == FormulaError::NONE || !mbStopOnError)) + { + NextToken(); + CheckSetForceArrayParameter( mpToken, nSepCount); + nSepCount++; + if (nSepCount > FORMULA_MAXPARAMS) + SetError( FormulaError::CodeOverflow); + eOp = Expression(); + } + } + if (eOp != ocClose) + SetError( FormulaError::PairExpected); + else + NextToken(); + pFacToken->SetByte( nSepCount ); + if (nSepCount == 2) + { + // An old mode!=1 indicates ISO week, remove argument if + // literal double value and keep function. Anything else + // can not be resolved, there exists no "like ISO but week + // starts on Sunday" mode in WEEKNUM and for an expression + // we can't determine. + // Current index is nSepPos+3 if expression stops, or + // nSepPos+4 if expression continues after the call because + // we just called NextToken() to move away from it. + if (pc >= 2 && (maArrIterator.GetIndex() == nSepPos + 3 || maArrIterator.GetIndex() == nSepPos + 4) && + pArr->TokenAt(nSepPos+1)->GetType() == svDouble && + pArr->TokenAt(nSepPos+1)->GetDouble() != 1.0 && + pArr->TokenAt(nSepPos+2)->GetOpCode() == ocClose && + pArr->RemoveToken( nSepPos, 2) == 2) + { + maArrIterator.AfterRemoveToken( nSepPos, 2); + // Remove the ocPush/svDouble just removed also from + // the compiler local RPN array. + --pCode; --pc; + (*pCode)->DecRef(); // may be dead now + pFacToken->SetByte( nSepCount - 1 ); + } + else + { + // For the remaining two arguments cases use the + // compatibility function. + pFacToken->NewOpCode( ocWeeknumOOo, FormulaToken::PrivateAccess()); + } + } + PutCode( pFacToken ); + } + else + { + // standard handling of 1-parameter opcodes + pFacToken = mpToken; + eOp = NextToken(); + if( nNumFmt == SvNumFormatType::UNDEFINED && eOp == ocNot ) + nNumFmt = SvNumFormatType::LOGICAL; + if (eOp == ocOpen) + { + NextToken(); + CheckSetForceArrayParameter( mpToken, 0); + eOp = Expression(); + } + else + SetError( FormulaError::PairExpected); + if (eOp != ocClose) + SetError( FormulaError::PairExpected); + else if ( pArr->GetCodeError() == FormulaError::NONE ) + { + pFacToken->SetByte( 1 ); + if (mbComputeII) + { + FormulaToken** pArg = pCode - 1; + HandleIIOpCode(pFacToken, &pArg, 1); + } + } + PutCode( pFacToken ); + NextToken(); + } + } + else if ((SC_OPCODE_START_2_PAR <= eOp && eOp < SC_OPCODE_STOP_2_PAR) + || eOp == ocExternal + || eOp == ocMacro + || eOp == ocAnd + || eOp == ocOr + || eOp == ocBad + || ( eOp >= ocInternalBegin && eOp <= ocInternalEnd ) + || (!mbJumpCommandReorder && IsOpCodeJumpCommand(eOp))) + { + pFacToken = mpToken; + OpCode eMyLastOp = eOp; + eOp = NextToken(); + bool bNoParam = false; + bool bBadName = false; + if (eOp == ocOpen) + { + eOp = NextToken(); + if (eOp == ocClose) + bNoParam = true; + else + { + CheckSetForceArrayParameter( mpToken, 0); + eOp = Expression(); + } + } + else if (eMyLastOp == ocBad) + { + // Just a bad name, not an unknown function, no parameters, no + // closing expected. + bBadName = true; + bNoParam = true; + } + else + SetError( FormulaError::PairExpected); + sal_uInt32 nSepCount = 0; + if( !bNoParam ) + { + bool bDoIICompute = mbComputeII; + // Array of FormulaToken double pointers to collect the parameters of II opcodes. + FormulaToken*** pArgArray = nullptr; + if (bDoIICompute) + { + pArgArray = static_cast<FormulaToken***>(alloca(sizeof(FormulaToken**)*FORMULA_MAXPARAMSII)); + if (!pArgArray) + bDoIICompute = false; + } + + nSepCount++; + + if (bDoIICompute) + pArgArray[nSepCount-1] = pCode - 1; // Add first argument + + while ((eOp == ocSep) && (pArr->GetCodeError() == FormulaError::NONE || !mbStopOnError)) + { + NextToken(); + CheckSetForceArrayParameter( mpToken, nSepCount); + nSepCount++; + if (nSepCount > FORMULA_MAXPARAMS) + SetError( FormulaError::CodeOverflow); + eOp = Expression(); + if (bDoIICompute && nSepCount <= FORMULA_MAXPARAMSII) + pArgArray[nSepCount - 1] = pCode - 1; // Add rest of the arguments + } + if (bDoIICompute) + HandleIIOpCode(pFacToken, pArgArray, + std::min(nSepCount, static_cast<sal_uInt32>(FORMULA_MAXPARAMSII))); + } + bool bDone = false; + if (bBadName) + ; // nothing, keep current token for return + else if (eOp != ocClose) + SetError( FormulaError::PairExpected); + else + { + NextToken(); + bDone = true; + } + // Jumps are just normal functions for the FunctionAutoPilot tree view + if (!mbJumpCommandReorder && pFacToken->GetType() == svJump) + pFacToken = new FormulaFAPToken( pFacToken->GetOpCode(), nSepCount, pFacToken ); + else + pFacToken->SetByte( nSepCount ); + PutCode( pFacToken ); + + if (bDone) + AnnotateOperands(); + } + else if (IsOpCodeJumpCommand(eOp)) + { + // the PC counters are -1 + pFacToken = mpToken; + switch (eOp) + { + case ocIf: + pFacToken->GetJump()[ 0 ] = 3; // if, else, behind + break; + case ocChoose: + pFacToken->GetJump()[ 0 ] = FORMULA_MAXJUMPCOUNT + 1; + break; + case ocIfError: + case ocIfNA: + pFacToken->GetJump()[ 0 ] = 2; // if, behind + break; + default: + SAL_WARN("formula.core","Jump OpCode: " << +eOp); + assert(!"FormulaCompiler::Factor: someone forgot to add a jump count case"); + } + eOp = NextToken(); + if (eOp == ocOpen) + { + NextToken(); + CheckSetForceArrayParameter( mpToken, 0); + eOp = Expression(); + } + else + SetError( FormulaError::PairExpected); + PutCode( pFacToken ); + // During AutoCorrect (since pArr->GetCodeError() is + // ignored) an unlimited ocIf would crash because + // ScRawToken::Clone() allocates the JumpBuffer according to + // nJump[0]*2+2, which is 3*2+2 on ocIf and 2*2+2 ocIfError and ocIfNA. + short nJumpMax; + OpCode eFacOpCode = pFacToken->GetOpCode(); + switch (eFacOpCode) + { + case ocIf: + nJumpMax = 3; + break; + case ocChoose: + nJumpMax = FORMULA_MAXJUMPCOUNT; + break; + case ocIfError: + case ocIfNA: + nJumpMax = 2; + break; + default: + nJumpMax = 0; + SAL_WARN("formula.core","Jump OpCode: " << +eFacOpCode); + assert(!"FormulaCompiler::Factor: someone forgot to add a jump max case"); + } + short nJumpCount = 0; + while ( (nJumpCount < (FORMULA_MAXJUMPCOUNT - 1)) && (eOp == ocSep) + && (pArr->GetCodeError() == FormulaError::NONE || !mbStopOnError)) + { + if ( ++nJumpCount <= nJumpMax ) + pFacToken->GetJump()[nJumpCount] = pc-1; + NextToken(); + CheckSetForceArrayParameter( mpToken, nJumpCount - 1); + eOp = Expression(); + // ocSep or ocClose terminate the subexpression + PutCode( mpToken ); + } + if (eOp != ocClose) + SetError( FormulaError::PairExpected); + else + { + NextToken(); + // always limit to nJumpMax, no arbitrary overwrites + if ( ++nJumpCount <= nJumpMax ) + pFacToken->GetJump()[ nJumpCount ] = pc-1; + eFacOpCode = pFacToken->GetOpCode(); + bool bLimitOk; + switch (eFacOpCode) + { + case ocIf: + bLimitOk = (nJumpCount <= 3); + break; + case ocChoose: + bLimitOk = (nJumpCount < FORMULA_MAXJUMPCOUNT); + break; + case ocIfError: + case ocIfNA: + bLimitOk = (nJumpCount <= 2); + break; + default: + bLimitOk = false; + SAL_WARN("formula.core","Jump OpCode: " << +eFacOpCode); + assert(!"FormulaCompiler::Factor: someone forgot to add a jump limit case"); + } + if (bLimitOk) + pFacToken->GetJump()[ 0 ] = nJumpCount; + else + SetError( FormulaError::IllegalParameter); + } + } + else if ( eOp == ocMissing ) + { + PutCode( mpToken ); + NextToken(); + } + else if ( eOp == ocClose ) + { + SetError( FormulaError::ParameterExpected ); + } + else if ( eOp == ocSep ) + { // Subsequent ocSep + SetError( FormulaError::ParameterExpected ); + if ( bAutoCorrect && !pStack ) + { + aCorrectedSymbol.clear(); + bCorrected = true; + } + } + else if ( mpToken->IsExternalRef() ) + { + PutCode( mpToken); + NextToken(); + } + else + { + SetError( FormulaError::UnknownToken ); + if ( bAutoCorrect && !pStack ) + { + if ( eOp == ocStop ) + { // trailing operator w/o operand + sal_Int32 nLen = aCorrectedFormula.getLength(); + if ( nLen ) + aCorrectedFormula = aCorrectedFormula.copy( 0, nLen - 1 ); + aCorrectedSymbol.clear(); + bCorrected = true; + } + } + } + } +} + +void FormulaCompiler::RangeLine() +{ + Factor(); + while (mpToken->GetOpCode() == ocRange) + { + FormulaToken** pCode1 = pCode - 1; + FormulaTokenRef p = mpToken; + NextToken(); + Factor(); + FormulaToken** pCode2 = pCode - 1; + if (!MergeRangeReference( pCode1, pCode2)) + PutCode(p); + } +} + +void FormulaCompiler::IntersectionLine() +{ + RangeLine(); + while (mpToken->GetOpCode() == ocIntersect || mpToken->GetOpCode() == ocSpaces) + { + sal_uInt16 nCodeIndex = maArrIterator.GetIndex() - 1; + FormulaToken** pCode1 = pCode - 1; + FormulaTokenRef p = mpToken; + NextToken(); + RangeLine(); + FormulaToken** pCode2 = pCode - 1; + if (p->GetOpCode() == ocSpaces) + { + // Convert to intersection if both left and right are references or + // functions (potentially returning references, if not then a space + // or no space would be a syntax error anyway), not other operators + // or operands. Else discard. + if (isAdjacentOrGapRpnEnd( pc, pCode, pCode1, pCode2) && isIntersectable( pCode1, pCode2)) + { + FormulaTokenRef pIntersect( new FormulaByteToken( ocIntersect)); + // Replace ocSpaces with ocIntersect so that when switching + // formula syntax the correct operator string is created. + pArr->ReplaceToken( nCodeIndex, pIntersect.get(), FormulaTokenArray::ReplaceMode::CODE_ONLY); + PutCode( pIntersect); + } + } + else + { + PutCode(p); + } + } +} + +void FormulaCompiler::UnionLine() +{ + IntersectionLine(); + while (mpToken->GetOpCode() == ocUnion) + { + FormulaTokenRef p = mpToken; + NextToken(); + IntersectionLine(); + PutCode(p); + } +} + +void FormulaCompiler::UnaryLine() +{ + if( mpToken->GetOpCode() == ocAdd ) + GetToken(); + else if (SC_OPCODE_START_UN_OP <= mpToken->GetOpCode() && + mpToken->GetOpCode() < SC_OPCODE_STOP_UN_OP) + { + FormulaTokenRef p = mpToken; + NextToken(); + UnaryLine(); + if (mbComputeII) + { + FormulaToken** pArg = pCode - 1; + HandleIIOpCode(p.get(), &pArg, 1); + } + PutCode( p ); + } + else + UnionLine(); +} + +void FormulaCompiler::PostOpLine() +{ + UnaryLine(); + while ( mpToken->GetOpCode() == ocPercentSign ) + { // this operator _follows_ its operand + if (mbComputeII) + { + FormulaToken** pArg = pCode - 1; + HandleIIOpCode(mpToken.get(), &pArg, 1); + } + PutCode( mpToken ); + NextToken(); + } +} + +void FormulaCompiler::PowLine() +{ + PostOpLine(); + while (mpToken->GetOpCode() == ocPow) + { + FormulaTokenRef p = mpToken; + FormulaToken** pArgArray[2]; + if (mbComputeII) + pArgArray[0] = pCode - 1; // Add first argument + NextToken(); + PostOpLine(); + if (mbComputeII) + { + pArgArray[1] = pCode - 1; // Add second argument + HandleIIOpCode(p.get(), pArgArray, 2); + } + PutCode(p); + } +} + +void FormulaCompiler::MulDivLine() +{ + PowLine(); + while (mpToken->GetOpCode() == ocMul || mpToken->GetOpCode() == ocDiv) + { + FormulaTokenRef p = mpToken; + FormulaToken** pArgArray[2]; + if (mbComputeII) + pArgArray[0] = pCode - 1; // Add first argument + NextToken(); + PowLine(); + if (mbComputeII) + { + pArgArray[1] = pCode - 1; // Add second argument + HandleIIOpCode(p.get(), pArgArray, 2); + } + PutCode(p); + } +} + +void FormulaCompiler::AddSubLine() +{ + MulDivLine(); + while (mpToken->GetOpCode() == ocAdd || mpToken->GetOpCode() == ocSub) + { + FormulaTokenRef p = mpToken; + FormulaToken** pArgArray[2]; + if (mbComputeII) + pArgArray[0] = pCode - 1; // Add first argument + NextToken(); + MulDivLine(); + if (mbComputeII) + { + pArgArray[1] = pCode - 1; // Add second argument + HandleIIOpCode(p.get(), pArgArray, 2); + } + PutCode(p); + } +} + +void FormulaCompiler::ConcatLine() +{ + AddSubLine(); + while (mpToken->GetOpCode() == ocAmpersand) + { + FormulaTokenRef p = mpToken; + FormulaToken** pArgArray[2]; + if (mbComputeII) + pArgArray[0] = pCode - 1; // Add first argument + NextToken(); + AddSubLine(); + if (mbComputeII) + { + pArgArray[1] = pCode - 1; // Add second argument + HandleIIOpCode(p.get(), pArgArray, 2); + } + PutCode(p); + } +} + +void FormulaCompiler::CompareLine() +{ + ConcatLine(); + while (mpToken->GetOpCode() >= ocEqual && mpToken->GetOpCode() <= ocGreaterEqual) + { + FormulaTokenRef p = mpToken; + FormulaToken** pArgArray[2]; + if (mbComputeII) + pArgArray[0] = pCode - 1; // Add first argument + NextToken(); + ConcatLine(); + if (mbComputeII) + { + pArgArray[1] = pCode - 1; // Add second argument + HandleIIOpCode(p.get(), pArgArray, 2); + } + PutCode(p); + } +} + +OpCode FormulaCompiler::Expression() +{ + FormulaCompilerRecursionGuard aRecursionGuard( nRecursion ); + if ( nRecursion > nRecursionMax ) + { + SetError( FormulaError::StackOverflow ); + return ocStop; //! generate token instead? + } + CompareLine(); + while (mpToken->GetOpCode() == ocAnd || mpToken->GetOpCode() == ocOr) + { + FormulaTokenRef p = mpToken; + mpToken->SetByte( 2 ); // 2 parameters! + FormulaToken** pArgArray[2]; + if (mbComputeII) + pArgArray[0] = pCode - 1; // Add first argument + NextToken(); + CompareLine(); + if (mbComputeII) + { + pArgArray[1] = pCode - 1; // Add second argument + HandleIIOpCode(p.get(), pArgArray, 2); + } + PutCode(p); + } + return mpToken->GetOpCode(); +} + + +void FormulaCompiler::SetError( FormulaError /*nError*/ ) +{ +} + +FormulaTokenRef FormulaCompiler::ExtendRangeReference( FormulaToken & /*rTok1*/, FormulaToken & /*rTok2*/ ) +{ + return FormulaTokenRef(); +} + +bool FormulaCompiler::MergeRangeReference( FormulaToken * * const pCode1, FormulaToken * const * const pCode2 ) +{ + if (!isAdjacentRpnEnd( pc, pCode, pCode1, pCode2)) + return false; + + FormulaToken *p1 = *pCode1, *p2 = *pCode2; + FormulaTokenRef p = ExtendRangeReference( *p1, *p2); + if (!p) + return false; + + p->IncRef(); + p1->DecRef(); + p2->DecRef(); + *pCode1 = p.get(); + --pCode; + --pc; + + return true; +} + +bool FormulaCompiler::CompileTokenArray() +{ + glSubTotal = false; + bCorrected = false; + needsRPNTokenCheck = false; + if (pArr->GetCodeError() == FormulaError::NONE || !mbStopOnError) + { + if ( bAutoCorrect ) + { + aCorrectedFormula.clear(); + aCorrectedSymbol.clear(); + } + pArr->DelRPN(); + maArrIterator.Reset(); + pStack = nullptr; + FormulaToken* pDataArray[ FORMULA_MAXTOKENS + 1 ]; + // Code in some places refers to the last token as 'pCode - 1', which may + // point before the first element if the expression is bad. So insert a dummy + // node in that place which will make that token be nullptr. + pDataArray[ 0 ] = nullptr; + FormulaToken** pData = pDataArray + 1; + pCode = pData; + bool bWasForced = pArr->IsRecalcModeForced(); + if ( bWasForced && bAutoCorrect ) + aCorrectedFormula = "="; + pArr->ClearRecalcMode(); + maArrIterator.Reset(); + eLastOp = ocOpen; + pc = 0; + NextToken(); + OpCode eOp = Expression(); + // Some trailing garbage that doesn't form an expression? + if (eOp != ocStop) + SetError( FormulaError::OperatorExpected); + PostProcessCode(); + + FormulaError nErrorBeforePop = pArr->GetCodeError(); + + while( pStack ) + PopTokenArray(); + if( pc ) + { + pArr->CreateNewRPNArrayFromData( pData, pc ); + if( needsRPNTokenCheck ) + pArr->CheckAllRPNTokens(); + } + + // once an error, always an error + if( pArr->GetCodeError() == FormulaError::NONE && nErrorBeforePop != FormulaError::NONE ) + pArr->SetCodeError( nErrorBeforePop); + + if (pArr->GetCodeError() != FormulaError::NONE && mbStopOnError) + { + pArr->DelRPN(); + maArrIterator.Reset(); + pArr->SetHyperLink( false); + } + + if ( bWasForced ) + pArr->SetRecalcModeForced(); + } + if( nNumFmt == SvNumFormatType::UNDEFINED ) + nNumFmt = SvNumFormatType::NUMBER; + return glSubTotal; +} + +void FormulaCompiler::PopTokenArray() +{ + if( !pStack ) + return; + + FormulaArrayStack* p = pStack; + pStack = p->pNext; + // obtain special RecalcMode from SharedFormula + if ( pArr->IsRecalcModeAlways() ) + p->pArr->SetExclusiveRecalcModeAlways(); + else if ( !pArr->IsRecalcModeNormal() && p->pArr->IsRecalcModeNormal() ) + p->pArr->SetMaskedRecalcMode( pArr->GetRecalcMode() ); + p->pArr->SetCombinedBitsRecalcMode( pArr->GetRecalcMode() ); + if ( pArr->IsHyperLink() ) // fdo 87534 + p->pArr->SetHyperLink( true ); + if( p->bTemp ) + delete pArr; + pArr = p->pArr; + maArrIterator = FormulaTokenArrayPlainIterator(*pArr); + maArrIterator.Jump(p->nIndex); + mpLastToken = p->mpLastToken; + delete p; +} + +void FormulaCompiler::CreateStringFromTokenArray( OUString& rFormula ) +{ + OUStringBuffer aBuffer( pArr->GetLen() * 5 ); + CreateStringFromTokenArray( aBuffer ); + rFormula = aBuffer.makeStringAndClear(); +} + +void FormulaCompiler::CreateStringFromTokenArray( OUStringBuffer& rBuffer ) +{ + rBuffer.setLength(0); + if( !pArr->GetLen() ) + return; + + FormulaTokenArray* pSaveArr = pArr; + int nSaveIndex = maArrIterator.GetIndex(); + bool bODFF = FormulaGrammar::isODFF( meGrammar); + if (bODFF || FormulaGrammar::isPODF( meGrammar) ) + { + // Scan token array for missing args and re-write if present. + MissingConventionODF aConv( bODFF); + if (pArr->NeedsPodfRewrite( aConv)) + { + pArr = pArr->RewriteMissing( aConv ); + maArrIterator = FormulaTokenArrayPlainIterator( *pArr ); + } + } + else if ( FormulaGrammar::isOOXML( meGrammar ) ) + { + // Scan token array for missing args and rewrite if present. + if (pArr->NeedsOoxmlRewrite()) + { + MissingConventionOOXML aConv; + pArr = pArr->RewriteMissing( aConv ); + maArrIterator = FormulaTokenArrayPlainIterator( *pArr ); + } + } + + // At least one character per token, plus some are references, some are + // function names, some are numbers, ... + rBuffer.ensureCapacity( pArr->GetLen() * 5 ); + + if ( pArr->IsRecalcModeForced() ) + rBuffer.append( '='); + const FormulaToken* t = maArrIterator.First(); + while( t ) + t = CreateStringFromToken( rBuffer, t, true ); + + if (pSaveArr != pArr) + { + delete pArr; + pArr = pSaveArr; + maArrIterator = FormulaTokenArrayPlainIterator( *pArr ); + maArrIterator.Jump(nSaveIndex); + } +} + +const FormulaToken* FormulaCompiler::CreateStringFromToken( OUString& rFormula, const FormulaToken* pTokenP ) +{ + OUStringBuffer aBuffer; + const FormulaToken* p = CreateStringFromToken( aBuffer, pTokenP ); + rFormula += aBuffer; + return p; +} + +const FormulaToken* FormulaCompiler::CreateStringFromToken( OUStringBuffer& rBuffer, const FormulaToken* pTokenP, + bool bAllowArrAdvance ) +{ + bool bNext = true; + bool bSpaces = false; + const FormulaToken* t = pTokenP; + OpCode eOp = t->GetOpCode(); + if( eOp >= ocAnd && eOp <= ocOr ) + { + // AND, OR infix? + if ( bAllowArrAdvance ) + t = maArrIterator.Next(); + else + t = maArrIterator.PeekNext(); + bNext = false; + bSpaces = ( !t || t->GetOpCode() != ocOpen ); + } + if( bSpaces ) + rBuffer.append( ' '); + + if (eOp == ocSpaces || eOp == ocWhitespace) + { + bool bWriteSpaces = true; + if (eOp == ocSpaces && mxSymbols->isODFF()) + { + const FormulaToken* p = maArrIterator.PeekPrevNoSpaces(); + bool bIntersectionOp = (p && p->GetOpCode() == ocColRowName); + if (bIntersectionOp) + { + p = maArrIterator.PeekNextNoSpaces(); + bIntersectionOp = (p && p->GetOpCode() == ocColRowName); + } + if (bIntersectionOp) + { + rBuffer.append( "!!"); + bWriteSpaces = false; + } + } + if (bWriteSpaces) + { + // ODF v1.3 OpenFormula 5.14 Whitespace states "whitespace shall + // not separate a function name from its initial opening + // parenthesis". + // + // ECMA-376-1:2016 18.17.2 Syntax states "that no space characters + // shall separate a function-name from the left parenthesis (() + // that follows it." and Excel even chokes on it. + // + // Suppress/remove it in any case also in UI, it will not be + // preserved. + const FormulaToken* p = maArrIterator.PeekPrevNoSpaces(); + if (p && p->IsFunction()) + { + p = maArrIterator.PeekNextNoSpaces(); + if (p && p->GetOpCode() == ocOpen) + bWriteSpaces = false; + } + } + if (bWriteSpaces) + { + // most times it's just one blank + sal_uInt8 n = t->GetByte(); + for ( sal_uInt8 j=0; j<n; ++j ) + { + if (eOp == ocWhitespace) + rBuffer.append( t->GetChar()); + else + rBuffer.append( ' '); + } + } + } + else if( eOp >= ocInternalBegin && eOp <= ocInternalEnd ) + rBuffer.appendAscii( pInternal[ eOp - ocInternalBegin ] ); + else if (eOp == ocIntersect) + { + // Nasty, ugly, horrific, terrifying... + if (FormulaGrammar::isExcelSyntax( meGrammar)) + rBuffer.append(' '); + else + rBuffer.append( mxSymbols->getSymbol( eOp)); + } + else if( static_cast<sal_uInt16>(eOp) < mxSymbols->getSymbolCount()) // Keyword: + rBuffer.append( mxSymbols->getSymbol( eOp)); + else + { + SAL_WARN( "formula.core","unknown OpCode"); + rBuffer.append( GetNativeSymbol( ocErrName )); + } + if( bNext ) + { + if (t->IsExternalRef()) + { + CreateStringFromExternal( rBuffer, pTokenP); + } + else + { + switch( t->GetType() ) + { + case svDouble: + AppendDouble( rBuffer, t->GetDouble() ); + break; + + case svString: + if( eOp == ocBad || eOp == ocStringXML ) + rBuffer.append( t->GetString().getString()); + else + AppendString( rBuffer, t->GetString().getString() ); + break; + case svSingleRef: + CreateStringFromSingleRef( rBuffer, t); + break; + case svDoubleRef: + CreateStringFromDoubleRef( rBuffer, t); + break; + case svMatrix: + case svMatrixCell: + CreateStringFromMatrix( rBuffer, t ); + break; + + case svIndex: + CreateStringFromIndex( rBuffer, t ); + if (t->GetOpCode() == ocTableRef && bAllowArrAdvance && NeedsTableRefTransformation()) + { + // Suppress all TableRef related tokens, the resulting + // range was written by CreateStringFromIndex(). + const FormulaToken* const p = maArrIterator.PeekNext(); + if (p && p->GetOpCode() == ocTableRefOpen) + { + int nLevel = 0; + do + { + t = maArrIterator.Next(); + if (!t) + break; + + // Switch cases correspond with those in + // ScCompiler::HandleTableRef() + switch (t->GetOpCode()) + { + case ocTableRefOpen: + ++nLevel; + break; + case ocTableRefClose: + --nLevel; + break; + case ocTableRefItemAll: + case ocTableRefItemHeaders: + case ocTableRefItemData: + case ocTableRefItemTotals: + case ocTableRefItemThisRow: + case ocSep: + case ocPush: + case ocRange: + case ocSpaces: + case ocWhitespace: + break; + default: + nLevel = 0; + bNext = false; + } + } while (nLevel); + } + } + break; + case svExternal: + { + // mapped or translated name of AddIns + OUString aAddIn( t->GetExternal() ); + bool bMapped = mxSymbols->isPODF(); // ODF 1.1 directly uses programmatical name + if (!bMapped && mxSymbols->hasExternals()) + { + ExternalHashMap::const_iterator iLook = mxSymbols->getReverseExternalHashMap().find( aAddIn); + if (iLook != mxSymbols->getReverseExternalHashMap().end()) + { + aAddIn = (*iLook).second; + bMapped = true; + } + } + if (!bMapped && !mxSymbols->isEnglish()) + LocalizeString( aAddIn ); + rBuffer.append( aAddIn); + } + break; + case svError: + AppendErrorConstant( rBuffer, t->GetError()); + break; + case svByte: + case svJump: + case svFAP: + case svMissing: + case svSep: + break; // Opcodes + default: + SAL_WARN("formula.core", "FormulaCompiler::GetStringFromToken: unknown token type " << t->GetType()); + } // of switch + } + } + if( bSpaces ) + rBuffer.append( ' '); + if ( bAllowArrAdvance ) + { + if( bNext ) + t = maArrIterator.Next(); + return t; + } + return pTokenP; +} + + +void FormulaCompiler::AppendDouble( OUStringBuffer& rBuffer, double fVal ) const +{ + if ( mxSymbols->isEnglishLocale() ) + { + ::rtl::math::doubleToUStringBuffer( rBuffer, fVal, + rtl_math_StringFormat_Automatic, + rtl_math_DecimalPlaces_Max, '.', true ); + } + else + { + SvtSysLocale aSysLocale; + ::rtl::math::doubleToUStringBuffer( rBuffer, fVal, + rtl_math_StringFormat_Automatic, + rtl_math_DecimalPlaces_Max, + aSysLocale.GetLocaleData().getNumDecimalSep()[0], + true ); + } +} + +void FormulaCompiler::AppendBoolean( OUStringBuffer& rBuffer, bool bVal ) const +{ + rBuffer.append( mxSymbols->getSymbol( bVal ? ocTrue : ocFalse ) ); +} + +void FormulaCompiler::AppendString( OUStringBuffer& rBuffer, const OUString & rStr ) +{ + rBuffer.append( '"'); + if ( lcl_UnicodeStrChr( rStr.getStr(), '"' ) == nullptr ) + rBuffer.append( rStr ); + else + { + OUString aStr = rStr.replaceAll( "\"", "\"\"" ); + rBuffer.append(aStr); + } + rBuffer.append( '"'); +} + +bool FormulaCompiler::NeedsTableRefTransformation() const +{ + // Currently only UI representations and OOXML export use Table structured + // references. Not defined in ODFF. + // Unnecessary to explicitly check for ODFF grammar as the ocTableRefOpen + // symbol is not defined there. + return mxSymbols->getSymbol( ocTableRefOpen).isEmpty() || FormulaGrammar::isPODF( meGrammar); +} + +void FormulaCompiler::UpdateSeparatorsNative( + const OUString& rSep, const OUString& rArrayColSep, const OUString& rArrayRowSep ) +{ + NonConstOpCodeMapPtr xSymbolsNative; + lcl_fillNativeSymbols( xSymbolsNative); + xSymbolsNative->putOpCode( rSep, ocSep, nullptr); + xSymbolsNative->putOpCode( rArrayColSep, ocArrayColSep, nullptr); + xSymbolsNative->putOpCode( rArrayRowSep, ocArrayRowSep, nullptr); +} + +void FormulaCompiler::ResetNativeSymbols() +{ + NonConstOpCodeMapPtr xSymbolsNative; + lcl_fillNativeSymbols( xSymbolsNative, InitSymbols::DESTROY); + lcl_fillNativeSymbols( xSymbolsNative); +} + +void FormulaCompiler::SetNativeSymbols( const OpCodeMapPtr& xMap ) +{ + NonConstOpCodeMapPtr xSymbolsNative; + lcl_fillNativeSymbols( xSymbolsNative); + xSymbolsNative->copyFrom( *xMap ); +} + + +OpCode FormulaCompiler::NextToken() +{ + if( !GetToken() ) + return ocStop; + OpCode eOp = mpToken->GetOpCode(); + // There must be an operator before a push + if ( (eOp == ocPush || eOp == ocColRowNameAuto) && + !( (eLastOp == ocOpen) || (eLastOp == ocSep) || + (SC_OPCODE_START_BIN_OP <= eLastOp && eLastOp < SC_OPCODE_STOP_UN_OP)) ) + SetError( FormulaError::OperatorExpected); + // Operator and Plus => operator + if (eOp == ocAdd && (eLastOp == ocOpen || eLastOp == ocSep || + (SC_OPCODE_START_BIN_OP <= eLastOp && eLastOp < SC_OPCODE_STOP_UN_OP))) + { + FormulaCompilerRecursionGuard aRecursionGuard( nRecursion ); + eOp = NextToken(); + } + else + { + // Before an operator there must not be another operator, with the + // exception of AND and OR. + if ( eOp != ocAnd && eOp != ocOr && + (SC_OPCODE_START_BIN_OP <= eOp && eOp < SC_OPCODE_STOP_BIN_OP ) + && (eLastOp == ocOpen || eLastOp == ocSep || + (SC_OPCODE_START_BIN_OP <= eLastOp && eLastOp < SC_OPCODE_STOP_UN_OP))) + { + SetError( FormulaError::VariableExpected); + if ( bAutoCorrect && !pStack ) + { + if ( eOp == eLastOp || eLastOp == ocOpen ) + { // throw away duplicated operator + aCorrectedSymbol.clear(); + bCorrected = true; + } + else + { + sal_Int32 nPos = aCorrectedFormula.getLength(); + if ( nPos ) + { + nPos--; + sal_Unicode c = aCorrectedFormula[ nPos ]; + switch ( eOp ) + { // swap operators + case ocGreater: + if ( c == mxSymbols->getSymbolChar( ocEqual) ) + { // >= instead of => + aCorrectedFormula = aCorrectedFormula.replaceAt( nPos, 1, + rtl::OUStringChar( mxSymbols->getSymbolChar(ocGreater) ) ); + aCorrectedSymbol = OUString(c); + bCorrected = true; + } + break; + case ocLess: + if ( c == mxSymbols->getSymbolChar( ocEqual) ) + { // <= instead of =< + aCorrectedFormula = aCorrectedFormula.replaceAt( nPos, 1, + rtl::OUStringChar( mxSymbols->getSymbolChar(ocLess) ) ); + aCorrectedSymbol = OUString(c); + bCorrected = true; + } + else if ( c == mxSymbols->getSymbolChar( ocGreater) ) + { // <> instead of >< + aCorrectedFormula = aCorrectedFormula.replaceAt( nPos, 1, + rtl::OUStringChar( mxSymbols->getSymbolChar(ocLess) ) ); + aCorrectedSymbol = OUString(c); + bCorrected = true; + } + break; + case ocMul: + if ( c == mxSymbols->getSymbolChar( ocSub) ) + { // *- instead of -* + aCorrectedFormula = aCorrectedFormula.replaceAt( nPos, 1, + rtl::OUStringChar( mxSymbols->getSymbolChar(ocMul) ) ); + aCorrectedSymbol = OUString(c); + bCorrected = true; + } + break; + case ocDiv: + if ( c == mxSymbols->getSymbolChar( ocSub) ) + { // /- instead of -/ + aCorrectedFormula = aCorrectedFormula.replaceAt( nPos, 1, + rtl::OUStringChar( mxSymbols->getSymbolChar(ocDiv) ) ); + aCorrectedSymbol = OUString(c); + bCorrected = true; + } + break; + default: + ; // nothing + } + } + } + } + } + // Nasty, ugly, horrific, terrifying... significant whitespace... + if (eOp == ocSpaces && FormulaGrammar::isExcelSyntax( meGrammar)) + { + // Fake an intersection op as last op for the next round, but at + // least roughly check if it could make sense at all. + FormulaToken* pPrev = maArrIterator.PeekPrevNoSpaces(); + if (pPrev && isPotentialRangeType( pPrev, false, false)) + { + FormulaToken* pNext = maArrIterator.PeekNextNoSpaces(); + if (pNext && isPotentialRangeType( pNext, false, true)) + eLastOp = ocIntersect; + else + eLastOp = eOp; + } + else + eLastOp = eOp; + } + else + eLastOp = eOp; + } + return eOp; +} + +void FormulaCompiler::PutCode( FormulaTokenRef& p ) +{ + if( pc >= FORMULA_MAXTOKENS - 1 ) + { + if ( pc == FORMULA_MAXTOKENS - 1 ) + { + p = new FormulaByteToken( ocStop ); + p->IncRef(); + *pCode++ = p.get(); + ++pc; + } + SetError( FormulaError::CodeOverflow); + return; + } + if (pArr->GetCodeError() != FormulaError::NONE && mbJumpCommandReorder) + return; + ForceArrayOperator( p); + p->IncRef(); + *pCode++ = p.get(); + pc++; +} + + +bool FormulaCompiler::HandleExternalReference( const FormulaToken& /*_aToken*/) +{ + return true; +} + +bool FormulaCompiler::HandleRange() +{ + return true; +} + +bool FormulaCompiler::HandleColRowName() +{ + return true; +} + +bool FormulaCompiler::HandleDbData() +{ + return true; +} + +bool FormulaCompiler::HandleTableRef() +{ + return true; +} + +void FormulaCompiler::CreateStringFromSingleRef( OUStringBuffer& /*rBuffer*/, const FormulaToken* /*pToken*/) const +{ +} + +void FormulaCompiler::CreateStringFromDoubleRef( OUStringBuffer& /*rBuffer*/, const FormulaToken* /*pToken*/) const +{ +} + +void FormulaCompiler::CreateStringFromIndex( OUStringBuffer& /*rBuffer*/, const FormulaToken* /*pToken*/) const +{ +} + +void FormulaCompiler::CreateStringFromMatrix( OUStringBuffer& /*rBuffer*/, const FormulaToken* /*pToken*/) const +{ +} + +void FormulaCompiler::CreateStringFromExternal( OUStringBuffer& /*rBuffer*/, const FormulaToken* /*pToken*/) const +{ +} + +void FormulaCompiler::LocalizeString( OUString& /*rName*/ ) const +{ +} + +formula::ParamClass FormulaCompiler::GetForceArrayParameter( const FormulaToken* /*pToken*/, sal_uInt16 /*nParam*/ ) const +{ + return ParamClass::Unknown; +} + +void FormulaCompiler::ForceArrayOperator( FormulaTokenRef const & rCurr ) +{ + if (pCurrentFactorToken.get() == rCurr.get()) + return; + + const OpCode eOp = rCurr->GetOpCode(); + const StackVar eType = rCurr->GetType(); + const bool bInlineArray = (eOp == ocPush && eType == svMatrix); + + if (!bInlineArray) + { + if (rCurr->GetInForceArray() != ParamClass::Unknown) + // Already set, unnecessary to evaluate again. This happens by calls to + // CurrentFactor::operator=() while descending through Factor() and + // then ascending back (and down and up, ...), + // CheckSetForceArrayParameter() and later PutCode(). + return; + + if (!(eOp != ocPush && (eType == svByte || eType == svJump))) + return; + } + + // Return class for inline arrays and functions returning array/matrix. + // It's somewhat unclear what Excel actually does there and in + // ECMA-376-1:2016 OOXML mentions "call to ... shall be an array formula" + // only for FREQUENCY() and TRANSPOSE() but not for any other function + // returning array/matrix or inline arrays, though for the latter has one + // example in 18.17.2 Syntax: + // "SUM(SQRT({1,2,3,4})) returns 6.14 when entered normally". However, + // these need to be treated similar but not as ParamClass::ForceArray + // (which would contradict the example in + // https://bugs.documentfoundation.org/show_bug.cgi?id=122301#c19 and A6 of + // https://bugs.documentfoundation.org/show_bug.cgi?id=133260#c10 ). + // See also + // commit d0ded163d8e93dc5b10d7a7c9bdab1d0a6a50bac + // commit 5413c8871dec08eff19f514f5f391b946a45c86c + constexpr ParamClass eArrayReturn = ParamClass::ForceArrayReturn; + + if (bInlineArray) + { + // rCurr->SetInForceArray() can not be used with ocPush, but ocPush + // with svMatrix has an implicit ParamClass::ForceArrayReturn. + if (nCurrentFactorParam > 0 && pCurrentFactorToken + && pCurrentFactorToken->GetInForceArray() == ParamClass::Unknown + && GetForceArrayParameter( pCurrentFactorToken.get(), static_cast<sal_uInt16>(nCurrentFactorParam - 1)) + == ParamClass::Value) + { + // Propagate to caller as if a function returning an array/matrix + // was called (see also below). + pCurrentFactorToken->SetInForceArray( eArrayReturn); + } + return; + } + + if (!pCurrentFactorToken) + { + if (mbMatrixFlag) + { + // An array/matrix formula acts as ForceArray on all top level + // operators and function calls, so that can be inherited properly + // below. + rCurr->SetInForceArray( ParamClass::ForceArray); + } + else if (pc >= 2 && SC_OPCODE_START_BIN_OP <= eOp && eOp < SC_OPCODE_STOP_BIN_OP) + { + // Binary operators are not functions followed by arguments + // and need some peeking into RPN to inspect their operands. + // Note that array context is not forced if only one + // of the operands is an array like "={1;2}+A1:A2" returns #VALUE! + // if entered in column A and not input in array mode, because it + // involves a range reference with an implicit intersection. Check + // both arguments are arrays, or the other is ocPush without ranges + // for "={1;2}+3" or "={1;2}+A1". + // Note this does not catch "={1;2}+ABS(A1)" that could be forced + // to array, user still has to close in array mode. + // The IsMatrixFunction() is only necessary because not all + // functions returning matrix have ForceArrayReturn (yet?), see + // OOXML comment above. + + const OpCode eOp1 = pCode[-1]->GetOpCode(); + const OpCode eOp2 = pCode[-2]->GetOpCode(); + const bool b1 = (pCode[-1]->GetInForceArray() != ParamClass::Unknown || IsMatrixFunction(eOp1)); + const bool b2 = (pCode[-2]->GetInForceArray() != ParamClass::Unknown || IsMatrixFunction(eOp2)); + if ((b1 && b2) + || (b1 && eOp2 == ocPush && pCode[-2]->GetType() != svDoubleRef) + || (b2 && eOp1 == ocPush && pCode[-1]->GetType() != svDoubleRef)) + { + rCurr->SetInForceArray( eArrayReturn); + } + } + else if (pc >= 1 && SC_OPCODE_START_UN_OP <= eOp && eOp < SC_OPCODE_STOP_UN_OP) + { + // Similar for unary operators. + if (pCode[-1]->GetInForceArray() != ParamClass::Unknown || IsMatrixFunction(pCode[-1]->GetOpCode())) + { + rCurr->SetInForceArray( eArrayReturn); + } + } + return; + } + + // Inherited parameter class. + const formula::ParamClass eForceType = pCurrentFactorToken->GetInForceArray(); + if (eForceType == ParamClass::ForceArray || eForceType == ParamClass::ReferenceOrRefArray) + { + // ReferenceOrRefArray was set only if in ForceArray context already, + // it is valid for the one function only to indicate the preferred + // return type. Propagate as ForceArray if not another parameter + // handling ReferenceOrRefArray. + if (nCurrentFactorParam > 0 + && (GetForceArrayParameter( pCurrentFactorToken.get(), static_cast<sal_uInt16>(nCurrentFactorParam - 1)) + == ParamClass::ReferenceOrRefArray)) + rCurr->SetInForceArray( ParamClass::ReferenceOrRefArray); + else + rCurr->SetInForceArray( ParamClass::ForceArray); + return; + } + else if (eForceType == ParamClass::ReferenceOrForceArray) + { + // Inherit further only if the return class of the nested function is + // not Reference. Else flag as suppressed. + if (GetForceArrayParameter( rCurr.get(), SAL_MAX_UINT16) != ParamClass::Reference) + rCurr->SetInForceArray( eForceType); + else + rCurr->SetInForceArray( ParamClass::SuppressedReferenceOrForceArray); + return; + } + + if (nCurrentFactorParam <= 0) + return; + + // Actual current parameter's class. + const formula::ParamClass eParamType = GetForceArrayParameter( + pCurrentFactorToken.get(), static_cast<sal_uInt16>(nCurrentFactorParam - 1)); + if (eParamType == ParamClass::ForceArray) + rCurr->SetInForceArray( eParamType); + else if (eParamType == ParamClass::ReferenceOrForceArray) + { + if (GetForceArrayParameter( rCurr.get(), SAL_MAX_UINT16) != ParamClass::Reference) + rCurr->SetInForceArray( eParamType); + else + rCurr->SetInForceArray( formula::ParamClass::SuppressedReferenceOrForceArray); + } + + // Propagate a ForceArrayReturn to caller if the called function + // returns one and the caller so far does not have a stronger array + // mode set and expects a scalar value for this parameter. + if (eParamType == ParamClass::Value && pCurrentFactorToken->GetInForceArray() == ParamClass::Unknown) + { + if (IsMatrixFunction( eOp)) + pCurrentFactorToken->SetInForceArray( eArrayReturn); + else if (GetForceArrayParameter( rCurr.get(), SAL_MAX_UINT16) == ParamClass::ForceArrayReturn) + pCurrentFactorToken->SetInForceArray( ParamClass::ForceArrayReturn); + } +} + +void FormulaCompiler::CheckSetForceArrayParameter( FormulaTokenRef const & rCurr, sal_uInt8 nParam ) +{ + if (!pCurrentFactorToken) + return; + + nCurrentFactorParam = nParam + 1; + + ForceArrayOperator( rCurr); +} + +void FormulaCompiler::PushTokenArray( FormulaTokenArray* pa, bool bTemp ) +{ + if ( bAutoCorrect && !pStack ) + { // don't merge stacked subroutine code into entered formula + aCorrectedFormula += aCorrectedSymbol; + aCorrectedSymbol.clear(); + } + FormulaArrayStack* p = new FormulaArrayStack; + p->pNext = pStack; + p->pArr = pArr; + p->nIndex = maArrIterator.GetIndex(); + p->mpLastToken = mpLastToken; + p->bTemp = bTemp; + pStack = p; + pArr = pa; + maArrIterator = FormulaTokenArrayPlainIterator( *pArr ); +} + +} // namespace formula + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/formula/source/core/api/FormulaOpCodeMapperObj.cxx b/formula/source/core/api/FormulaOpCodeMapperObj.cxx new file mode 100644 index 000000000..a3ffe56cc --- /dev/null +++ b/formula/source/core/api/FormulaOpCodeMapperObj.cxx @@ -0,0 +1,104 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include <memory> +#include <sal/config.h> + +#include <utility> + +#include <formula/FormulaCompiler.hxx> +#include <formula/FormulaOpCodeMapperObj.hxx> +#include <formula/opcode.hxx> +#include <cppuhelper/supportsservice.hxx> +#include <com/sun/star/lang/IllegalArgumentException.hpp> + +namespace formula +{ + using namespace ::com::sun::star; + +sal_Bool SAL_CALL FormulaOpCodeMapperObj::supportsService( const OUString& _rServiceName ) +{ + return cppu::supportsService(this, _rServiceName); +} + +FormulaOpCodeMapperObj::FormulaOpCodeMapperObj(::std::unique_ptr<FormulaCompiler> && _pCompiler) +: m_pCompiler(std::move(_pCompiler)) +{ +} + +FormulaOpCodeMapperObj::~FormulaOpCodeMapperObj() +{ +} + +::sal_Int32 SAL_CALL FormulaOpCodeMapperObj::getOpCodeExternal() +{ + return ocExternal; +} + + +::sal_Int32 SAL_CALL FormulaOpCodeMapperObj::getOpCodeUnknown() +{ + return FormulaCompiler::OpCodeMap::getOpCodeUnknown(); +} + + +css::uno::Sequence< css::sheet::FormulaToken > +SAL_CALL FormulaOpCodeMapperObj::getMappings( + const css::uno::Sequence< OUString >& rNames, + sal_Int32 nLanguage ) +{ + FormulaCompiler::OpCodeMapPtr xMap = m_pCompiler->GetOpCodeMap( nLanguage); + if (!xMap) + throw lang::IllegalArgumentException(); + return xMap->createSequenceOfFormulaTokens( *m_pCompiler,rNames); +} + + +css::uno::Sequence< css::sheet::FormulaOpCodeMapEntry > +SAL_CALL FormulaOpCodeMapperObj::getAvailableMappings( + sal_Int32 nLanguage, sal_Int32 nGroups ) +{ + FormulaCompiler::OpCodeMapPtr xMap = m_pCompiler->GetOpCodeMap( nLanguage); + if (!xMap) + throw lang::IllegalArgumentException(); + return xMap->createSequenceOfAvailableMappings( *m_pCompiler,nGroups); +} + +OUString SAL_CALL FormulaOpCodeMapperObj::getImplementationName( ) +{ + return "simple.formula.FormulaOpCodeMapperObj"; +} + +uno::Sequence< OUString > SAL_CALL FormulaOpCodeMapperObj::getSupportedServiceNames( ) +{ + return { "com.sun.star.sheet.FormulaOpCodeMapper" }; +} + +} // formula + +extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface* +simple_formula_FormulaOpCodeMapperObj( + css::uno::XComponentContext* , css::uno::Sequence<css::uno::Any> const& ) +{ + return cppu::acquire( + new formula::FormulaOpCodeMapperObj(std::make_unique<formula::FormulaCompiler>())); +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/formula/source/core/api/grammar.cxx b/formula/source/core/api/grammar.cxx new file mode 100644 index 000000000..3974ee28d --- /dev/null +++ b/formula/source/core/api/grammar.cxx @@ -0,0 +1,87 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include <formula/grammar.hxx> +#include <cassert> + +namespace formula { + +FormulaGrammar::Grammar FormulaGrammar::mapAPItoGrammar( const bool bEnglish, const bool bXML ) +{ + Grammar eGrammar; + if (bEnglish && bXML) + eGrammar = GRAM_PODF; + else if (bEnglish && !bXML) + eGrammar = GRAM_API; + else if (!bEnglish && bXML) + eGrammar = GRAM_NATIVE_ODF; + else // (!bEnglish && !bXML) + eGrammar = GRAM_NATIVE; + return eGrammar; +} + +bool FormulaGrammar::isSupported( const Grammar eGrammar ) +{ + switch (eGrammar) + { + case GRAM_ODFF : + case GRAM_PODF : + case GRAM_ENGLISH : + case GRAM_NATIVE : + case GRAM_ODFF_UI : + case GRAM_ODFF_A1 : + case GRAM_PODF_UI : + case GRAM_PODF_A1 : + case GRAM_NATIVE_UI : + case GRAM_NATIVE_ODF : + case GRAM_NATIVE_XL_A1 : + case GRAM_NATIVE_XL_R1C1 : + case GRAM_ENGLISH_XL_A1 : + case GRAM_ENGLISH_XL_R1C1: + case GRAM_ENGLISH_XL_OOX : + case GRAM_OOXML : + case GRAM_API : + return true; + default: + return extractFormulaLanguage( eGrammar) == GRAM_EXTERNAL; + } +} + +FormulaGrammar::Grammar FormulaGrammar::setEnglishBit( const Grammar eGrammar, const bool bEnglish ) +{ + if (bEnglish) + return static_cast<Grammar>( eGrammar | kEnglishBit); + else + return static_cast<Grammar>( eGrammar & ~kEnglishBit); +} + +FormulaGrammar::Grammar FormulaGrammar::mergeToGrammar( const Grammar eGrammar, const AddressConvention eConv ) +{ + bool bEnglish = isEnglish( eGrammar); + Grammar eGram = static_cast<Grammar>( + extractFormulaLanguage( eGrammar) | + ((eConv + kConventionOffset) << kConventionShift)); + eGram = setEnglishBit( eGram, bEnglish); + assert( isSupported( eGram)); + return eGram; +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/formula/source/core/api/token.cxx b/formula/source/core/api/token.cxx new file mode 100644 index 000000000..f194a4f74 --- /dev/null +++ b/formula/source/core/api/token.cxx @@ -0,0 +1,2032 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + + +#include <algorithm> + +#include <string.h> +#include <limits.h> +#include <osl/diagnose.h> +#include <sal/log.hxx> + +#include <com/sun/star/sheet/FormulaToken.hpp> +#include <formula/errorcodes.hxx> +#include <formula/token.hxx> +#include <formula/tokenarray.hxx> +#include <formula/FormulaCompiler.hxx> +#include <formula/compiler.hxx> +#include <svl/sharedstringpool.hxx> +#include <memory> + +namespace formula +{ + using namespace com::sun::star; + + +// --- helpers -------------------------------------------------------------- + +static bool lcl_IsReference( OpCode eOp, StackVar eType ) +{ + return + (eOp == ocPush && (eType == svSingleRef || eType == svDoubleRef)) + || (eOp == ocColRowNameAuto && eType == svDoubleRef) + || (eOp == ocColRowName && eType == svSingleRef) + || (eOp == ocMatRef && eType == svSingleRef) + ; +} + +// --- class FormulaToken -------------------------------------------------------- + +FormulaToken::FormulaToken( StackVar eTypeP, OpCode e ) : + eOp(e), eType( eTypeP ), mnRefCnt(0) +{ +} + +FormulaToken::FormulaToken( const FormulaToken& r ) : + eOp(r.eOp), eType( r.eType ), mnRefCnt(0) +{ +} + +FormulaToken::~FormulaToken() +{ +} + +bool FormulaToken::IsFunction() const +{ + return (eOp != ocPush && eOp != ocBad && eOp != ocColRowName && + eOp != ocColRowNameAuto && eOp != ocName && eOp != ocDBArea && + eOp != ocTableRef && + (GetByte() != 0 // x parameters + || (SC_OPCODE_START_NO_PAR <= eOp && eOp < SC_OPCODE_STOP_NO_PAR) // no parameter + || FormulaCompiler::IsOpCodeJumpCommand( eOp ) // @ jump commands + || (SC_OPCODE_START_1_PAR <= eOp && eOp < SC_OPCODE_STOP_1_PAR) // one parameter + || (SC_OPCODE_START_2_PAR <= eOp && eOp < SC_OPCODE_STOP_2_PAR) // x parameters (cByte==0 in + // FuncAutoPilot) + || eOp == ocMacro || eOp == ocExternal // macros, AddIns + || eOp == ocAnd || eOp == ocOr // former binary, now x parameters + || (eOp >= ocInternalBegin && eOp <= ocInternalEnd) // internal + )); +} + + +sal_uInt8 FormulaToken::GetParamCount() const +{ + if ( eOp < SC_OPCODE_STOP_DIV && eOp != ocExternal && eOp != ocMacro && + !FormulaCompiler::IsOpCodeJumpCommand( eOp ) && + eOp != ocPercentSign ) + return 0; // parameters and specials + // ocIf... jump commands not for FAP, have cByte then +//2do: bool parameter whether FAP or not? + else if (GetByte()) + return GetByte(); // all functions, also ocExternal and ocMacro + else if (SC_OPCODE_START_BIN_OP <= eOp && eOp < SC_OPCODE_STOP_BIN_OP && eOp != ocAnd && eOp != ocOr) + return 2; // binary operators, compiler checked; OR and AND legacy but are functions + else if ((SC_OPCODE_START_UN_OP <= eOp && eOp < SC_OPCODE_STOP_UN_OP) || eOp == ocPercentSign) + return 1; // unary operators, compiler checked + else if (SC_OPCODE_START_NO_PAR <= eOp && eOp < SC_OPCODE_STOP_NO_PAR) + return 0; // no parameter + else if (FormulaCompiler::IsOpCodeJumpCommand( eOp )) + return 1; // only the condition counts as parameter + else + return 0; // all the rest, no Parameter, or + // if so then it should be in cByte +} + +bool FormulaToken::IsExternalRef() const +{ + bool bRet = false; + switch (eType) + { + case svExternalSingleRef: + case svExternalDoubleRef: + case svExternalName: + bRet = true; + break; + default: + bRet = false; + break; + } + return bRet; +} + +bool FormulaToken::IsRef() const +{ + switch (eType) + { + case svSingleRef: + case svDoubleRef: + case svExternalSingleRef: + case svExternalDoubleRef: + return true; + default: + if (eOp == ocTableRef) + return true; + } + + return false; +} + +bool FormulaToken::IsInForceArray() const +{ + ParamClass eParam = GetInForceArray(); + return eParam == ParamClass::ForceArray || eParam == ParamClass::ReferenceOrForceArray + || eParam == ParamClass::ReferenceOrRefArray || eParam == ParamClass::ForceArrayReturn; +} + +bool FormulaToken::operator==( const FormulaToken& rToken ) const +{ + // don't compare reference count! + return eType == rToken.eType && GetOpCode() == rToken.GetOpCode(); +} + + +// --- virtual dummy methods ------------------------------------------------- + +sal_uInt8 FormulaToken::GetByte() const +{ + // ok to be called for any derived class + return 0; +} + +void FormulaToken::SetByte( sal_uInt8 ) +{ + assert( !"virtual dummy called" ); +} + +ParamClass FormulaToken::GetInForceArray() const +{ + // ok to be called for any derived class + return (eOp == ocPush && eType == svMatrix) ? ParamClass::ForceArrayReturn : ParamClass::Unknown; +} + +void FormulaToken::SetInForceArray( ParamClass ) +{ + assert( !"virtual dummy called" ); +} + +double FormulaToken::GetDouble() const +{ + // This Get is worth an assert. + assert( !"virtual dummy called" ); + return 0.0; +} + +double & FormulaToken::GetDoubleAsReference() +{ + // This Get is worth an assert. + assert( !"virtual dummy called" ); + static double fVal = 0.0; + return fVal; +} + +sal_Int16 FormulaToken::GetDoubleType() const +{ + SAL_WARN( "formula.core", "FormulaToken::GetDoubleType: virtual dummy called" ); + return 0; +} + +void FormulaToken::SetDoubleType( sal_Int16 ) +{ + assert( !"virtual dummy called" ); +} + +const svl::SharedString INVALID_STRING; + +const svl::SharedString & FormulaToken::GetString() const +{ + SAL_WARN( "formula.core", "FormulaToken::GetString: virtual dummy called" ); + return INVALID_STRING; // invalid string +} + +void FormulaToken::SetString( const svl::SharedString& ) +{ + assert( !"virtual dummy called" ); +} + +sal_uInt16 FormulaToken::GetIndex() const +{ + SAL_WARN( "formula.core", "FormulaToken::GetIndex: virtual dummy called" ); + return 0; +} + +void FormulaToken::SetIndex( sal_uInt16 ) +{ + assert( !"virtual dummy called" ); +} + +sal_Int16 FormulaToken::GetSheet() const +{ + SAL_WARN( "formula.core", "FormulaToken::GetSheet: virtual dummy called" ); + return -1; +} + +void FormulaToken::SetSheet( sal_Int16 ) +{ + assert( !"virtual dummy called" ); +} + +sal_Unicode FormulaToken::GetChar() const +{ + // This Get is worth an assert. + assert( !"virtual dummy called" ); + return 0; +} + +short* FormulaToken::GetJump() const +{ + SAL_WARN( "formula.core", "FormulaToken::GetJump: virtual dummy called" ); + return nullptr; +} + + +const OUString& FormulaToken::GetExternal() const +{ + SAL_WARN( "formula.core", "FormulaToken::GetExternal: virtual dummy called" ); + static OUString aDummyString; + return aDummyString; +} + +FormulaToken* FormulaToken::GetFAPOrigToken() const +{ + SAL_WARN( "formula.core", "FormulaToken::GetFAPOrigToken: virtual dummy called" ); + return nullptr; +} + +FormulaError FormulaToken::GetError() const +{ + SAL_WARN( "formula.core", "FormulaToken::GetError: virtual dummy called" ); + return FormulaError::NONE; +} + +void FormulaToken::SetError( FormulaError ) +{ + assert( !"virtual dummy called" ); +} + +const ScSingleRefData* FormulaToken::GetSingleRef() const +{ + OSL_FAIL( "FormulaToken::GetSingleRef: virtual dummy called" ); + return nullptr; +} + +ScSingleRefData* FormulaToken::GetSingleRef() +{ + OSL_FAIL( "FormulaToken::GetSingleRef: virtual dummy called" ); + return nullptr; +} + +const ScComplexRefData* FormulaToken::GetDoubleRef() const +{ + OSL_FAIL( "FormulaToken::GetDoubleRef: virtual dummy called" ); + return nullptr; +} + +ScComplexRefData* FormulaToken::GetDoubleRef() +{ + OSL_FAIL( "FormulaToken::GetDoubleRef: virtual dummy called" ); + return nullptr; +} + +const ScSingleRefData* FormulaToken::GetSingleRef2() const +{ + OSL_FAIL( "FormulaToken::GetSingleRef2: virtual dummy called" ); + return nullptr; +} + +ScSingleRefData* FormulaToken::GetSingleRef2() +{ + OSL_FAIL( "FormulaToken::GetSingleRef2: virtual dummy called" ); + return nullptr; +} + +const ScMatrix* FormulaToken::GetMatrix() const +{ + OSL_FAIL( "FormulaToken::GetMatrix: virtual dummy called" ); + return nullptr; +} + +ScMatrix* FormulaToken::GetMatrix() +{ + OSL_FAIL( "FormulaToken::GetMatrix: virtual dummy called" ); + return nullptr; +} + +ScJumpMatrix* FormulaToken::GetJumpMatrix() const +{ + OSL_FAIL( "FormulaToken::GetJumpMatrix: virtual dummy called" ); + return nullptr; +} +const std::vector<ScComplexRefData>* FormulaToken::GetRefList() const +{ + OSL_FAIL( "FormulaToken::GetRefList: virtual dummy called" ); + return nullptr; +} + +std::vector<ScComplexRefData>* FormulaToken::GetRefList() +{ + OSL_FAIL( "FormulaToken::GetRefList: virtual dummy called" ); + return nullptr; +} + +bool FormulaToken::TextEqual( const FormulaToken& rToken ) const +{ + return *this == rToken; +} + +// real implementations of virtual functions + + +sal_uInt8 FormulaSpaceToken::GetByte() const { return nByte; } +sal_Unicode FormulaSpaceToken::GetChar() const { return cChar; } +bool FormulaSpaceToken::operator==( const FormulaToken& r ) const +{ + return FormulaToken::operator==( r ) && nByte == r.GetByte() && + cChar == r.GetChar(); +} + + +sal_uInt8 FormulaByteToken::GetByte() const { return nByte; } +void FormulaByteToken::SetByte( sal_uInt8 n ) { nByte = n; } +ParamClass FormulaByteToken::GetInForceArray() const { return eInForceArray; } +void FormulaByteToken::SetInForceArray( ParamClass c ) { eInForceArray = c; } +bool FormulaByteToken::operator==( const FormulaToken& r ) const +{ + return FormulaToken::operator==( r ) && nByte == r.GetByte() && + eInForceArray == r.GetInForceArray(); +} + + +FormulaToken* FormulaFAPToken::GetFAPOrigToken() const { return pOrigToken.get(); } +bool FormulaFAPToken::operator==( const FormulaToken& r ) const +{ + return FormulaByteToken::operator==( r ) && pOrigToken == r.GetFAPOrigToken(); +} + + +short* FormulaJumpToken::GetJump() const { return pJump.get(); } +ParamClass FormulaJumpToken::GetInForceArray() const { return eInForceArray; } +void FormulaJumpToken::SetInForceArray( ParamClass c ) { eInForceArray = c; } +bool FormulaJumpToken::operator==( const FormulaToken& r ) const +{ + return FormulaToken::operator==( r ) && pJump[0] == r.GetJump()[0] && + memcmp( pJump.get()+1, r.GetJump()+1, pJump[0] * sizeof(short) ) == 0 && + eInForceArray == r.GetInForceArray(); +} +FormulaJumpToken::~FormulaJumpToken() +{ +} + + +bool FormulaTokenArray::AddFormulaToken( + const sheet::FormulaToken& rToken, svl::SharedStringPool& rSPool, ExternalReferenceHelper* /*pExtRef*/) +{ + bool bError = false; + const OpCode eOpCode = static_cast<OpCode>(rToken.OpCode); //! assuming equal values for the moment + + const uno::TypeClass eClass = rToken.Data.getValueTypeClass(); + switch ( eClass ) + { + case uno::TypeClass_VOID: + // empty data -> use AddOpCode (does some special cases) + AddOpCode( eOpCode ); + break; + case uno::TypeClass_DOUBLE: + // double is only used for "push" + if ( eOpCode == ocPush ) + AddDouble( rToken.Data.get<double>() ); + else + bError = true; + break; + case uno::TypeClass_LONG: + { + // long is svIndex, used for name / database area, or "byte" for spaces + sal_Int32 nValue = rToken.Data.get<sal_Int32>(); + if ( eOpCode == ocDBArea ) + Add( new formula::FormulaIndexToken( eOpCode, static_cast<sal_uInt16>(nValue) ) ); + else if ( eOpCode == ocTableRef ) + bError = true; /* TODO: implementation */ + else if ( eOpCode == ocSpaces ) + Add( new formula::FormulaByteToken( ocSpaces, static_cast<sal_uInt8>(nValue) ) ); + else + bError = true; + } + break; + case uno::TypeClass_STRING: + { + OUString aStrVal( rToken.Data.get<OUString>() ); + if ( eOpCode == ocPush ) + AddString(rSPool.intern(aStrVal)); + else if ( eOpCode == ocBad ) + AddBad( aStrVal ); + else if ( eOpCode == ocStringXML ) + AddStringXML( aStrVal ); + else if ( eOpCode == ocExternal || eOpCode == ocMacro ) + Add( new formula::FormulaExternalToken( eOpCode, aStrVal ) ); + else if ( eOpCode == ocWhitespace ) + { + // Simply ignore empty string. + // Convention is one character repeated. + if (!aStrVal.isEmpty()) + Add( new formula::FormulaSpaceToken( static_cast<sal_uInt8>(aStrVal.getLength()), aStrVal[0])); + } + else + bError = true; // unexpected string: don't know what to do with it + } + break; + default: + bError = true; + } // switch ( eClass ) + return bError; +} + +bool FormulaTokenArray::Fill( + const uno::Sequence<sheet::FormulaToken>& rSequence, + svl::SharedStringPool& rSPool, ExternalReferenceHelper* pExtRef ) +{ + bool bError = false; + const sal_Int32 nCount = rSequence.getLength(); + for (sal_Int32 nPos=0; nPos<nCount; nPos++) + { + bool bOneError = AddFormulaToken(rSequence[nPos], rSPool, pExtRef); + if (bOneError) + { + AddOpCode( ocErrName); // add something that indicates an error + bError = true; + } + } + return bError; +} + +void FormulaTokenArray::DelRPN() +{ + if( nRPN ) + { + FormulaToken** p = pRPN; + for( sal_uInt16 i = 0; i < nRPN; i++ ) + { + (*p++)->DecRef(); + } + delete [] pRPN; + } + pRPN = nullptr; + nRPN = 0; +} + +FormulaToken* FormulaTokenArray::FirstToken() const +{ + if (!pCode || nLen == 0) + return nullptr; + return pCode[0]; +} + +FormulaToken* FormulaTokenArray::PeekPrev( sal_uInt16 & nIdx ) const +{ + if (0 < nIdx && nIdx <= nLen) + return pCode[--nIdx]; + return nullptr; +} + +FormulaToken* FormulaTokenArray::FirstRPNToken() const +{ + if (!pRPN || nRPN == 0) + return nullptr; + return pRPN[0]; +} + +FormulaToken* FormulaTokenArray::LastRPNToken() const +{ + if (!pRPN || nRPN == 0) + return nullptr; + return pRPN[nRPN - 1]; +} + +bool FormulaTokenArray::HasReferences() const +{ + for (auto i: Tokens()) + { + if (i->IsRef()) + return true; + } + + for (auto i: RPNTokens()) + { + if (i->IsRef()) + return true; + } + + return false; +} + +bool FormulaTokenArray::HasExternalRef() const +{ + for (auto i: Tokens()) + { + if (i->IsExternalRef()) + return true; + } + return false; +} + +bool FormulaTokenArray::HasOpCode( OpCode eOp ) const +{ + for (auto i: Tokens()) + { + if (i->GetOpCode() == eOp) + return true; + } + return false; +} + +bool FormulaTokenArray::HasOpCodeRPN( OpCode eOp ) const +{ + for (auto i: RPNTokens()) + { + if (i->GetOpCode() == eOp) + return true; + } + return false; +} + +bool FormulaTokenArray::HasNameOrColRowName() const +{ + for (auto i: Tokens()) + { + if (i->GetType() == svIndex || i->GetOpCode() == ocColRowName ) + return true; + } + return false; +} + +bool FormulaTokenArray::HasOpCodes(const unordered_opcode_set& rOpCodes) const +{ + for (auto i: Tokens()) + { + if (rOpCodes.count(i->GetOpCode()) > 0) + return true; + } + + return false; +} + +FormulaTokenArray::FormulaTokenArray() : + pRPN(nullptr), + nLen(0), + nRPN(0), + nError(FormulaError::NONE), + nMode(ScRecalcMode::NORMAL), + bHyperLink(false), + mbFromRangeName(false), + mbShareable(true), + mbFinalized(false) +{ +} + +FormulaTokenArray::FormulaTokenArray( const FormulaTokenArray& rArr ) +{ + Assign( rArr ); +} + +FormulaTokenArray::FormulaTokenArray( FormulaTokenArray&& rArr ) +{ + Move( std::move(rArr) ); +} + +FormulaTokenArray::~FormulaTokenArray() +{ + FormulaTokenArray::Clear(); +} + +void FormulaTokenArray::Finalize() +{ + if( nLen && !mbFinalized ) + { + // Add() overallocates, so reallocate to the minimum needed size. + std::unique_ptr<FormulaToken*[]> newCode(new FormulaToken*[ nLen ]); + std::copy(&pCode[0], &pCode[nLen], newCode.get()); + pCode = std::move( newCode ); + mbFinalized = true; + } +} + +void FormulaTokenArray::Assign( const FormulaTokenArray& r ) +{ + nLen = r.nLen; + nRPN = r.nRPN; + nError = r.nError; + nMode = r.nMode; + bHyperLink = r.bHyperLink; + mbFromRangeName = r.mbFromRangeName; + mbShareable = r.mbShareable; + mbFinalized = r.mbFinalized; + pCode = nullptr; + pRPN = nullptr; + FormulaToken** pp; + if( nLen ) + { + pCode.reset(new FormulaToken*[ nLen ]); + pp = pCode.get(); + memcpy( pp, r.pCode.get(), nLen * sizeof( FormulaToken* ) ); + for( sal_uInt16 i = 0; i < nLen; i++ ) + (*pp++)->IncRef(); + mbFinalized = true; + } + if( nRPN ) + { + pp = pRPN = new FormulaToken*[ nRPN ]; + memcpy( pp, r.pRPN, nRPN * sizeof( FormulaToken* ) ); + for( sal_uInt16 i = 0; i < nRPN; i++ ) + (*pp++)->IncRef(); + } +} + +void FormulaTokenArray::Move( FormulaTokenArray&& r ) +{ + pCode = std::move(r.pCode); + pRPN = r.pRPN; + r.pRPN = nullptr; + nLen = r.nLen; + r.nLen = 0; + nRPN = r.nRPN; + r.nRPN = 0; + nError = r.nError; + nMode = r.nMode; + bHyperLink = r.bHyperLink; + mbFromRangeName = r.mbFromRangeName; + mbShareable = r.mbShareable; + mbFinalized = r.mbFinalized; +} + +/// Optimisation for efficiently creating StringXML placeholders +void FormulaTokenArray::Assign( sal_uInt16 nCode, FormulaToken **pTokens ) +{ + assert( nLen == 0 ); + assert( pCode == nullptr ); + + nLen = nCode; + pCode.reset(new FormulaToken*[ nLen ]); + mbFinalized = true; + + for( sal_uInt16 i = 0; i < nLen; i++ ) + { + FormulaToken *t = pTokens[ i ]; + assert( t->GetOpCode() == ocStringXML ); + pCode[ i ] = t; + t->IncRef(); + } +} + +FormulaTokenArray& FormulaTokenArray::operator=( const FormulaTokenArray& rArr ) +{ + if(this == &rArr) + return *this; + + Clear(); + Assign( rArr ); + return *this; +} + +FormulaTokenArray& FormulaTokenArray::operator=( FormulaTokenArray&& rArr ) +{ + Clear(); + Move( std::move(rArr) ); + return *this; +} + +void FormulaTokenArray::Clear() +{ + if( nRPN ) DelRPN(); + if( pCode ) + { + FormulaToken** p = pCode.get(); + for( sal_uInt16 i = 0; i < nLen; i++ ) + { + (*p++)->DecRef(); + } + pCode.reset(); + } + pRPN = nullptr; + nError = FormulaError::NONE; + nLen = nRPN = 0; + bHyperLink = false; + mbFromRangeName = false; + mbShareable = true; + mbFinalized = false; + ClearRecalcMode(); +} + +void FormulaTokenArray::CheckToken( const FormulaToken& /*r*/ ) +{ + // Do nothing. +} + +void FormulaTokenArray::CheckAllRPNTokens() +{ + if( nRPN ) + { + FormulaToken** p = pRPN; + for( sal_uInt16 i = 0; i < nRPN; i++ ) + { + CheckToken( *p[ i ] ); + } + } +} + +FormulaToken* FormulaTokenArray::AddToken( const FormulaToken& r ) +{ + return Add( r.Clone() ); +} + +FormulaToken* FormulaTokenArray::MergeArray( ) +{ + return nullptr; +} + +FormulaToken* FormulaTokenArray::ReplaceToken( sal_uInt16 nOffset, FormulaToken* t, + FormulaTokenArray::ReplaceMode eMode ) +{ + if (nOffset < nLen) + { + CheckToken(*t); + t->IncRef(); + FormulaToken* p = pCode[nOffset]; + pCode[nOffset] = t; + if (eMode == CODE_AND_RPN && p->GetRef() > 1) + { + for (sal_uInt16 i=0; i < nRPN; ++i) + { + if (pRPN[i] == p) + { + t->IncRef(); + pRPN[i] = t; + p->DecRef(); + if (p->GetRef() == 1) + break; // for + } + } + } + p->DecRef(); // may be dead now + return t; + } + else + { + t->DeleteIfZeroRef(); + return nullptr; + } +} + +sal_uInt16 FormulaTokenArray::RemoveToken( sal_uInt16 nOffset, sal_uInt16 nCount ) +{ + if (nOffset < nLen) + { + SAL_WARN_IF( nOffset + nCount > nLen, "formula.core", + "FormulaTokenArray::RemoveToken - nOffset " << nOffset << " + nCount " << nCount << " > nLen " << nLen); + const sal_uInt16 nStop = ::std::min( static_cast<sal_uInt16>(nOffset + nCount), nLen); + nCount = nStop - nOffset; + for (sal_uInt16 j = nOffset; j < nStop; ++j) + { + FormulaToken* p = pCode[j]; + if (p->GetRef() > 1) + { + for (sal_uInt16 i=0; i < nRPN; ++i) + { + if (pRPN[i] == p) + { + // Shift remaining tokens in pRPN down. + for (sal_uInt16 x=i+1; x < nRPN; ++x) + { + pRPN[x-1] = pRPN[x]; + } + --nRPN; + + p->DecRef(); + if (p->GetRef() == 1) + break; // for + } + } + } + p->DecRef(); // may be dead now + } + + // Shift remaining tokens in pCode down. + for (sal_uInt16 x = nStop; x < nLen; ++x) + { + pCode[x-nCount] = pCode[x]; + } + nLen -= nCount; + + return nCount; + } + else + { + SAL_WARN("formula.core","FormulaTokenArray::RemoveToken - nOffset " << nOffset << " >= nLen " << nLen); + return 0; + } +} + +FormulaToken* FormulaTokenArray::Add( FormulaToken* t ) +{ + assert(!mbFinalized); + if (mbFinalized) + { + t->DeleteIfZeroRef(); + return nullptr; + } + +// Allocating an array of size FORMULA_MAXTOKENS is simple, but that results in relatively large +// allocations that malloc() implementations usually do not handle as efficiently as smaller +// sizes (not only in terms of memory usage but also speed). Since most token arrays are going +// to be small, start with a small array and resize only if needed. Eventually Finalize() will +// reallocate the memory to size exactly matching the requirements. + const size_t MAX_FAST_TOKENS = 32; + if( !pCode ) + pCode.reset(new FormulaToken*[ MAX_FAST_TOKENS ]); + if( nLen == MAX_FAST_TOKENS ) + { + FormulaToken** tmp = new FormulaToken*[ FORMULA_MAXTOKENS ]; + std::copy(&pCode[0], &pCode[MAX_FAST_TOKENS], tmp); + pCode.reset(tmp); + } + if( nLen < FORMULA_MAXTOKENS - 1 ) + { + CheckToken(*t); + pCode[ nLen++ ] = t; + t->IncRef(); + if( t->GetOpCode() == ocArrayClose ) + return MergeArray(); + return t; + } + else + { + t->DeleteIfZeroRef(); + if ( nLen == FORMULA_MAXTOKENS - 1 ) + { + t = new FormulaByteToken( ocStop ); + pCode[ nLen++ ] = t; + t->IncRef(); + } + return nullptr; + } +} + +FormulaToken* FormulaTokenArray::AddString( const svl::SharedString& rStr ) +{ + return Add( new FormulaStringToken( rStr ) ); +} + +FormulaToken* FormulaTokenArray::AddDouble( double fVal ) +{ + return Add( new FormulaDoubleToken( fVal ) ); +} + +void FormulaTokenArray::AddExternal( const sal_Unicode* pStr ) +{ + AddExternal( OUString( pStr ) ); +} + +FormulaToken* FormulaTokenArray::AddExternal( const OUString& rStr, + OpCode eOp /* = ocExternal */ ) +{ + return Add( new FormulaExternalToken( eOp, rStr ) ); +} + +FormulaToken* FormulaTokenArray::AddBad( const OUString& rStr ) +{ + return Add( new FormulaStringOpToken( ocBad, svl::SharedString( rStr ) ) ); // string not interned +} + +FormulaToken* FormulaTokenArray::AddStringXML( const OUString& rStr ) +{ + return Add( new FormulaStringOpToken( ocStringXML, svl::SharedString( rStr ) ) ); // string not interned +} + + +void FormulaTokenArray::AddRecalcMode( ScRecalcMode nBits ) +{ + const unsigned nExclusive = static_cast<sal_uInt8>(nBits & ScRecalcMode::EMask); + if (nExclusive) + { + unsigned nExBit; + if (nExclusive & (nExclusive - 1)) + { + // More than one bit set, use highest priority. + for (nExBit = 1; (nExBit & static_cast<sal_uInt8>(ScRecalcMode::EMask)) != 0; nExBit <<= 1) + { + if (nExclusive & nExBit) + break; + } + } + else + { + // Only one bit is set. + nExBit = nExclusive; + } + // Set exclusive bit if priority is higher than existing. + if (nExBit < static_cast<sal_uInt8>(nMode & ScRecalcMode::EMask)) + SetMaskedRecalcMode( static_cast<ScRecalcMode>(nExBit)); + } + SetCombinedBitsRecalcMode( nBits ); +} + + +bool FormulaTokenArray::HasMatrixDoubleRefOps() const +{ + if ( !pRPN || !nRPN ) + return false; + + // RPN-Interpreter simulation. + // Simply assumes a double as return value of each function. + std::unique_ptr<FormulaToken*[]> pStack(new FormulaToken* [nRPN]); + FormulaToken* pResult = new FormulaDoubleToken( 0.0 ); + short sp = 0; + for ( auto t: RPNTokens() ) + { + OpCode eOp = t->GetOpCode(); + sal_uInt8 nParams = t->GetParamCount(); + switch ( eOp ) + { + case ocAdd : + case ocSub : + case ocMul : + case ocDiv : + case ocPow : + case ocPower : + case ocAmpersand : + case ocEqual : + case ocNotEqual : + case ocLess : + case ocGreater : + case ocLessEqual : + case ocGreaterEqual : + { + for ( sal_uInt8 k = nParams; k; k-- ) + { + if ( sp >= k && pStack[sp-k]->GetType() == svDoubleRef ) + { + pResult->Delete(); + return true; + } + } + } + break; + default: + { + // added to avoid warnings + } + } + if ( eOp == ocPush || lcl_IsReference( eOp, t->GetType() ) ) + pStack[sp++] = t; + else if (FormulaCompiler::IsOpCodeJumpCommand( eOp )) + { // ignore Jumps, pop previous Result (Condition) + if ( sp ) + --sp; + } + else + { // pop parameters, push result + sp = sal::static_int_cast<short>( sp - nParams ); + if ( sp < 0 ) + { + SAL_WARN("formula.core", "FormulaTokenArray::HasMatrixDoubleRefOps: sp < 0" ); + sp = 0; + } + pStack[sp++] = pResult; + } + } + pResult->Delete(); + + return false; +} + +// --- Formula rewrite of a token array + +inline bool MissingConventionODF::isRewriteNeeded( OpCode eOp ) const +{ + switch (eOp) + { + case ocGammaDist: + case ocPoissonDist: + case ocAddress: + case ocLogInv: + case ocLogNormDist: + case ocNormDist: + return true; + case ocMissing: + case ocLog: + return isPODF(); // rewrite only for PODF + case ocDBCount: + case ocDBCount2: + return isODFF(); // rewrite only for ODFF + default: + return false; + } +} + +/* + fdo 81596 +To be implemented yet: + ocExternal: ? + ocMacro: ? + ocIndex: INDEX() ? +*/ +inline bool MissingConventionOOXML::isRewriteNeeded( OpCode eOp ) +{ + switch (eOp) + { + case ocIf: + + case ocExternal: + case ocEuroConvert: + case ocMacro: + + case ocRound: + case ocRoundUp: + case ocRoundDown: + + case ocIndex: + + case ocCeil: + case ocFloor: + + case ocGammaDist: + case ocFDist_LT: + case ocPoissonDist: + case ocNormDist: + case ocLogInv: + case ocLogNormDist: + case ocHypGeomDist: + + case ocDBCount: + case ocDBCount2: + return true; + + default: + return false; + } +} + +namespace { + +class FormulaMissingContext +{ + public: + const FormulaToken* mpFunc; + int mnCurArg; + + void Clear() { mpFunc = nullptr; mnCurArg = 0; } + inline bool AddDefaultArg( FormulaTokenArray* pNewArr, int nArg, double f ) const; + bool AddMissingExternal( FormulaTokenArray* pNewArr ) const; + bool AddMissing( FormulaTokenArray *pNewArr, const MissingConvention & rConv ) const; + void AddMoreArgs( FormulaTokenArray *pNewArr, const MissingConvention & rConv ) const; +}; + +} + +void FormulaMissingContext::AddMoreArgs( FormulaTokenArray *pNewArr, const MissingConvention & rConv ) const +{ + if ( !mpFunc ) + return; + + switch (rConv.getConvention()) + { + case MissingConvention::FORMULA_MISSING_CONVENTION_ODFF: + case MissingConvention::FORMULA_MISSING_CONVENTION_PODF: + { + switch (mpFunc->GetOpCode()) + { + case ocGammaDist: + if (mnCurArg == 2) + { + pNewArr->AddOpCode( ocSep ); + pNewArr->AddDouble( 1.0 ); // 4th, Cumulative=true() + } + break; + case ocPoissonDist: + if (mnCurArg == 1) + { + pNewArr->AddOpCode( ocSep ); + pNewArr->AddDouble( 1.0 ); // 3rd, Cumulative=true() + } + break; + case ocNormDist: + if ( mnCurArg == 2 ) + { + pNewArr->AddOpCode( ocSep ); + pNewArr->AddDouble( 1.0 ); // 4th, Cumulative=true() + } + break; + case ocLogInv: + case ocLogNormDist: + if ( mnCurArg == 0 ) + { + pNewArr->AddOpCode( ocSep ); + pNewArr->AddDouble( 0.0 ); // 2nd, mean = 0.0 + } + if ( mnCurArg <= 1 ) + { + pNewArr->AddOpCode( ocSep ); + pNewArr->AddDouble( 1.0 ); // 3rd, standard deviation = 1.0 + } + break; + case ocLog: + if ( rConv.isPODF() && mnCurArg == 0 ) + { + pNewArr->AddOpCode( ocSep ); + pNewArr->AddDouble( 10.0 ); // 2nd, basis 10 + } + break; + default: + break; + } + } + break; + case MissingConvention::FORMULA_MISSING_CONVENTION_OOXML: + { + switch (mpFunc->GetOpCode()) + { + case ocIf: + if( mnCurArg == 0 ) + { + // Excel needs at least two parameters in IF function + pNewArr->AddOpCode( ocSep ); + pNewArr->AddOpCode( ocTrue ); // 2nd, true() as function + pNewArr->AddOpCode( ocOpen ); // so the result is of logical type + pNewArr->AddOpCode( ocClose ); // and survives roundtrip + } + break; + + case ocEuroConvert: + if ( mnCurArg == 2 ) + { + pNewArr->AddOpCode( ocSep ); + pNewArr->AddDouble( 0.0 ); // 4th, FullPrecision = false() + } + break; + + case ocPoissonDist: + if (mnCurArg == 1) + { + pNewArr->AddOpCode( ocSep ); + pNewArr->AddDouble( 1.0 ); // 3rd, Cumulative=true() + } + break; + + case ocGammaDist: + case ocFDist_LT: + case ocNormDist: + if (mnCurArg == 2) + { + pNewArr->AddOpCode( ocSep ); + pNewArr->AddDouble( 1.0 ); // 4th, Cumulative=true() + } + break; + + case ocLogInv: + case ocLogNormDist: + if ( mnCurArg == 0 ) + { + pNewArr->AddOpCode( ocSep ); + pNewArr->AddDouble( 0.0 ); // 2nd, mean = 0.0 + } + if ( mnCurArg <= 1 ) + { + pNewArr->AddOpCode( ocSep ); + pNewArr->AddDouble( 1.0 ); // 3rd, standard deviation = 1.0 + } + break; + + case ocHypGeomDist: + if ( mnCurArg == 3 ) + { + pNewArr->AddOpCode( ocSep ); + pNewArr->AddDouble( 0.0 ); // 5th, Cumulative = false() + } + break; + + case ocRound: + case ocRoundUp: + case ocRoundDown: + if( mnCurArg == 0 ) + { + // ROUND, ROUNDUP, ROUNDDOWN functions are fixed to 2 parameters in Excel + pNewArr->AddOpCode( ocSep ); + pNewArr->AddDouble( 0.0 ); // 2nd, 0.0 + } + break; + + default: + break; + } + } + break; + } + +} + +inline bool FormulaMissingContext::AddDefaultArg( FormulaTokenArray* pNewArr, int nArg, double f ) const +{ + if (mnCurArg == nArg) + { + pNewArr->AddDouble( f ); + return true; + } + return false; +} + +bool FormulaMissingContext::AddMissingExternal( FormulaTokenArray *pNewArr ) const +{ + // Only called for PODF, not ODFF. No need to distinguish. + + const OUString &rName = mpFunc->GetExternal(); + + // initial (fast) checks: + sal_Int32 nLength = rName.getLength(); + if (!nLength) + return false; + + sal_Unicode nLastChar = rName[ nLength - 1]; + if ( nLastChar != 't' && nLastChar != 'm' ) + return false; + + if (rName.equalsIgnoreAsciiCase( + "com.sun.star.sheet.addin.Analysis.getAccrint" )) + { + return AddDefaultArg( pNewArr, 4, 1000.0 ); + } + if (rName.equalsIgnoreAsciiCase( + "com.sun.star.sheet.addin.Analysis.getAccrintm" )) + { + return AddDefaultArg( pNewArr, 3, 1000.0 ); + } + return false; +} + +bool FormulaMissingContext::AddMissing( FormulaTokenArray *pNewArr, const MissingConvention & rConv ) const +{ + if ( !mpFunc ) + return false; + + bool bRet = false; + const OpCode eOp = mpFunc->GetOpCode(); + + switch (rConv.getConvention()) + { + case MissingConvention::FORMULA_MISSING_CONVENTION_ODFF: + { + // Add for ODFF + switch (eOp) + { + case ocAddress: + return AddDefaultArg( pNewArr, 2, 1.0 ); // abs + default: + break; + } + } + break; + case MissingConvention::FORMULA_MISSING_CONVENTION_PODF: + { + // Add for PODF + switch (eOp) + { + case ocAddress: + return AddDefaultArg( pNewArr, 2, 1.0 ); // abs + case ocFixed: + return AddDefaultArg( pNewArr, 1, 2.0 ); + case ocBetaDist: + case ocBetaInv: + case ocPMT: + return AddDefaultArg( pNewArr, 3, 0.0 ); + case ocIpmt: + case ocPpmt: + return AddDefaultArg( pNewArr, 4, 0.0 ); + case ocPV: + case ocFV: + bRet |= AddDefaultArg( pNewArr, 2, 0.0 ); // pmt + bRet |= AddDefaultArg( pNewArr, 3, 0.0 ); // [fp]v + break; + case ocRate: + bRet |= AddDefaultArg( pNewArr, 1, 0.0 ); // pmt + bRet |= AddDefaultArg( pNewArr, 3, 0.0 ); // fv + bRet |= AddDefaultArg( pNewArr, 4, 0.0 ); // type + break; + case ocExternal: + return AddMissingExternal( pNewArr ); + + // --- more complex cases --- + + case ocOffset: + // FIXME: rather tough + // if arg 3 (height) omitted, export arg1 (rows) + break; + default: + break; + } + } + break; + case MissingConvention::FORMULA_MISSING_CONVENTION_OOXML: + { + switch (eOp) + { + case ocExternal: + return AddMissingExternal( pNewArr ); + default: + break; + } + } + break; + } + + return bRet; +} + +bool FormulaTokenArray::NeedsPodfRewrite( const MissingConventionODF & rConv ) +{ + for ( auto i: Tokens() ) + { + if ( rConv.isRewriteNeeded( i->GetOpCode())) + return true; + } + return false; +} + +bool FormulaTokenArray::NeedsOoxmlRewrite() +{ + for ( auto i: Tokens() ) + { + if ( MissingConventionOOXML::isRewriteNeeded( i->GetOpCode())) + return true; + } + return false; +} + + +FormulaTokenArray * FormulaTokenArray::RewriteMissing( const MissingConvention & rConv ) +{ + const size_t nAlloc = 256; + FormulaMissingContext aCtx[ nAlloc ]; + + /* TODO: with some effort we might be able to merge the two almost + * identical function stacks into one and generalize things, otherwise + * adding yet another "omit argument" would be copypasta. */ + + int aOpCodeAddressStack[ nAlloc ]; // use of ADDRESS() function + const int nOmitAddressArg = 3; // ADDRESS() 4th parameter A1/R1C1 + + int aOpCodeDcountStack[ nAlloc ]; // use of DCOUNT()/DCOUNTA() function + const int nOmitDcountArg = 1; // DCOUNT() and DCOUNTA() 2nd parameter DatabaseField if 0 + + sal_uInt16 nTokens = GetLen() + 1; + FormulaMissingContext* pCtx = (nAlloc < nTokens ? new FormulaMissingContext[nTokens] : &aCtx[0]); + int* pOcas = (nAlloc < nTokens ? new int[nTokens] : &aOpCodeAddressStack[0]); + int* pOcds = (nAlloc < nTokens ? new int[nTokens] : &aOpCodeDcountStack[0]); + // Never go below 0, never use 0, mpFunc always NULL. + pCtx[0].Clear(); + int nFn = 0; + int nOcas = 0; + int nOcds = 0; + + FormulaTokenArray *pNewArr = new FormulaTokenArray; + // At least ScRecalcMode::ALWAYS needs to be set. + pNewArr->AddRecalcMode( GetRecalcMode()); + + FormulaTokenArrayPlainIterator aIter(*this); + for ( FormulaToken *pCur = aIter.First(); pCur; pCur = aIter.Next() ) + { + bool bAdd = true; + // Don't write the expression of the new inserted ADDRESS() parameter. + // Do NOT omit the new second parameter of INDIRECT() though. If that + // was done for both, INDIRECT() actually could calculate different and + // valid (but wrong) results with the then changed return value of + // ADDRESS(). Better let it generate an error instead. + for (int i = nOcas; i-- > 0 && bAdd; ) + { + if (pCtx[ pOcas[ i ] ].mnCurArg == nOmitAddressArg) + { + // Omit everything except a trailing separator, the leading + // separator is omitted below. The other way around would leave + // an extraneous separator if no parameter followed. + if (pOcas[ i ] != nFn || pCur->GetOpCode() != ocSep) + bAdd = false; + } + } + // Strip the 2nd argument (leaving empty) of DCOUNT() and DCOUNTA() if + // it is 0. + for (int i = nOcds; i-- > 0 && bAdd; ) + { + if (pCtx[ pOcds[ i ] ].mnCurArg == nOmitDcountArg) + { + // Omit only a literal 0 value, nothing else. + if (pOcds[ i ] == nFn && pCur->GetOpCode() == ocPush && pCur->GetType() == svDouble && + pCur->GetDouble() == 0.0) + { + // No other expression, between separators. + FormulaToken* p = aIter.PeekPrevNoSpaces(); + if (p && p->GetOpCode() == ocSep) + { + p = aIter.PeekNextNoSpaces(); + if (p && p->GetOpCode() == ocSep) + bAdd = false; + } + } + } + } + switch ( pCur->GetOpCode() ) + { + case ocOpen: + { + ++nFn; // all following operations on _that_ function + pCtx[ nFn ].mpFunc = aIter.PeekPrevNoSpaces(); + pCtx[ nFn ].mnCurArg = 0; + if (rConv.isPODF() && pCtx[ nFn ].mpFunc && pCtx[ nFn ].mpFunc->GetOpCode() == ocAddress) + pOcas[ nOcas++ ] = nFn; // entering ADDRESS() if PODF + else if ((rConv.isODFF() || rConv.isOOXML()) && pCtx[ nFn ].mpFunc) + { + OpCode eOp = pCtx[ nFn ].mpFunc->GetOpCode(); + if (eOp == ocDBCount || eOp == ocDBCount2) + pOcds[ nOcds++ ] = nFn; // entering DCOUNT() or DCOUNTA() if ODFF or OOXML + } + } + break; + case ocClose: + pCtx[ nFn ].AddMoreArgs( pNewArr, rConv ); + SAL_WARN_IF(nFn <= 0, "formula.core", "FormulaTokenArray::RewriteMissing: underflow"); + if (nOcas > 0 && pOcas[ nOcas-1 ] == nFn) + --nOcas; // leaving ADDRESS() + else if (nOcds > 0 && pOcds[ nOcds-1 ] == nFn) + --nOcds; // leaving DCOUNT() or DCOUNTA() + if (nFn > 0) + --nFn; + break; + case ocSep: + pCtx[ nFn ].mnCurArg++; + // Omit leading separator of ADDRESS() parameter. + if (nOcas && pOcas[ nOcas-1 ] == nFn && pCtx[ nFn ].mnCurArg == nOmitAddressArg) + { + bAdd = false; + } + break; + case ocMissing: + if ( bAdd ) + bAdd = !pCtx[ nFn ].AddMissing( pNewArr, rConv ); + break; + default: + break; + } + if (bAdd) + { + OpCode eOp = pCur->GetOpCode(); + if ( ( eOp == ocCeil || eOp == ocFloor || + ( eOp == ocLogNormDist && pCur->GetByte() == 4 ) ) && + rConv.getConvention() == MissingConvention::FORMULA_MISSING_CONVENTION_OOXML ) + { + switch ( eOp ) + { + case ocCeil : + eOp = ocCeil_Math; + break; + case ocFloor : + eOp = ocFloor_Math; + break; + case ocLogNormDist : + eOp = ocLogNormDist_MS; + break; + default : + eOp = ocNone; + break; + } + FormulaToken *pToken = new FormulaToken( svByte, eOp ); + pNewArr->Add( pToken ); + } + else if ( eOp == ocHypGeomDist && + rConv.getConvention() == MissingConvention::FORMULA_MISSING_CONVENTION_OOXML ) + { + FormulaToken *pToken = new FormulaToken( svByte, ocHypGeomDist_MS ); + pNewArr->Add( pToken ); + } + else + pNewArr->AddToken( *pCur ); + } + } + + if (pOcds != &aOpCodeDcountStack[0]) + delete [] pOcds; + if (pOcas != &aOpCodeAddressStack[0]) + delete [] pOcas; + if (pCtx != &aCtx[0]) + delete [] pCtx; + + return pNewArr; +} + +namespace { +inline bool isWhitespace( OpCode eOp ) { return eOp == ocSpaces || eOp == ocWhitespace; } +} + +bool FormulaTokenArray::MayReferenceFollow() +{ + if ( !pCode || nLen <= 0 ) + return false; + + // ignore trailing spaces + sal_uInt16 i = nLen - 1; + while (i > 0 && isWhitespace( pCode[i]->GetOpCode())) + { + --i; + } + if (i > 0 || !isWhitespace( pCode[i]->GetOpCode())) + { + OpCode eOp = pCode[i]->GetOpCode(); + if ( (SC_OPCODE_START_BIN_OP <= eOp && eOp < SC_OPCODE_STOP_BIN_OP ) || + (SC_OPCODE_START_UN_OP <= eOp && eOp < SC_OPCODE_STOP_UN_OP ) || + eOp == SC_OPCODE_OPEN || eOp == SC_OPCODE_SEP ) + { + return true; + } + } + return false; +} +FormulaToken* FormulaTokenArray::AddOpCode( OpCode eOp ) +{ + FormulaToken* pRet = nullptr; + switch ( eOp ) + { + case ocOpen: + case ocClose: + case ocSep: + case ocArrayOpen: + case ocArrayClose: + case ocArrayRowSep: + case ocArrayColSep: + pRet = new FormulaToken( svSep,eOp ); + break; + case ocIf: + case ocIfError: + case ocIfNA: + case ocChoose: + { + short nJump[FORMULA_MAXJUMPCOUNT + 1]; + if ( eOp == ocIf ) + nJump[ 0 ] = 3; + else if ( eOp == ocChoose ) + nJump[ 0 ] = FORMULA_MAXJUMPCOUNT + 1; + else + nJump[ 0 ] = 2; + pRet = new FormulaJumpToken( eOp, nJump ); + } + break; + default: + pRet = new FormulaByteToken( eOp, 0, ParamClass::Unknown ); + break; + } + return Add( pRet ); +} + +void FormulaTokenArray::ReinternStrings( svl::SharedStringPool& rPool ) +{ + for (auto i: Tokens()) + { + switch (i->GetType()) + { + case svString: + i->SetString( rPool.intern( i->GetString().getString())); + break; + default: + ; // nothing + } + } +} + + +/*----------------------------------------------------------------------*/ + +FormulaTokenIterator::Item::Item(const FormulaTokenArray* pArray, short pc, short stop) : + pArr(pArray), nPC(pc), nStop(stop) +{ +} + +FormulaTokenIterator::FormulaTokenIterator( const FormulaTokenArray& rArr ) +{ + Push( &rArr ); +} + +FormulaTokenIterator::~FormulaTokenIterator() +{ +} + +void FormulaTokenIterator::Push( const FormulaTokenArray* pArr ) +{ + FormulaTokenIterator::Item item(pArr, -1, SHRT_MAX); + + maStack.push_back(item); +} + +void FormulaTokenIterator::Pop() +{ + maStack.pop_back(); +} + +void FormulaTokenIterator::Reset() +{ + while( maStack.size() > 1 ) + maStack.pop_back(); + + maStack.back().nPC = -1; +} + +FormulaToken* FormulaTokenArrayPlainIterator::GetNextName() +{ + if( mpFTA->GetArray() ) + { + while ( mnIndex < mpFTA->GetLen() ) + { + FormulaToken* t = mpFTA->GetArray()[ mnIndex++ ]; + if( t->GetType() == svIndex ) + return t; + } + } + return nullptr; +} + +const FormulaToken* FormulaTokenIterator::Next() +{ + const FormulaToken* t = GetNonEndOfPathToken( ++maStack.back().nPC ); + if( !t && maStack.size() > 1 ) + { + Pop(); + t = Next(); + } + return t; +} + +const FormulaToken* FormulaTokenIterator::PeekNextOperator() +{ + const FormulaToken* t = nullptr; + short nIdx = maStack.back().nPC; + for (;;) + { + t = GetNonEndOfPathToken( ++nIdx); + if (t == nullptr || t->GetOpCode() != ocPush) + break; // ignore operands + } + if (!t && maStack.size() > 1) + { + FormulaTokenIterator::Item aHere = maStack.back(); + maStack.pop_back(); + t = PeekNextOperator(); + maStack.push_back(aHere); + } + return t; +} + +//! The nPC counts after a Push() are -1 + +void FormulaTokenIterator::Jump( short nStart, short nNext, short nStop ) +{ + maStack.back().nPC = nNext; + if( nStart != nNext ) + { + Push( maStack.back().pArr ); + maStack.back().nPC = nStart; + maStack.back().nStop = nStop; + } +} + +void FormulaTokenIterator::ReInit( const FormulaTokenArray& rArr ) +{ + maStack.clear(); + Push( &rArr ); +} + +const FormulaToken* FormulaTokenIterator::GetNonEndOfPathToken( short nIdx ) const +{ + FormulaTokenIterator::Item cur = maStack.back(); + + if (nIdx < cur.pArr->GetCodeLen() && nIdx < cur.nStop) + { + const FormulaToken* t = cur.pArr->GetCode()[ nIdx ]; + // such an OpCode ends an IF() or CHOOSE() path + return (t->GetOpCode() == ocSep || t->GetOpCode() == ocClose) ? nullptr : t; + } + return nullptr; +} + +bool FormulaTokenIterator::IsEndOfPath() const +{ + return GetNonEndOfPathToken( maStack.back().nPC + 1) == nullptr; +} + +FormulaToken* FormulaTokenArrayPlainIterator::GetNextReference() +{ + while( mnIndex < mpFTA->GetLen() ) + { + FormulaToken* t = mpFTA->GetArray()[ mnIndex++ ]; + switch( t->GetType() ) + { + case svSingleRef: + case svDoubleRef: + case svExternalSingleRef: + case svExternalDoubleRef: + return t; + default: + { + // added to avoid warnings + } + } + } + return nullptr; +} + +FormulaToken* FormulaTokenArrayPlainIterator::GetNextColRowName() +{ + while( mnIndex < mpFTA->GetLen() ) + { + FormulaToken* t = mpFTA->GetArray()[ mnIndex++ ]; + if ( t->GetOpCode() == ocColRowName ) + return t; + } + return nullptr; +} + +FormulaToken* FormulaTokenArrayPlainIterator::GetNextReferenceRPN() +{ + while( mnIndex < mpFTA->GetCodeLen() ) + { + FormulaToken* t = mpFTA->GetCode()[ mnIndex++ ]; + switch( t->GetType() ) + { + case svSingleRef: + case svDoubleRef: + case svExternalSingleRef: + case svExternalDoubleRef: + return t; + default: + { + // added to avoid warnings + } + } + } + return nullptr; +} + +FormulaToken* FormulaTokenArrayPlainIterator::GetNextReferenceOrName() +{ + if( !mpFTA->GetArray() ) + return nullptr; + + while ( mnIndex < mpFTA->GetLen() ) + { + FormulaToken* t = mpFTA->GetArray()[ mnIndex++ ]; + switch( t->GetType() ) + { + case svSingleRef: + case svDoubleRef: + case svIndex: + case svExternalSingleRef: + case svExternalDoubleRef: + case svExternalName: + return t; + default: + { + // added to avoid warnings + } + } + } + return nullptr; +} + +FormulaToken* FormulaTokenArrayPlainIterator::Next() +{ + if( mpFTA->GetArray() && mnIndex < mpFTA->GetLen() ) + return mpFTA->GetArray()[ mnIndex++ ]; + else + return nullptr; +} + +FormulaToken* FormulaTokenArrayPlainIterator::NextNoSpaces() +{ + if( mpFTA->GetArray() ) + { + while ((mnIndex < mpFTA->GetLen()) && isWhitespace( mpFTA->GetArray()[ mnIndex ]->GetOpCode())) + ++mnIndex; + if( mnIndex < mpFTA->GetLen() ) + return mpFTA->GetArray()[ mnIndex++ ]; + } + return nullptr; +} + +FormulaToken* FormulaTokenArrayPlainIterator::NextRPN() +{ + if( mpFTA->GetCode() && mnIndex < mpFTA->GetCodeLen() ) + return mpFTA->GetCode()[ mnIndex++ ]; + else + return nullptr; +} + +FormulaToken* FormulaTokenArrayPlainIterator::PrevRPN() +{ + if( mpFTA->GetCode() && mnIndex ) + return mpFTA->GetCode()[ --mnIndex ]; + else + return nullptr; +} + +FormulaToken* FormulaTokenArrayPlainIterator::PeekNext() +{ + if( mpFTA->GetArray() && mnIndex < mpFTA->GetLen() ) + return mpFTA->GetArray()[ mnIndex ]; + else + return nullptr; +} + +FormulaToken* FormulaTokenArrayPlainIterator::PeekNextNoSpaces() const +{ + if( mpFTA->GetArray() && mnIndex < mpFTA->GetLen() ) + { + sal_uInt16 j = mnIndex; + while (j < mpFTA->GetLen() && isWhitespace( mpFTA->GetArray()[j]->GetOpCode())) + j++; + if ( j < mpFTA->GetLen() ) + return mpFTA->GetArray()[ j ]; + else + return nullptr; + } + else + return nullptr; +} + +FormulaToken* FormulaTokenArrayPlainIterator::PeekPrevNoSpaces() const +{ + if( mpFTA->GetArray() && mnIndex > 1 ) + { + sal_uInt16 j = mnIndex - 2; + while (isWhitespace( mpFTA->GetArray()[j]->GetOpCode()) && j > 0 ) + j--; + if (j > 0 || !isWhitespace( mpFTA->GetArray()[j]->GetOpCode())) + return mpFTA->GetArray()[ j ]; + else + return nullptr; + } + else + return nullptr; +} + +void FormulaTokenArrayPlainIterator::AfterRemoveToken( sal_uInt16 nOffset, sal_uInt16 nCount ) +{ + const sal_uInt16 nStop = std::min( static_cast<sal_uInt16>(nOffset + nCount), mpFTA->GetLen()); + + if (mnIndex >= nOffset) + { + if (mnIndex < nStop) + mnIndex = nOffset + 1; + else + mnIndex -= nStop - nOffset; + } +} + +// real implementations of virtual functions + + +double FormulaDoubleToken::GetDouble() const { return fDouble; } +double & FormulaDoubleToken::GetDoubleAsReference() { return fDouble; } + +sal_Int16 FormulaDoubleToken::GetDoubleType() const +{ + // This is a plain double value without type information, don't emit a + // warning via FormulaToken::GetDoubleType(). + return 0; +} + +bool FormulaDoubleToken::operator==( const FormulaToken& r ) const +{ + return FormulaToken::operator==( r ) && fDouble == r.GetDouble(); +} + +sal_Int16 FormulaTypedDoubleToken::GetDoubleType() const +{ + return mnType; +} + +void FormulaTypedDoubleToken::SetDoubleType( sal_Int16 nType ) +{ + mnType = nType; +} + +bool FormulaTypedDoubleToken::operator==( const FormulaToken& r ) const +{ + return FormulaDoubleToken::operator==( r ) && mnType == r.GetDoubleType(); +} + +FormulaStringToken::FormulaStringToken( const svl::SharedString& r ) : + FormulaToken( svString ), maString( r ) +{ +} + +FormulaStringToken::FormulaStringToken( const FormulaStringToken& r ) : + FormulaToken( r ), maString( r.maString ) {} + +FormulaToken* FormulaStringToken::Clone() const +{ + return new FormulaStringToken(*this); +} + +const svl::SharedString & FormulaStringToken::GetString() const +{ + return maString; +} + +void FormulaStringToken::SetString( const svl::SharedString& rStr ) +{ + maString = rStr; +} + +bool FormulaStringToken::operator==( const FormulaToken& r ) const +{ + return FormulaToken::operator==( r ) && maString == r.GetString(); +} + +FormulaStringOpToken::FormulaStringOpToken( OpCode e, const svl::SharedString& r ) : + FormulaByteToken( e, 0, svString, ParamClass::Unknown ), maString( r ) {} + +FormulaStringOpToken::FormulaStringOpToken( const FormulaStringOpToken& r ) : + FormulaByteToken( r ), maString( r.maString ) {} + +FormulaToken* FormulaStringOpToken::Clone() const +{ + return new FormulaStringOpToken(*this); +} + +const svl::SharedString & FormulaStringOpToken::GetString() const +{ + return maString; +} + +void FormulaStringOpToken::SetString( const svl::SharedString& rStr ) +{ + maString = rStr; +} + +bool FormulaStringOpToken::operator==( const FormulaToken& r ) const +{ + return FormulaByteToken::operator==( r ) && maString == r.GetString(); +} + +sal_uInt16 FormulaIndexToken::GetIndex() const { return nIndex; } +void FormulaIndexToken::SetIndex( sal_uInt16 n ) { nIndex = n; } +sal_Int16 FormulaIndexToken::GetSheet() const { return mnSheet; } +void FormulaIndexToken::SetSheet( sal_Int16 n ) { mnSheet = n; } +bool FormulaIndexToken::operator==( const FormulaToken& r ) const +{ + return FormulaToken::operator==( r ) && nIndex == r.GetIndex() && + mnSheet == r.GetSheet(); +} +const OUString& FormulaExternalToken::GetExternal() const { return aExternal; } +bool FormulaExternalToken::operator==( const FormulaToken& r ) const +{ + return FormulaByteToken::operator==( r ) && aExternal == r.GetExternal(); +} + + +FormulaError FormulaErrorToken::GetError() const { return nError; } +void FormulaErrorToken::SetError( FormulaError nErr ) { nError = nErr; } +bool FormulaErrorToken::operator==( const FormulaToken& r ) const +{ + return FormulaToken::operator==( r ) && + nError == static_cast< const FormulaErrorToken & >(r).GetError(); +} +double FormulaMissingToken::GetDouble() const { return 0.0; } + +const svl::SharedString & FormulaMissingToken::GetString() const +{ + return svl::SharedString::getEmptyString(); +} + +bool FormulaMissingToken::operator==( const FormulaToken& r ) const +{ + return FormulaToken::operator==( r ); +} + + +bool FormulaUnknownToken::operator==( const FormulaToken& r ) const +{ + return FormulaToken::operator==( r ); +} + + +} // formula + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/formula/source/core/api/vectortoken.cxx b/formula/source/core/api/vectortoken.cxx new file mode 100644 index 000000000..c1bd52157 --- /dev/null +++ b/formula/source/core/api/vectortoken.cxx @@ -0,0 +1,109 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ + +#include <formula/vectortoken.hxx> +#include <sal/log.hxx> + +namespace formula { + +VectorRefArray::VectorRefArray() : + mpNumericArray(nullptr), + mpStringArray(nullptr), + mbValid(true) {} + +VectorRefArray::VectorRefArray( InitInvalid ) : + mpNumericArray(nullptr), + mpStringArray(nullptr), + mbValid(false) {} + +VectorRefArray::VectorRefArray( const double* pArray ) : + mpNumericArray(pArray), + mpStringArray(nullptr), + mbValid(true) {} + +VectorRefArray::VectorRefArray( rtl_uString** pArray ) : + mpNumericArray(nullptr), + mpStringArray(pArray), + mbValid(true) {} + +VectorRefArray::VectorRefArray( const double* pNumArray, rtl_uString** pStrArray ) : + mpNumericArray(pNumArray), + mpStringArray(pStrArray), + mbValid(true) {} + +bool VectorRefArray::isValid() const +{ + return mbValid; +} + +SingleVectorRefToken::SingleVectorRefToken( const VectorRefArray& rArray, size_t nArrayLength ) : + FormulaToken(svSingleVectorRef, ocPush), maArray(rArray), mnArrayLength(nArrayLength) +{ + SAL_INFO("formula.core", "Created SingleVectorRefToken nArrayLength=" << nArrayLength); +} + +FormulaToken* SingleVectorRefToken::Clone() const +{ + return new SingleVectorRefToken(maArray, mnArrayLength); +} + +const VectorRefArray& SingleVectorRefToken::GetArray() const +{ + return maArray; +} + +size_t SingleVectorRefToken::GetArrayLength() const +{ + return mnArrayLength; +} + +DoubleVectorRefToken::DoubleVectorRefToken( + std::vector<VectorRefArray>&& rArrays, size_t nArrayLength, + size_t nRefRowSize, bool bStartFixed, bool bEndFixed ) : + FormulaToken(svDoubleVectorRef, ocPush), + maArrays(std::move(rArrays)), mnArrayLength(nArrayLength), + mnRefRowSize(nRefRowSize), mbStartFixed(bStartFixed), mbEndFixed(bEndFixed) +{ + SAL_INFO("formula.core", "Created DoubleVectorRefToken nArrayLength=" << nArrayLength); +} + +FormulaToken* DoubleVectorRefToken::Clone() const +{ + return new DoubleVectorRefToken( + std::vector(maArrays), mnArrayLength, mnRefRowSize, mbStartFixed, mbEndFixed); +} + +const std::vector<VectorRefArray>& DoubleVectorRefToken::GetArrays() const +{ + return maArrays; +} + +size_t DoubleVectorRefToken::GetArrayLength() const +{ + return mnArrayLength; +} + +size_t DoubleVectorRefToken::GetRefRowSize() const +{ + return mnRefRowSize; +} + +bool DoubleVectorRefToken::IsStartFixed() const +{ + return mbStartFixed; +} + +bool DoubleVectorRefToken::IsEndFixed() const +{ + return mbEndFixed; +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/formula/source/core/resource/core_resource.cxx b/formula/source/core/resource/core_resource.cxx new file mode 100644 index 000000000..d18432357 --- /dev/null +++ b/formula/source/core/resource/core_resource.cxx @@ -0,0 +1,23 @@ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include <core_resource.hxx> + +OUString ForResId(TranslateId aId) { return Translate::get(aId, Translate::Create("for")); } + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/formula/source/ui/dlg/ControlHelper.hxx b/formula/source/ui/dlg/ControlHelper.hxx new file mode 100644 index 000000000..249547451 --- /dev/null +++ b/formula/source/ui/dlg/ControlHelper.hxx @@ -0,0 +1,106 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ +#pragma once + +#include <formula/funcutl.hxx> + +namespace formula +{ + +class ParaWin; + + +class ArgEdit : public RefEdit +{ +public: + ArgEdit(std::unique_ptr<weld::Entry> xControl); + + void Init(ArgEdit* pPrevEdit, ArgEdit* pNextEdit, + weld::ScrolledWindow& rArgSlider, + ParaWin& rParaWin, sal_uInt16 nArgCount); + +protected: + virtual bool KeyInput(const KeyEvent& rKEvt) override; + +private: + ArgEdit* pEdPrev; + ArgEdit* pEdNext; + weld::ScrolledWindow* pSlider; + ParaWin* pParaWin; + sal_uInt16 nArgs; +}; + + + +class ArgInput final +{ +private: + Link<ArgInput&,void> aFxClickLink; + Link<ArgInput&,void> aFxFocusLink; + Link<ArgInput&,void> aEdFocusLink; + Link<ArgInput&,void> aEdModifyLink; + + weld::Label*pFtArg; + weld::Button* pBtnFx; + ArgEdit* pEdArg; + RefButton* pRefBtn; + + DECL_LINK( FxBtnClickHdl, weld::Button&, void ); + DECL_LINK( FxBtnFocusHdl, weld::Widget&, void ); + DECL_LINK( EdFocusHdl, RefEdit&, void ); + DECL_LINK( EdModifyHdl, RefEdit&, void ); + +public: + + ArgInput(); + + void InitArgInput(weld::Label* pftArg, + weld::Button* pbtnFx, + ArgEdit* pedArg, + RefButton* prefBtn); + + void SetArgName(const OUString &aArg); + OUString GetArgName() const; + void SetArgNameFont(const vcl::Font&); + + void SetArgVal(const OUString &aVal); + OUString GetArgVal() const; + + void SelectAll(); + + ArgEdit* GetArgEdPtr() { return pEdArg; } + + + void SetFxClickHdl( const Link<ArgInput&,void>& rLink ) { aFxClickLink = rLink; } + + void SetFxFocusHdl( const Link<ArgInput&,void>& rLink ) { aFxFocusLink = rLink; } + + void SetEdFocusHdl( const Link<ArgInput&,void>& rLink ) { aEdFocusLink = rLink; } + + void SetEdModifyHdl( const Link<ArgInput&,void>& rLink ) { aEdModifyLink = rLink; } + + void Hide(); + void Show(); + + void UpdateAccessibleNames(); +}; + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/formula/source/ui/dlg/FormulaHelper.cxx b/formula/source/ui/dlg/FormulaHelper.cxx new file mode 100644 index 000000000..15d3b411a --- /dev/null +++ b/formula/source/ui/dlg/FormulaHelper.cxx @@ -0,0 +1,417 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include <algorithm> + +#include <formula/formulahelper.hxx> +#include <formula/IFunctionDescription.hxx> +#include <unotools/charclass.hxx> +#include <unotools/syslocale.hxx> + +namespace formula +{ + + namespace + { + + class OEmptyFunctionDescription : public IFunctionDescription + { + public: + OEmptyFunctionDescription(){} + virtual ~OEmptyFunctionDescription(){} + + virtual OUString getFunctionName() const override { return OUString(); } + virtual const IFunctionCategory* getCategory() const override { return nullptr; } + virtual OUString getDescription() const override { return OUString(); } + virtual sal_Int32 getSuppressedArgumentCount() const override { return 0; } + virtual OUString getFormula(const ::std::vector< OUString >& ) const override { return OUString(); } + virtual void fillVisibleArgumentMapping(::std::vector<sal_uInt16>& ) const override {} + virtual void initArgumentInfo() const override {} + virtual OUString getSignature() const override { return OUString(); } + virtual OString getHelpId() const override { return ""; } + virtual bool isHidden() const override { return false; } + virtual sal_uInt32 getParameterCount() const override { return 0; } + virtual sal_uInt32 getVarArgsStart() const override { return 0; } + virtual sal_uInt32 getVarArgsLimit() const override { return 0; } + virtual OUString getParameterName(sal_uInt32 ) const override { return OUString(); } + virtual OUString getParameterDescription(sal_uInt32 ) const override { return OUString(); } + virtual bool isParameterOptional(sal_uInt32 ) const override { return false; } + }; + } + +// class FormulaHelper - static Method + + +#define FUNC_NOTFOUND -1 + +FormulaHelper::FormulaHelper(const IFunctionManager* _pFunctionManager) + :m_pSysLocale(new SvtSysLocale) + ,m_pFunctionManager(_pFunctionManager) + ,open(_pFunctionManager->getSingleToken(IFunctionManager::eOk)) + ,close(_pFunctionManager->getSingleToken(IFunctionManager::eClose)) + ,sep(_pFunctionManager->getSingleToken(IFunctionManager::eSep)) + ,arrayOpen(_pFunctionManager->getSingleToken(IFunctionManager::eArrayOpen)) + ,arrayClose(_pFunctionManager->getSingleToken(IFunctionManager::eArrayClose)) +{ + m_pCharClass = &m_pSysLocale->GetCharClass(); +} + +sal_Int32 FormulaHelper::GetCategoryCount() const +{ + return m_pFunctionManager->getCount(); +} + +bool FormulaHelper::GetNextFunc( const OUString& rFormula, + bool bBack, + sal_Int32& rFStart, // Input and output + sal_Int32* pFEnd, // = NULL + const IFunctionDescription** ppFDesc, // = NULL + ::std::vector< OUString>* pArgs ) const // = NULL +{ + sal_Int32 nOldStart = rFStart; + OUString aFname; + + rFStart = GetFunctionStart( rFormula, rFStart, bBack, ppFDesc ? &aFname : nullptr ); + bool bFound = ( rFStart != FUNC_NOTFOUND ); + + if ( bFound ) + { + if ( pFEnd ) + *pFEnd = GetFunctionEnd( rFormula, rFStart ); + + if ( ppFDesc ) + { + *ppFDesc = nullptr; + const sal_uInt32 nCategoryCount = m_pFunctionManager->getCount(); + for(sal_uInt32 j= 0; j < nCategoryCount && !*ppFDesc; ++j) + { + const IFunctionCategory* pCategory = m_pFunctionManager->getCategory(j); + const sal_uInt32 nCount = pCategory->getCount(); + for(sal_uInt32 i = 0 ; i < nCount; ++i) + { + const IFunctionDescription* pCurrent = pCategory->getFunction(i); + if ( pCurrent->getFunctionName().equalsIgnoreAsciiCase(aFname) ) + { + *ppFDesc = pCurrent; + break; + } + }// for(sal_uInt32 i = 0 ; i < nCount; ++i) + } + if ( *ppFDesc && pArgs ) + { + GetArgStrings( *pArgs,rFormula, rFStart, static_cast<sal_uInt16>((*ppFDesc)->getParameterCount() )); + } + else + { + static OEmptyFunctionDescription s_aFunctionDescription; + *ppFDesc = &s_aFunctionDescription; + } + } + } + else + rFStart = nOldStart; + + return bFound; +} + + +void FormulaHelper::FillArgStrings( const OUString& rFormula, + sal_Int32 nFuncPos, + sal_uInt16 nArgs, + ::std::vector< OUString >& _rArgs ) const +{ + sal_Int32 nStart = 0; + sal_Int32 nEnd = 0; + sal_uInt16 i; + bool bLast = false; + + for ( i=0; i<nArgs && !bLast; i++ ) + { + nStart = GetArgStart( rFormula, nFuncPos, i ); + + if ( i+1<nArgs ) // last argument? + { + nEnd = GetArgStart( rFormula, nFuncPos, i+1 ); + + if ( nEnd != nStart ) + _rArgs.push_back(rFormula.copy( nStart, nEnd-1-nStart )); + else + { + _rArgs.emplace_back(); + bLast = true; + } + } + else + { + nEnd = GetFunctionEnd( rFormula, nFuncPos )-1; + if ( nStart < nEnd ) + _rArgs.push_back( rFormula.copy( nStart, nEnd-nStart ) ); + else + _rArgs.emplace_back(); + } + } + + if ( bLast ) + for ( ; i<nArgs; i++ ) + _rArgs.emplace_back(); +} + + +void FormulaHelper::GetArgStrings( ::std::vector< OUString >& _rArgs, + const OUString& rFormula, + sal_Int32 nFuncPos, + sal_uInt16 nArgs ) const +{ + if (nArgs) + { + FillArgStrings( rFormula, nFuncPos, nArgs, _rArgs ); + } +} + + +static bool IsFormulaText( const CharClass* _pCharClass,const OUString& rStr, sal_Int32 nPos ) +{ + if( _pCharClass->isLetterNumeric( rStr, nPos ) ) + return true; + else + { // In internationalized versions function names may contain a dot + // and in every version also an underscore... ;-) + sal_Unicode c = rStr[nPos]; + return c == '.' || c == '_'; + } + +} + +sal_Int32 FormulaHelper::GetFunctionStart( const OUString& rFormula, + sal_Int32 nStart, + bool bBack, + OUString* pFuncName ) const +{ + sal_Int32 nStrLen = rFormula.getLength(); + + if ( nStrLen < nStart ) + return nStart; + + sal_Int32 nFStart = FUNC_NOTFOUND; + sal_Int32 nParPos = bBack ? ::std::min( nStart, nStrLen - 1) : nStart; + + bool bRepeat; + do + { + bool bFound = false; + bRepeat = false; + + if ( bBack ) + { + while ( !bFound && (nParPos > 0) ) + { + if ( rFormula[nParPos] == '"' ) + { + nParPos--; + while ( (nParPos > 0) && rFormula[nParPos] != '"' ) + nParPos--; + if (nParPos > 0) + nParPos--; + } + else + { + bFound = rFormula[nParPos] == '('; + if ( !bFound ) + nParPos--; + } + } + } + else + { + while ( !bFound && (0 <= nParPos && nParPos < nStrLen) ) + { + if ( rFormula[nParPos] == '"' ) + { + nParPos++; + while ( (nParPos < nStrLen) && rFormula[nParPos] != '"' ) + nParPos++; + nParPos++; + } + else + { + bFound = rFormula[nParPos] == '('; + if ( !bFound ) + nParPos++; + } + } + } + + if ( bFound && (nParPos > 0) ) + { + nFStart = nParPos-1; + + while ( (nFStart > 0) && IsFormulaText(m_pCharClass, rFormula, nFStart )) + nFStart--; + } + + nFStart++; + + if ( bFound ) + { + if ( IsFormulaText( m_pCharClass,rFormula, nFStart ) ) + { + // Function found + if ( pFuncName ) + *pFuncName = rFormula.copy( nFStart, nParPos-nFStart ); + } + else // Brackets without function -> keep searching + { + bRepeat = true; + if ( !bBack ) + nParPos++; + else if (nParPos > 0) + nParPos--; + else + bRepeat = false; + } + } + else // No brackets found + { + nFStart = FUNC_NOTFOUND; + if ( pFuncName ) + pFuncName->clear(); + } + } + while(bRepeat); + + return nFStart; +} + + +sal_Int32 FormulaHelper::GetFunctionEnd( const OUString& rStr, sal_Int32 nStart ) const +{ + sal_Int32 nStrLen = rStr.getLength(); + + if ( nStrLen < nStart ) + return nStart; + + short nParCount = 0; + bool bInArray = false; + bool bFound = false; + + while ( !bFound && (nStart < nStrLen) ) + { + sal_Unicode c = rStr[nStart]; + + if ( c == '"' ) + { + nStart++; + while ( (nStart < nStrLen) && rStr[nStart] != '"' ) + nStart++; + } + else if ( c == open ) + nParCount++; + else if ( c == close ) + { + nParCount--; + if ( nParCount == 0 ) + bFound = true; + else if ( nParCount < 0 ) + { + bFound = true; + nStart--; // read one too far + } + } + else if ( c == arrayOpen ) + { + bInArray = true; + } + else if ( c == arrayClose ) + { + bInArray = false; + } + else if ( c == sep ) + { + if ( !bInArray && nParCount == 0 ) + { + bFound = true; + nStart--; // read one too far + } + } + nStart++; // Set behind found position + } + + // nStart > nStrLen can happen if there was an unclosed quote; instead of + // checking that in every loop iteration check it once here. + return std::min(nStart, nStrLen); +} + + +sal_Int32 FormulaHelper::GetArgStart( const OUString& rStr, sal_Int32 nStart, sal_uInt16 nArg ) const +{ + sal_Int32 nStrLen = rStr.getLength(); + + if ( nStrLen < nStart ) + return nStart; + + short nParCount = 0; + bool bInArray = false; + bool bFound = false; + + while ( !bFound && (nStart < nStrLen) ) + { + sal_Unicode c = rStr[nStart]; + + if ( c == '"' ) + { + nStart++; + while ( (nStart < nStrLen) && rStr[nStart] != '"' ) + nStart++; + } + else if ( c == open ) + { + bFound = ( nArg == 0 ); + nParCount++; + } + else if ( c == close ) + { + nParCount--; + bFound = ( nParCount == 0 ); + } + else if ( c == arrayOpen ) + { + bInArray = true; + } + else if ( c == arrayClose ) + { + bInArray = false; + } + else if ( c == sep ) + { + if ( !bInArray && nParCount == 1 ) + { + nArg--; + bFound = ( nArg == 0 ); + } + } + nStart++; + } + + return nStart; +} + +} // formula + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/formula/source/ui/dlg/formula.cxx b/formula/source/ui/dlg/formula.cxx new file mode 100644 index 000000000..9898fe1be --- /dev/null +++ b/formula/source/ui/dlg/formula.cxx @@ -0,0 +1,1960 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include <memory> +#include <sfx2/viewfrm.hxx> +#include <vcl/svapp.hxx> +#include <vcl/weld.hxx> + +#include <sal/log.hxx> + +#include <unotools/charclass.hxx> +#include <tools/diagnose_ex.h> + +#include "funcpage.hxx" +#include <formula/formula.hxx> +#include <formula/IFunctionDescription.hxx> +#include <formula/FormulaCompiler.hxx> +#include <formula/token.hxx> +#include <formula/tokenarray.hxx> +#include <formula/formdata.hxx> +#include <formula/formulahelper.hxx> +#include "structpg.hxx" +#include "parawin.hxx" +#include <strings.hrc> +#include <core_resource.hxx> +#include <com/sun/star/sheet/FormulaToken.hpp> +#include <com/sun/star/sheet/FormulaLanguage.hpp> +#include <com/sun/star/sheet/FormulaMapGroup.hpp> +#include <com/sun/star/sheet/FormulaMapGroupSpecialOffset.hpp> +#include <com/sun/star/sheet/XFormulaOpCodeMapper.hpp> +#include <com/sun/star/sheet/XFormulaParser.hpp> +#include <map> + +// For tab page +#define TOKEN_OPEN 0 +#define TOKEN_CLOSE 1 +namespace formula +{ + +using namespace ::com::sun::star; + +class FormulaDlg_Impl +{ +public: + ::std::pair<RefButton*, RefEdit*> + RefInputStartBefore( RefEdit* pEdit, RefButton* pButton ); + void RefInputStartAfter(); + void RefInputDoneAfter( bool bForced ); + bool CalcValue( const OUString& rStrExp, OUString& rStrResult, bool bForceMatrixFormula = false ); + void CalcStruct( const OUString& rStrExp, bool bForceRecalcStruct = false ); + void UpdateValues( bool bForceRecalcStruct = false ); + void DeleteArgs(); + sal_Int32 GetFunctionPos(sal_Int32 nPos); + void ClearAllParas(); + + void MakeTree(StructPage* _pTree, weld::TreeIter* pParent, const FormulaToken* pFuncToken, + const FormulaToken* _pToken, tools::Long Count); + void fillTree(StructPage* _pTree); + void UpdateTokenArray( const OUString& rStrExp); + OUString RepairFormula(const OUString& aFormula); + void FillDialog(bool bFlag = true); + bool EditNextFunc( bool bForward, sal_Int32 nFStart = NOT_FOUND ); + void EditThisFunc(sal_Int32 nFStart); + + OUString GetPrevFuncExpression( bool bStartFromEnd ); + + void StoreFormEditData(FormEditData* pEditData); + + void Update(); + void Update(const OUString& _sExp); + + void SaveArg( sal_uInt16 nEd ); + void UpdateSelection(); + void DoEnter( bool bOk ); + void FillListboxes(); + void FillControls( bool &rbNext, bool &rbPrev); + + FormulaDlgMode SetMeText( const OUString& _sText, sal_Int32 PrivStart, sal_Int32 PrivEnd, bool bMatrix, bool _bSelect, bool _bUpdate); + void SetMeText(const OUString& _sText); + bool CheckMatrix(OUString& aFormula /*IN/OUT*/); + + void SetEdSelection(); + + bool UpdateParaWin(Selection& _rSelection); + void UpdateParaWin( const Selection& _rSelection, const OUString& _sRefStr); + + void SetData( sal_Int32 nFStart, sal_Int32 nNextFStart, sal_Int32 nNextFEnd, sal_Int32& PrivStart, sal_Int32& PrivEnd); + + RefEdit* GetCurrRefEdit(); + + const FormulaHelper& GetFormulaHelper() const { return m_aFormulaHelper;} + void InitFormulaOpCodeMapper(); + + void UpdateOldSel(); + void FormulaCursor(); + + DECL_LINK( ModifyHdl, ParaWin&, void ); + DECL_LINK( FxHdl, ParaWin&, void ); + + DECL_LINK( MatrixHdl, weld::Toggleable&, void ); + DECL_LINK( FormulaHdl, weld::TextView&, void); + DECL_LINK( FormulaCursorHdl, weld::TextView&, void ); + DECL_LINK( BtnHdl, weld::Button&, void ); + DECL_LINK( DblClkHdl, FuncPage&, void ); + DECL_LINK( FuncSelHdl, FuncPage&, void ); + DECL_LINK( StructSelHdl, StructPage&, void ); +public: + mutable uno::Reference< sheet::XFormulaOpCodeMapper> m_xOpCodeMapper; + uno::Sequence< sheet::FormulaToken > m_aTokenList; + ::std::unique_ptr<FormulaTokenArray> m_pTokenArray; + ::std::unique_ptr<FormulaTokenArrayPlainIterator> m_pTokenArrayIterator; + mutable uno::Sequence< sheet::FormulaOpCodeMapEntry > m_aSpecialOpCodes; + mutable uno::Sequence< sheet::FormulaToken > m_aSeparatorsOpCodes; + mutable uno::Sequence< sheet::FormulaOpCodeMapEntry > m_aFunctionOpCodes; + mutable const sheet::FormulaOpCodeMapEntry* m_pFunctionOpCodesEnd; + ::std::map<const FormulaToken*, sheet::FormulaToken> m_aTokenMap; + IFormulaEditorHelper* m_pHelper; + weld::Dialog& m_rDialog; + + OUString m_aOldFormula; + bool m_bStructUpdate; + bool m_bUserMatrixFlag; + + const OUString m_aTitle1; + const OUString m_aTitle2; + FormulaHelper m_aFormulaHelper; + + OString m_aEditHelpId; + + OString m_aOldHelp; + bool m_bMakingTree; // in method of constructing tree + + bool m_bEditFlag; + const IFunctionDescription* m_pFuncDesc; + sal_Int32 m_nArgs; + ::std::vector< OUString > m_aArguments; + Selection m_aFuncSel; + + sal_Int32 m_nFuncExpStart; ///< current formula position for treeview results + + int m_nSelectionStart; + int m_nSelectionEnd; + + RefEdit* m_pTheRefEdit; + RefButton* m_pTheRefButton; + + std::unique_ptr<weld::Notebook> m_xTabCtrl; + std::unique_ptr<weld::Container> m_xParaWinBox; + std::unique_ptr<ParaWin> m_xParaWin; + std::unique_ptr<weld::Label> m_xFtHeadLine; + std::unique_ptr<weld::Label> m_xFtFuncName; + std::unique_ptr<weld::Label> m_xFtFuncDesc; + + std::unique_ptr<weld::Label> m_xFtEditName; + + std::unique_ptr<weld::Label> m_xFtResult; + std::unique_ptr<weld::Entry> m_xWndResult; + + std::unique_ptr<weld::Label> m_xFtFormula; + std::unique_ptr<weld::TextView> m_xMEdit; + + std::unique_ptr<weld::CheckButton> m_xBtnMatrix; + std::unique_ptr<weld::Button> m_xBtnCancel; + + std::unique_ptr<weld::Button> m_xBtnBackward; + std::unique_ptr<weld::Button> m_xBtnForward; + std::unique_ptr<weld::Button> m_xBtnEnd; + + std::unique_ptr<weld::Label> m_xFtFormResult; + std::unique_ptr<weld::Entry> m_xWndFormResult; + + std::unique_ptr<RefEdit> m_xEdRef; + std::unique_ptr<RefButton> m_xRefBtn; + + std::unique_ptr<FuncPage> m_xFuncPage; + std::unique_ptr<StructPage> m_xStructPage; + + FormulaDlg_Impl(weld::Dialog& rDialog, + weld::Builder& rBuilder, + bool _bSupportFunctionResult, + bool _bSupportResult, + bool _bSupportMatrix, + IFormulaEditorHelper* _pHelper, + const IFunctionManager* _pFunctionMgr, + IControlReferenceHandler* _pDlg); + ~FormulaDlg_Impl(); +}; + +FormulaDlg_Impl::FormulaDlg_Impl(weld::Dialog& rDialog, + weld::Builder& rBuilder, + bool _bSupportFunctionResult, + bool _bSupportResult, + bool _bSupportMatrix, + IFormulaEditorHelper* _pHelper, + const IFunctionManager* _pFunctionMgr, + IControlReferenceHandler* _pDlg) + : m_pFunctionOpCodesEnd(nullptr) + , m_pHelper(_pHelper) + , m_rDialog(rDialog) + , m_bUserMatrixFlag(false) + , m_aTitle1( ForResId( STR_TITLE1 ) ) + , m_aTitle2( ForResId( STR_TITLE2 ) ) + , m_aFormulaHelper(_pFunctionMgr) + , m_bMakingTree(false) + , m_pFuncDesc(nullptr) + , m_nArgs(0) + , m_nFuncExpStart(0) + , m_nSelectionStart(-1) + , m_nSelectionEnd(-1) + , m_pTheRefEdit(nullptr) + , m_pTheRefButton(nullptr) + , m_xTabCtrl(rBuilder.weld_notebook("tabcontrol")) + , m_xParaWinBox(rBuilder.weld_container("BOX")) + , m_xFtHeadLine(rBuilder.weld_label("headline")) + , m_xFtFuncName(rBuilder.weld_label("funcname")) + , m_xFtFuncDesc(rBuilder.weld_label("funcdesc")) + , m_xFtEditName(rBuilder.weld_label("editname")) + , m_xFtResult(rBuilder.weld_label("label2")) + , m_xWndResult(rBuilder.weld_entry("result")) + , m_xFtFormula(rBuilder.weld_label("formula")) + , m_xMEdit(rBuilder.weld_text_view("ed_formula")) + , m_xBtnMatrix(rBuilder.weld_check_button("array")) + , m_xBtnCancel(rBuilder.weld_button("cancel")) + , m_xBtnBackward(rBuilder.weld_button("back")) + , m_xBtnForward(rBuilder.weld_button("next")) + , m_xBtnEnd(rBuilder.weld_button("ok")) + , m_xFtFormResult(rBuilder.weld_label("label1")) + , m_xWndFormResult(rBuilder.weld_entry("formula_result")) + , m_xEdRef(new RefEdit(rBuilder.weld_entry("ED_REF"))) + , m_xRefBtn(new RefButton(rBuilder.weld_button("RB_REF"))) +{ + auto nWidth = m_xMEdit->get_approximate_digit_width() * 62; + + //Space for two lines of text + m_xFtHeadLine->set_label("X\nX\n"); + auto nHeight = m_xFtHeadLine->get_preferred_size().Height(); + m_xFtHeadLine->set_size_request(nWidth, nHeight); + m_xFtHeadLine->set_label(""); + + m_xFtFuncName->set_label("X\nX\n"); + nHeight = m_xFtFuncName->get_preferred_size().Height(); + m_xFtFuncName->set_size_request(nWidth, nHeight); + m_xFtFuncDesc->set_size_request(nWidth, nHeight); + m_xFtFuncName->set_label(""); + + m_xMEdit->set_size_request(nWidth, + m_xMEdit->get_height_rows(5)); + + m_xEdRef->SetReferences(_pDlg, m_xFtEditName.get()); + m_xRefBtn->SetReferences(_pDlg, m_xEdRef.get()); + + m_xParaWin.reset(new ParaWin(m_xParaWinBox.get(), _pDlg)); + m_xParaWin->Show(); + m_xParaWinBox->hide(); + m_xFtEditName->hide(); + m_xEdRef->GetWidget()->hide(); + m_xRefBtn->GetWidget()->hide(); + + m_xMEdit->set_accessible_name(m_xFtFormula->get_label()); + + m_aEditHelpId = m_xMEdit->get_help_id(); + + m_bEditFlag =false; + m_bStructUpdate =true; + m_xParaWin->SetArgModifiedHdl( LINK( this, FormulaDlg_Impl, ModifyHdl ) ); + m_xParaWin->SetFxHdl( LINK( this, FormulaDlg_Impl, FxHdl ) ); + + m_xFuncPage.reset(new FuncPage(m_xTabCtrl->get_page("function"), _pFunctionMgr)); + m_xStructPage.reset(new StructPage(m_xTabCtrl->get_page("struct"))); + m_xTabCtrl->set_current_page("function"); + + m_aOldHelp = m_rDialog.get_help_id(); // HelpId from resource always for "Page 1" + + m_xFtResult->set_visible( _bSupportResult ); + m_xWndResult->set_visible( _bSupportResult ); + + m_xFtFormResult->set_visible( _bSupportFunctionResult ); + m_xWndFormResult->set_visible( _bSupportFunctionResult ); + + if ( _bSupportMatrix ) + m_xBtnMatrix->connect_toggled( LINK( this, FormulaDlg_Impl, MatrixHdl ) ); + else + m_xBtnMatrix->hide(); + + m_xBtnCancel->connect_clicked( LINK( this, FormulaDlg_Impl, BtnHdl ) ); + m_xBtnEnd->connect_clicked( LINK( this, FormulaDlg_Impl, BtnHdl ) ); + m_xBtnForward->connect_clicked( LINK( this, FormulaDlg_Impl, BtnHdl ) ); + m_xBtnBackward->connect_clicked( LINK( this, FormulaDlg_Impl, BtnHdl ) ); + + m_xFuncPage->SetDoubleClickHdl( LINK( this, FormulaDlg_Impl, DblClkHdl ) ); + m_xFuncPage->SetSelectHdl( LINK( this, FormulaDlg_Impl, FuncSelHdl) ); + m_xStructPage->SetSelectionHdl( LINK( this, FormulaDlg_Impl, StructSelHdl ) ); + m_xMEdit->connect_changed( LINK( this, FormulaDlg_Impl, FormulaHdl ) ); + m_xMEdit->connect_cursor_position( LINK( this, FormulaDlg_Impl, FormulaCursorHdl ) ); + + vcl::Font aFntLight = m_xFtFormula->get_font(); + vcl::Font aFntBold = aFntLight; + aFntBold.SetWeight( WEIGHT_BOLD ); + + m_xParaWin->SetArgumentFonts( aFntBold, aFntLight); +} + +FormulaDlg_Impl::~FormulaDlg_Impl() +{ + m_xTabCtrl->remove_page("function"); + m_xTabCtrl->remove_page("struct"); + + DeleteArgs(); +} + +void FormulaDlg_Impl::StoreFormEditData(FormEditData* pData) +{ + if (!pData) // it won't be destroyed via Close + return; + + int nStartPos, nEndPos; + m_xMEdit->get_selection_bounds(nStartPos, nEndPos); + if (nStartPos > nEndPos) + std::swap(nStartPos, nEndPos); + + pData->SetFStart(nStartPos); + pData->SetSelection(Selection(nStartPos, nEndPos)); + + if (m_xTabCtrl->get_current_page_ident() == "function") + pData->SetMode( FormulaDlgMode::Formula ); + else + pData->SetMode( FormulaDlgMode::Edit ); + pData->SetUndoStr(m_xMEdit->get_text()); + pData->SetMatrixFlag(m_xBtnMatrix->get_active()); +} + +void FormulaDlg_Impl::InitFormulaOpCodeMapper() +{ + if ( m_xOpCodeMapper.is() ) + return; + + m_xOpCodeMapper = m_pHelper->getFormulaOpCodeMapper(); + m_aFunctionOpCodes = m_xOpCodeMapper->getAvailableMappings( sheet::FormulaLanguage::ODFF, sheet::FormulaMapGroup::FUNCTIONS); + m_pFunctionOpCodesEnd = m_aFunctionOpCodes.getConstArray() + m_aFunctionOpCodes.getLength(); + + // 0:TOKEN_OPEN, 1:TOKEN_CLOSE, 2:TOKEN_SEP + uno::Sequence< OUString > aArgs { "(", ")", ";" }; + m_aSeparatorsOpCodes = m_xOpCodeMapper->getMappings( aArgs, sheet::FormulaLanguage::ODFF); + + m_aSpecialOpCodes = m_xOpCodeMapper->getAvailableMappings( sheet::FormulaLanguage::ODFF, sheet::FormulaMapGroup::SPECIAL); +} + +void FormulaDlg_Impl::DeleteArgs() +{ + ::std::vector< OUString>().swap(m_aArguments); + m_nArgs = 0; +} + +sal_Int32 FormulaDlg_Impl::GetFunctionPos(sal_Int32 nPos) +{ + if ( !m_aTokenList.hasElements() ) + return SAL_MAX_INT32; + + const sal_Unicode sep = m_pHelper->getFunctionManager()->getSingleToken(IFunctionManager::eSep); + + sal_Int32 nFuncPos = SAL_MAX_INT32; + OUString aFormString = m_aFormulaHelper.GetCharClass()->uppercase(m_xMEdit->get_text()); + + const uno::Reference< sheet::XFormulaParser > xParser(m_pHelper->getFormulaParser()); + const table::CellAddress aRefPos(m_pHelper->getReferencePosition()); + + const sheet::FormulaToken* pIter = m_aTokenList.getConstArray(); + const sheet::FormulaToken* pEnd = pIter + m_aTokenList.getLength(); + try + { + bool bFlag = false; + sal_Int32 nTokPos = 1; + sal_Int32 nOldTokPos = 1; + sal_Int32 nPrevFuncPos = 1; + short nBracketCount = 0; + const sal_Int32 nOpPush = m_aSpecialOpCodes[sheet::FormulaMapGroupSpecialOffset::PUSH].Token.OpCode; + const sal_Int32 nOpSpaces = m_aSpecialOpCodes[sheet::FormulaMapGroupSpecialOffset::SPACES].Token.OpCode; + const sal_Int32 nOpWhitespace = m_aSpecialOpCodes[sheet::FormulaMapGroupSpecialOffset::WHITESPACE].Token.OpCode; + while ( pIter != pEnd ) + { + const sal_Int32 eOp = pIter->OpCode; + uno::Sequence<sheet::FormulaToken> aArgs { *pIter }; + const OUString aString = xParser->printFormula( aArgs, aRefPos); + const sheet::FormulaToken* pNextToken = pIter + 1; + + if ( !m_bUserMatrixFlag && FormulaCompiler::IsMatrixFunction(static_cast<OpCode>(eOp)) ) + { + m_xBtnMatrix->set_active(true); + } + + if (eOp == nOpPush || eOp == nOpSpaces || eOp == nOpWhitespace) + { + const sal_Int32 n1 = nTokPos < 0 ? -1 : aFormString.indexOf( sep, nTokPos); + const sal_Int32 n2 = nTokPos < 0 ? -1 : aFormString.indexOf( ')', nTokPos); + sal_Int32 nXXX = nTokPos; + if ( n1 < n2 && n1 != -1 ) + { + nTokPos = n1; + } + else + { + nTokPos = n2; + } + if ( pNextToken != pEnd ) + { + aArgs.getArray()[0] = *pNextToken; + const OUString a2String = xParser->printFormula( aArgs, aRefPos); + const sal_Int32 n3 = nXXX < 0 ? -1 : aFormString.indexOf( a2String, nXXX); + if (n3 < nTokPos && n3 != -1) + nTokPos = n3; + } + } + else + { + nTokPos = nTokPos + aString.getLength(); + } + + if ( eOp == m_aSeparatorsOpCodes[TOKEN_OPEN].OpCode ) + { + nBracketCount++; + bFlag = true; + } + else if ( eOp == m_aSeparatorsOpCodes[TOKEN_CLOSE].OpCode ) + { + nBracketCount--; + bFlag = false; + nFuncPos = nPrevFuncPos; + } + bool bIsFunction = std::any_of( m_aFunctionOpCodes.getConstArray(), + m_pFunctionOpCodesEnd, + [&eOp](const sheet::FormulaOpCodeMapEntry& aEntry) { return aEntry.Token.OpCode == eOp; }); + + if ( bIsFunction && nOpSpaces != eOp && nOpWhitespace != eOp ) + { + nPrevFuncPos = nFuncPos; + nFuncPos = nOldTokPos; + } + + if ( nOldTokPos <= nPos && nPos < nTokPos ) + { + if ( !bIsFunction ) + { + if ( nBracketCount < 1 ) + { + nFuncPos = m_xMEdit->get_text().getLength(); + } + else if ( !bFlag ) + { + nFuncPos = nPrevFuncPos; + } + } + break; + } + + pIter = pNextToken; + nOldTokPos = nTokPos; + } // while ( pIter != pEnd ) + } + catch ( const uno::Exception& ) + { + TOOLS_WARN_EXCEPTION("formula.ui", "FormulaDlg_Impl::GetFunctionPos"); + } + + return nFuncPos; +} + +bool FormulaDlg_Impl::CalcValue( const OUString& rStrExp, OUString& rStrResult, bool bForceMatrixFormula ) +{ + bool bResult = true; + + if ( !rStrExp.isEmpty() ) + { + // Only calculate the value when there isn't any more keyboard input: + + // Make this debuggable by assigning to a variable that can be changed + // from within the debugger. + bool bInput = Application::AnyInput( VclInputFlags::KEYBOARD ); + if ( !bInput ) + { + bResult = m_pHelper->calculateValue( rStrExp, rStrResult, bForceMatrixFormula || m_xBtnMatrix->get_active()); + } + else + bResult = false; + } + + return bResult; +} + +void FormulaDlg_Impl::UpdateValues( bool bForceRecalcStruct ) +{ + // Take a force-array context into account. RPN creation propagated those + // to tokens that are ref-counted so also available in the token array. + bool bForceArray = false; + // Only necessary if it's not a matrix formula anyway and matrix evaluation + // is supported, i.e. the button is visible. + if (m_xBtnMatrix->get_visible() && !m_xBtnMatrix->get_active()) + { + std::unique_ptr<FormulaCompiler> pCompiler(m_pHelper->createCompiler(*m_pTokenArray)); + // In the case of the reportdesign dialog there is no currently active + // OpCode symbol mapping that could be used to create strings from + // tokens, it's all dreaded API mapping. However, in that case there's + // no array/matrix support anyway, but ensure checking. + if (pCompiler->GetCurrentOpCodeMap()) + { + const sal_Int32 nPos = m_aFuncSel.Min(); + assert( 0 <= nPos && nPos < m_pHelper->getCurrentFormula().getLength()); + OUStringBuffer aBuf; + const FormulaToken* pToken = nullptr; + for (pToken = m_pTokenArrayIterator->First(); pToken; pToken = m_pTokenArrayIterator->Next()) + { + pCompiler->CreateStringFromToken( aBuf, pToken); + if (nPos < aBuf.getLength()) + break; + } + if (pToken && nPos < aBuf.getLength()) + bForceArray = pToken->IsInForceArray(); + } + } + + OUString aStrResult; + if (m_pFuncDesc && CalcValue( m_pFuncDesc->getFormula( m_aArguments), aStrResult, bForceArray)) + m_xWndResult->set_text( aStrResult ); + + if (m_bMakingTree) + return; + + aStrResult.clear(); + if ( CalcValue( m_pHelper->getCurrentFormula(), aStrResult ) ) + m_xWndFormResult->set_text( aStrResult ); + else + { + aStrResult.clear(); + m_xWndFormResult->set_text( aStrResult ); + } + CalcStruct( m_xMEdit->get_text(), bForceRecalcStruct); +} + +void FormulaDlg_Impl::CalcStruct( const OUString& rStrExp, bool bForceRecalcStruct ) +{ + sal_Int32 nLength = rStrExp.getLength(); + + if ( !(!rStrExp.isEmpty() && (bForceRecalcStruct || m_aOldFormula != rStrExp) && m_bStructUpdate)) + return; + + m_xStructPage->ClearStruct(); + + OUString aString = rStrExp; + if (rStrExp[nLength-1] == '(') + { + aString = aString.copy( 0, nLength-1); + } + + aString = aString.replaceAll( "\n", ""); + OUString aStrResult; + + if ( CalcValue( aString, aStrResult ) ) + m_xWndFormResult->set_text(aStrResult); + + UpdateTokenArray(aString); + fillTree(m_xStructPage.get()); + + m_aOldFormula = rStrExp; + if (rStrExp[nLength-1] == '(') + UpdateTokenArray(rStrExp); +} + +void FormulaDlg_Impl::MakeTree(StructPage* _pTree, weld::TreeIter* pParent, const FormulaToken* pFuncToken, + const FormulaToken* _pToken, tools::Long Count) +{ + if ( _pToken == nullptr || Count <= 0 ) + return; + + tools::Long nParas = _pToken->GetParamCount(); + OpCode eOp = _pToken->GetOpCode(); + + // #i101512# for output, the original token is needed + const FormulaToken* pOrigToken = (_pToken->GetType() == svFAP) ? _pToken->GetFAPOrigToken() : _pToken; + ::std::map<const FormulaToken*, sheet::FormulaToken>::const_iterator itr = m_aTokenMap.find(pOrigToken); + if (itr == m_aTokenMap.end()) + return; + + uno::Sequence<sheet::FormulaToken> aArgs { itr->second }; + try + { + const table::CellAddress aRefPos(m_pHelper->getReferencePosition()); + const OUString aResult = m_pHelper->getFormulaParser()->printFormula( aArgs, aRefPos); + + if ( nParas > 0 || (nParas == 0 && _pToken->IsFunction()) ) + { + std::unique_ptr<weld::TreeIter> xEntry; + weld::TreeIter* pEntry; + + bool bCalcSubformula = false; + OUString aTest = _pTree->GetEntryText(pParent); + + if (aTest == aResult && (eOp == ocAdd || eOp == ocMul || eOp == ocAmpersand)) + { + pEntry = pParent; + } + else + { + xEntry = m_xStructPage->GetTlbStruct().make_iterator(); + + if (eOp == ocBad) + { + _pTree->InsertEntry(aResult, pParent, STRUCT_ERROR, 0, _pToken, *xEntry); + } + else if (!((SC_OPCODE_START_BIN_OP <= eOp && eOp < SC_OPCODE_STOP_BIN_OP) || + (SC_OPCODE_START_UN_OP <= eOp && eOp < SC_OPCODE_STOP_UN_OP))) + { + // Not a binary or unary operator. + bCalcSubformula = true; + _pTree->InsertEntry(aResult, pParent, STRUCT_FOLDER, 0, _pToken, *xEntry); + } + else + { + /* TODO: question remains, why not sub calculate operators? */ + _pTree->InsertEntry(aResult, pParent, STRUCT_FOLDER, 0, _pToken, *xEntry); + } + + pEntry = xEntry.get(); + } + + MakeTree(_pTree, pEntry, _pToken, m_pTokenArrayIterator->PrevRPN(), nParas); + + if (bCalcSubformula) + { + OUString aFormula; + + if (!m_bMakingTree) + { + // gets the last subformula result + m_bMakingTree = true; + aFormula = GetPrevFuncExpression( true); + } + else + { + // gets subsequent subformula results (from the back) + aFormula = GetPrevFuncExpression( false); + } + + OUString aStr; + if (CalcValue( aFormula, aStr, _pToken->IsInForceArray())) + m_xWndResult->set_text( aStr ); + aStr = m_xWndResult->get_text(); + m_xStructPage->GetTlbStruct().set_text(*pEntry, aResult + " = " + aStr); + } + + --Count; + m_pTokenArrayIterator->NextRPN(); /* TODO: what's this to be? ThisRPN()? */ + MakeTree( _pTree, pParent, _pToken, m_pTokenArrayIterator->PrevRPN(), Count); + } + else + { + std::unique_ptr<weld::TreeIter> xEntry(m_xStructPage->GetTlbStruct().make_iterator()); + if (eOp == ocBad) + { + _pTree->InsertEntry( aResult, pParent, STRUCT_ERROR, 0, _pToken, *xEntry); + } + else if (eOp == ocPush) + { + // Interpret range reference in matrix context to resolve + // as array elements. Depending on parameter classification + // a scalar value (non-array context) is calculated first. + OUString aUnforcedResult; + bool bForceMatrix = (!m_xBtnMatrix->get_active() && + (_pToken->GetType() == svDoubleRef || _pToken->GetType() == svExternalDoubleRef)); + if (bForceMatrix && pFuncToken) + { + formula::ParamClass eParamClass = ParamClass::Reference; + if (pFuncToken->IsInForceArray()) + eParamClass = ParamClass::ForceArray; + else + { + std::shared_ptr<FormulaCompiler> pCompiler = m_pHelper->getCompiler(); + if (pCompiler) + eParamClass = pCompiler->GetForceArrayParameter( pFuncToken, Count - 1); + } + switch (eParamClass) + { + case ParamClass::Unknown: + case ParamClass::Bounds: + case ParamClass::Value: + if (CalcValue( "=" + aResult, aUnforcedResult, false) && aUnforcedResult != aResult) + aUnforcedResult += " "; + else + aUnforcedResult.clear(); + break; + case ParamClass::Reference: + case ParamClass::ReferenceOrRefArray: + case ParamClass::Array: + case ParamClass::ForceArray: + case ParamClass::ReferenceOrForceArray: + case ParamClass::SuppressedReferenceOrForceArray: + case ParamClass::ForceArrayReturn: + ; // nothing, only as array/matrix + // no default to get compiler warning + } + } + OUString aCellResult; + if (CalcValue( "=" + aResult, aCellResult, bForceMatrix) && aCellResult != aResult) + { + // Cell is a formula, print subformula. + // With scalar values prints "A1:A3 = 2 {1;2;3}" + _pTree->InsertEntry( aResult + " = " + aUnforcedResult + aCellResult, + pParent, STRUCT_END, 0, _pToken, *xEntry); + } + else + _pTree->InsertEntry(aResult, pParent, STRUCT_END, 0, _pToken, *xEntry); + } + else + { + _pTree->InsertEntry(aResult, pParent, STRUCT_END, 0, _pToken, *xEntry); + } + --Count; + MakeTree( _pTree, pParent, _pToken, m_pTokenArrayIterator->PrevRPN(), Count); + } + } + catch (const uno::Exception&) + { + DBG_UNHANDLED_EXCEPTION("formula.ui"); + } +} + +void FormulaDlg_Impl::fillTree(StructPage* _pTree) +{ + InitFormulaOpCodeMapper(); + FormulaToken* pToken = m_pTokenArrayIterator->LastRPN(); + + if ( pToken != nullptr) + { + MakeTree( _pTree, nullptr, nullptr, pToken, 1); + m_bMakingTree = false; + } +} + +void FormulaDlg_Impl::UpdateTokenArray( const OUString& rStrExp) +{ + m_aTokenMap.clear(); + m_aTokenList.realloc(0); + try + { + const table::CellAddress aRefPos(m_pHelper->getReferencePosition()); + m_aTokenList = m_pHelper->getFormulaParser()->parseFormula( rStrExp, aRefPos); + } + catch (const uno::Exception&) + { + DBG_UNHANDLED_EXCEPTION("formula.ui"); + } + InitFormulaOpCodeMapper(); + m_pTokenArray = m_pHelper->convertToTokenArray(m_aTokenList); + m_pTokenArrayIterator.reset(new FormulaTokenArrayPlainIterator(*m_pTokenArray)); + const sal_Int32 nLen = static_cast<sal_Int32>(m_pTokenArray->GetLen()); + FormulaToken** pTokens = m_pTokenArray->GetArray(); + if ( pTokens && nLen == m_aTokenList.getLength() ) + { + for (sal_Int32 nPos = 0; nPos < nLen; nPos++) + { + m_aTokenMap.emplace( pTokens[nPos], m_aTokenList[nPos] ); + } + } // if ( pTokens && nLen == m_aTokenList.getLength() ) + + std::unique_ptr<FormulaCompiler> pCompiler(m_pHelper->createCompiler(*m_pTokenArray)); + // #i101512# Disable special handling of jump commands. + pCompiler->EnableJumpCommandReorder(false); + pCompiler->EnableStopOnError(false); + pCompiler->SetComputeIIFlag(true); + pCompiler->SetMatrixFlag(m_bUserMatrixFlag); + pCompiler->CompileTokenArray(); +} + +void FormulaDlg_Impl::FillDialog(bool bFlag) +{ + bool bNext = true, bPrev = true; + if (bFlag) + FillControls( bNext, bPrev); + FillListboxes(); + if (bFlag) + { + m_xBtnBackward->set_sensitive(bPrev); + m_xBtnForward->set_sensitive(bNext); + } + + OUString aStrResult; + + if ( CalcValue( m_pHelper->getCurrentFormula(), aStrResult ) ) + m_xWndFormResult->set_text( aStrResult ); + else + { + aStrResult.clear(); + m_xWndFormResult->set_text( aStrResult ); + } +} + +void FormulaDlg_Impl::FillListboxes() +{ + // Switch between the "Pages" + FormEditData* pData = m_pHelper->getFormEditData(); + // 1. Page: select function + if ( m_pFuncDesc && m_pFuncDesc->getCategory() ) + { + // We'll never have more than int32 max categories so this is safe ... + // Category listbox holds additional entries for Last Used and All, so + // the offset should be two but hard coded numbers are ugly... + const sal_Int32 nCategoryOffset = m_xFuncPage->GetCategoryEntryCount() - m_aFormulaHelper.GetCategoryCount(); + if ( m_xFuncPage->GetCategory() != static_cast<sal_Int32>(m_pFuncDesc->getCategory()->getNumber() + nCategoryOffset) ) + m_xFuncPage->SetCategory(m_pFuncDesc->getCategory()->getNumber() + nCategoryOffset); + + sal_Int32 nPos = m_xFuncPage->GetFuncPos(m_pFuncDesc); + + m_xFuncPage->SetFunction(nPos); + } + else if ( pData ) + { + m_xFuncPage->SetCategory( 1 ); + m_xFuncPage->SetFunction( -1 ); + } + FuncSelHdl(*m_xFuncPage); + + m_pHelper->setDispatcherLock( true ); // Activate Modal-Mode + + // HelpId for 1. page is the one from the resource + m_rDialog.set_help_id( m_aOldHelp ); +} + +void FormulaDlg_Impl::FillControls( bool &rbNext, bool &rbPrev) +{ + // Switch between the "Pages" + FormEditData* pData = m_pHelper->getFormEditData(); + if (!pData ) + return; + + // 2. Page or Edit: show selected function + + sal_Int32 nFStart = pData->GetFStart(); + OUString aFormula = m_pHelper->getCurrentFormula() + " )"; + sal_Int32 nNextFStart = nFStart; + sal_Int32 nNextFEnd = 0; + + DeleteArgs(); + const IFunctionDescription* pOldFuncDesc = m_pFuncDesc; + + if ( m_aFormulaHelper.GetNextFunc( aFormula, false, + nNextFStart, &nNextFEnd, &m_pFuncDesc, &m_aArguments ) ) + { + const bool bTestFlag = (pOldFuncDesc != m_pFuncDesc); + if (bTestFlag) + { + m_xFtHeadLine->hide(); + m_xFtFuncName->hide(); + m_xFtFuncDesc->hide(); + m_xParaWin->SetFunctionDesc(m_pFuncDesc); + m_xFtEditName->set_label( m_pFuncDesc->getFunctionName() ); + m_xFtEditName->show(); + m_xParaWinBox->show(); + const OString aHelpId = m_pFuncDesc->getHelpId(); + if ( !aHelpId.isEmpty() ) + m_xMEdit->set_help_id(aHelpId); + } + + sal_Int32 nOldStart, nOldEnd; + m_pHelper->getSelection( nOldStart, nOldEnd ); + if ( nOldStart != nNextFStart || nOldEnd != nNextFEnd ) + { + m_pHelper->setSelection( nNextFStart, nNextFEnd ); + } + m_aFuncSel.Min() = nNextFStart; + m_aFuncSel.Max() = nNextFEnd; + + if (!m_bEditFlag) + m_xMEdit->set_text(m_pHelper->getCurrentFormula()); + sal_Int32 PrivStart, PrivEnd; + m_pHelper->getSelection( PrivStart, PrivEnd); + if (!m_bEditFlag) + m_xMEdit->select_region(PrivStart, PrivEnd); + + m_nArgs = m_pFuncDesc->getSuppressedArgumentCount(); + sal_uInt16 nOffset = pData->GetOffset(); + + // Concatenate the Edit's for Focus-Control + + if (bTestFlag) + m_xParaWin->SetArgumentOffset(nOffset); + sal_uInt16 nActiv = 0; + sal_Int32 nArgPos = m_aFormulaHelper.GetArgStart( aFormula, nFStart, 0 ); + + int nStartPos, nEndPos; + m_xMEdit->get_selection_bounds(nStartPos, nEndPos); + if (nStartPos > nEndPos) + std::swap(nStartPos, nEndPos); + + sal_Int32 nEditPos = nStartPos; + bool bFlag = false; + + for (sal_Int32 i = 0; i < m_nArgs; i++) + { + sal_Int32 nLength = m_aArguments[i].getLength()+1; + m_xParaWin->SetArgument( i, m_aArguments[i]); + if (nArgPos <= nEditPos && nEditPos < nArgPos+nLength) + { + nActiv = i; + bFlag = true; + } + nArgPos = nArgPos + nLength; + } + m_xParaWin->UpdateParas(); + + if (bFlag) + { + m_xParaWin->SetActiveLine(nActiv); + } + + UpdateValues(); + } + else + { + m_xFtEditName->set_label(""); + m_xMEdit->set_help_id(m_aEditHelpId); + } + // test if before/after are anymore functions + + sal_Int32 nTempStart = m_aFormulaHelper.GetArgStart( aFormula, nFStart, 0 ); + rbNext = m_aFormulaHelper.GetNextFunc( aFormula, false, nTempStart ); + + int nStartPos, nEndPos; + m_xMEdit->get_selection_bounds(nStartPos, nEndPos); + if (nStartPos > nEndPos) + std::swap(nStartPos, nEndPos); + + nTempStart = nStartPos; + pData->SetFStart(nTempStart); + rbPrev = m_aFormulaHelper.GetNextFunc( aFormula, true, nTempStart ); +} + + +void FormulaDlg_Impl::ClearAllParas() +{ + DeleteArgs(); + m_pFuncDesc = nullptr; + m_xParaWin->ClearAll(); + m_xWndResult->set_text(OUString()); + m_xFtFuncName->set_label(OUString()); + FuncSelHdl(*m_xFuncPage); + + if (m_xFuncPage->IsVisible()) + { + m_xFtEditName->hide(); + m_xParaWinBox->hide(); + + m_xBtnForward->set_sensitive(true); //@new + m_xFtHeadLine->show(); + m_xFtFuncName->show(); + m_xFtFuncDesc->show(); + } +} + +OUString FormulaDlg_Impl::RepairFormula(const OUString& aFormula) +{ + OUString aResult('='); + try + { + UpdateTokenArray(aFormula); + + if ( m_aTokenList.hasElements() ) + { + const table::CellAddress aRefPos(m_pHelper->getReferencePosition()); + const OUString sFormula( m_pHelper->getFormulaParser()->printFormula( m_aTokenList, aRefPos)); + if ( sFormula.isEmpty() || sFormula[0] != '=' ) + aResult += sFormula; + else + aResult = sFormula; + + } + } + catch ( const uno::Exception& ) + { + TOOLS_WARN_EXCEPTION("formula.ui", "FormulaDlg_Impl::RepairFormula"); + } + return aResult; +} + +void FormulaDlg_Impl::DoEnter(bool bOk) +{ + // Accept input to the document or cancel + if ( bOk) + { + // remove dummy arguments + OUString aInputFormula = m_pHelper->getCurrentFormula(); + OUString aString = RepairFormula(m_xMEdit->get_text()); + m_pHelper->setSelection( 0, aInputFormula.getLength()); + m_pHelper->setCurrentFormula(aString); + } + + m_pHelper->switchBack(); + + m_pHelper->dispatch( bOk, m_xBtnMatrix->get_active()); + // Clear data + m_pHelper->deleteFormData(); + + // Close dialog + m_pHelper->doClose(bOk); +} + + +IMPL_LINK(FormulaDlg_Impl, BtnHdl, weld::Button&, rBtn, void) +{ + if (&rBtn == m_xBtnCancel.get()) + { + DoEnter(false); // closes the Dialog + } + else if (&rBtn == m_xBtnEnd.get()) + { + DoEnter(true); // closes the Dialog + } + else if (&rBtn == m_xBtnForward.get()) + { + const IFunctionDescription* pDesc; + sal_Int32 nSelFunc = m_xFuncPage->GetFunction(); + if (nSelFunc != -1) + pDesc = m_xFuncPage->GetFuncDesc( nSelFunc ); + else + { + // Do not overwrite the selected formula expression, just edit the + // unlisted function. + m_pFuncDesc = pDesc = nullptr; + } + + if (pDesc == m_pFuncDesc || !m_xFuncPage->IsVisible()) + EditNextFunc( true ); + else + { + DblClkHdl(*m_xFuncPage); //new + m_xBtnForward->set_sensitive(false); //new + } + } + else if (&rBtn == m_xBtnBackward.get()) + { + m_bEditFlag = false; + m_xBtnForward->set_sensitive(true); + EditNextFunc( false ); + } +} + +// Functions for 1. Page + +// Handler for Listboxes + +IMPL_LINK_NOARG( FormulaDlg_Impl, DblClkHdl, FuncPage&, void) +{ + sal_Int32 nFunc = m_xFuncPage->GetFunction(); + + // ex-UpdateLRUList + const IFunctionDescription* pDesc = m_xFuncPage->GetFuncDesc(nFunc); + m_pHelper->insertEntryToLRUList(pDesc); + + OUString aFuncName = m_xFuncPage->GetSelFunctionName() + "()"; + m_pHelper->setCurrentFormula(aFuncName); + m_xMEdit->replace_selection(aFuncName); + + int nStartPos, nEndPos; + m_xMEdit->get_selection_bounds(nStartPos, nEndPos); + if (nStartPos > nEndPos) + std::swap(nStartPos, nEndPos); + + nEndPos = nEndPos - 1; + m_xMEdit->select_region(nStartPos, nEndPos); + + FormulaHdl(*m_xMEdit); + + nStartPos = nEndPos; + m_xMEdit->select_region(nStartPos, nEndPos); + + if (m_nArgs == 0) + { + BtnHdl(*m_xBtnBackward); + } + + m_xParaWin->SetEdFocus(); + m_xBtnForward->set_sensitive(false); //@New +} + +// Functions for right Page + +void FormulaDlg_Impl::SetData( sal_Int32 nFStart, sal_Int32 nNextFStart, sal_Int32 nNextFEnd, sal_Int32& PrivStart, sal_Int32& PrivEnd) +{ + sal_Int32 nFEnd; + + // Notice and set new selection + m_pHelper->getSelection( nFStart, nFEnd ); + m_pHelper->setSelection( nNextFStart, nNextFEnd ); + if (!m_bEditFlag) + m_xMEdit->set_text(m_pHelper->getCurrentFormula()); + + + m_pHelper->getSelection( PrivStart, PrivEnd); + if (!m_bEditFlag) + { + m_xMEdit->select_region(PrivStart, PrivEnd); + UpdateOldSel(); + } + + FormEditData* pData = m_pHelper->getFormEditData(); + pData->SetFStart( nNextFStart ); + pData->SetOffset( 0 ); + + FillDialog(); +} + +void FormulaDlg_Impl::EditThisFunc(sal_Int32 nFStart) +{ + FormEditData* pData = m_pHelper->getFormEditData(); + if (!pData) + return; + + OUString aFormula = m_pHelper->getCurrentFormula(); + + if (nFStart == NOT_FOUND) + { + nFStart = pData->GetFStart(); + } + else + { + pData->SetFStart(nFStart); + } + + sal_Int32 nNextFStart = nFStart; + sal_Int32 nNextFEnd = 0; + + bool bFound; + + bFound = m_aFormulaHelper.GetNextFunc( aFormula, false, nNextFStart, &nNextFEnd); + if ( bFound ) + { + sal_Int32 PrivStart, PrivEnd; + SetData( nFStart, nNextFStart, nNextFEnd, PrivStart, PrivEnd); + m_pHelper->showReference( aFormula.copy( PrivStart, PrivEnd-PrivStart)); + } + else + { + ClearAllParas(); + } +} + +bool FormulaDlg_Impl::EditNextFunc( bool bForward, sal_Int32 nFStart ) +{ + FormEditData* pData = m_pHelper->getFormEditData(); + if (!pData) + return false; + + OUString aFormula = m_pHelper->getCurrentFormula(); + + if (nFStart == NOT_FOUND) + { + nFStart = pData->GetFStart(); + } + else + { + pData->SetFStart(nFStart); + } + + sal_Int32 nNextFStart = 0; + sal_Int32 nNextFEnd = 0; + + bool bFound; + if ( bForward ) + { + nNextFStart = m_aFormulaHelper.GetArgStart( aFormula, nFStart, 0 ); + bFound = m_aFormulaHelper.GetNextFunc( aFormula, false, nNextFStart, &nNextFEnd); + } + else + { + nNextFStart = nFStart; + bFound = m_aFormulaHelper.GetNextFunc( aFormula, true, nNextFStart, &nNextFEnd); + } + + if ( bFound ) + { + sal_Int32 PrivStart, PrivEnd; + SetData( nFStart, nNextFStart, nNextFEnd, PrivStart, PrivEnd); + } + + return bFound; +} + +OUString FormulaDlg_Impl::GetPrevFuncExpression( bool bStartFromEnd ) +{ + OUString aExpression; + + OUString aFormula( m_pHelper->getCurrentFormula()); + if (aFormula.isEmpty()) + return aExpression; + + if (bStartFromEnd || m_nFuncExpStart >= aFormula.getLength()) + m_nFuncExpStart = aFormula.getLength() - 1; + + sal_Int32 nFStart = m_nFuncExpStart; + sal_Int32 nFEnd = 0; + if (m_aFormulaHelper.GetNextFunc( aFormula, true, nFStart, &nFEnd)) + { + aExpression = aFormula.copy( nFStart, nFEnd - nFStart); // nFEnd is exclusive + m_nFuncExpStart = nFStart; + } + + return aExpression; +} + +void FormulaDlg_Impl::SaveArg( sal_uInt16 nEd ) +{ + if (nEd >= m_nArgs) + return; + + for (sal_uInt16 i = 0; i <= nEd; i++) + { + if ( m_aArguments[i].isEmpty() ) + m_aArguments[i] = " "; + } + if (!m_xParaWin->GetArgument(nEd).isEmpty()) + m_aArguments[nEd] = m_xParaWin->GetArgument(nEd); + + sal_uInt16 nClearPos = nEd+1; + for (sal_Int32 i = nEd+1; i < m_nArgs; i++) + { + if ( !m_xParaWin->GetArgument(i).isEmpty() ) + { + nClearPos = i+1; + } + } + + for (sal_Int32 i = nClearPos; i < m_nArgs; i++) + { + m_aArguments[i].clear(); + } +} + +IMPL_LINK( FormulaDlg_Impl, FxHdl, ParaWin&, rPtr, void ) +{ + if (&rPtr != m_xParaWin.get()) + return; + + m_xBtnForward->set_sensitive(true); //@ In order to be able to input another function. + m_xTabCtrl->set_current_page("function"); + + OUString aUndoStr = m_pHelper->getCurrentFormula(); // it will be added before a ";" + FormEditData* pData = m_pHelper->getFormEditData(); + if (!pData) + return; + + sal_uInt16 nArgNo = m_xParaWin->GetActiveLine(); + sal_uInt16 nEdFocus = nArgNo; + + SaveArg(nArgNo); + UpdateSelection(); + + sal_Int32 nFormulaStrPos = pData->GetFStart(); + + OUString aFormula = m_pHelper->getCurrentFormula(); + sal_Int32 n1 = m_aFormulaHelper.GetArgStart( aFormula, nFormulaStrPos, nEdFocus + pData->GetOffset() ); + + pData->SaveValues(); + pData->SetMode( FormulaDlgMode::Formula ); + pData->SetFStart( n1 ); + pData->SetUndoStr( aUndoStr ); + ClearAllParas(); + + FillDialog(false); + m_xFuncPage->SetFocus(); //There Parawin is not visible anymore +} + +IMPL_LINK( FormulaDlg_Impl, ModifyHdl, ParaWin&, rPtr, void ) +{ + if (&rPtr == m_xParaWin.get()) + { + SaveArg(m_xParaWin->GetActiveLine()); + UpdateValues(); + + UpdateSelection(); + CalcStruct(m_xMEdit->get_text()); + } +} + +IMPL_LINK_NOARG( FormulaDlg_Impl, FormulaHdl, weld::TextView&, void) +{ + + FormEditData* pData = m_pHelper->getFormEditData(); + if (!pData) + return; + + m_bEditFlag = true; + OUString aInputFormula = m_pHelper->getCurrentFormula(); + OUString aString = m_xMEdit->get_text(); + + int nStartPos, nEndPos; + m_xMEdit->get_selection_bounds(nStartPos, nEndPos); + if (nStartPos > nEndPos) + std::swap(nStartPos, nEndPos); + + if (aString.isEmpty()) // in case everything was cleared + { + aString += "="; + m_xMEdit->set_text(aString); + nStartPos = 1; + nEndPos = 1; + m_xMEdit->select_region(nStartPos, nEndPos); + } + else if (aString[0]!='=') // in case it's replaced + { + aString = "=" + aString; + m_xMEdit->set_text(aString); + nStartPos += 1; + nEndPos += 1; + m_xMEdit->select_region(nStartPos, nEndPos); + } + + m_pHelper->setSelection( 0, aInputFormula.getLength()); + m_pHelper->setCurrentFormula(aString); + m_pHelper->setSelection(nStartPos, nEndPos); + + sal_Int32 nPos = nStartPos - 1; + + OUString aStrResult; + + if ( CalcValue( m_pHelper->getCurrentFormula(), aStrResult ) ) + m_xWndFormResult->set_text( aStrResult ); + else + { + aStrResult.clear(); + m_xWndFormResult->set_text( aStrResult ); + } + CalcStruct(aString); + + nPos = GetFunctionPos(nPos); + + if (nPos < nStartPos - 1) + { + sal_Int32 nPos1 = aString.indexOf( '(', nPos); + EditNextFunc( false, nPos1); + } + else + { + ClearAllParas(); + } + + m_pHelper->setSelection(nStartPos, nEndPos); + m_bEditFlag = false; +} + +void FormulaDlg_Impl::FormulaCursor() +{ + FormEditData* pData = m_pHelper->getFormEditData(); + if (!pData) + return; + + m_bEditFlag = true; + + OUString aString = m_xMEdit->get_text(); + + int nStartPos, nEndPos; + m_xMEdit->get_selection_bounds(nStartPos, nEndPos); + if (nStartPos > nEndPos) + std::swap(nStartPos, nEndPos); + + m_pHelper->setSelection(nStartPos, nEndPos); + + if (nStartPos == 0) + { + nStartPos = 1; + m_xMEdit->select_region(nStartPos, nEndPos); + } + if (nStartPos != aString.getLength()) + { + sal_Int32 nPos = nStartPos; + + sal_Int32 nFStart = GetFunctionPos(nPos - 1); + + if (nFStart < nPos) + { + sal_Int32 nPos1 = m_aFormulaHelper.GetFunctionEnd( aString, nFStart); + + if (nPos1 > nPos) + { + EditThisFunc(nFStart); + } + else + { + sal_Int32 n = nPos; + short nCount = 1; + while(n > 0) + { + if (aString[n]==')') + nCount++; + else if (aString[n]=='(') + nCount--; + if (nCount == 0) + break; + n--; + } + if (nCount == 0) + { + nFStart = m_aFormulaHelper.GetFunctionStart( aString, n, true); + EditThisFunc(nFStart); + } + else + { + ClearAllParas(); + } + } + } + else + { + ClearAllParas(); + } + } + m_pHelper->setSelection(nStartPos, nEndPos); + + m_bEditFlag = false; +} + +void FormulaDlg_Impl::UpdateOldSel() +{ + m_xMEdit->get_selection_bounds(m_nSelectionStart, m_nSelectionEnd); + if (m_nSelectionStart > m_nSelectionEnd) + std::swap(m_nSelectionStart, m_nSelectionEnd); +} + +IMPL_LINK_NOARG( FormulaDlg_Impl, FormulaCursorHdl, weld::TextView&, void) +{ + int nStartPos, nEndPos; + m_xMEdit->get_selection_bounds(nStartPos, nEndPos); + if (nStartPos > nEndPos) + std::swap(nStartPos, nEndPos); + + if (nStartPos != m_nSelectionStart || nEndPos != m_nSelectionEnd) + { + m_nSelectionStart = nStartPos; + m_nSelectionEnd = nEndPos; + FormulaCursor(); + } +} + +void FormulaDlg_Impl::UpdateSelection() +{ + m_pHelper->setSelection( m_aFuncSel.Min(), m_aFuncSel.Max()); + if (m_pFuncDesc) + { + m_pHelper->setCurrentFormula( m_pFuncDesc->getFormula( m_aArguments ) ); + m_nArgs = m_pFuncDesc->getSuppressedArgumentCount(); + } + else + { + m_pHelper->setCurrentFormula(""); + m_nArgs = 0; + } + + m_xMEdit->set_text(m_pHelper->getCurrentFormula()); + sal_Int32 PrivStart, PrivEnd; + m_pHelper->getSelection( PrivStart, PrivEnd); + m_aFuncSel.Min() = PrivStart; + m_aFuncSel.Max() = PrivEnd; + + OUString aFormula = m_xMEdit->get_text(); + sal_Int32 nArgPos = m_aFormulaHelper.GetArgStart( aFormula, PrivStart, 0); + + sal_uInt16 nPos = m_xParaWin->GetActiveLine(); + if (nPos >= m_aArguments.size()) + { + SAL_WARN("formula.ui","FormulaDlg_Impl::UpdateSelection - shot in foot: nPos " << + nPos << " >= m_aArguments.size() " << m_aArguments.size() << + " for aFormula '" << aFormula << "'"); + nPos = m_aArguments.size(); + if (nPos) + --nPos; + } + + for (sal_uInt16 i = 0; i < nPos; i++) + { + nArgPos += (m_aArguments[i].getLength() + 1); + } + sal_Int32 nLength = (nPos < m_aArguments.size()) ? m_aArguments[nPos].getLength() : 0; + + m_pHelper->setSelection(nArgPos, nArgPos + nLength); + m_xMEdit->select_region(nArgPos, nArgPos + nLength); + UpdateOldSel(); +} + +::std::pair<RefButton*, RefEdit*> FormulaDlg_Impl::RefInputStartBefore(RefEdit* pEdit, RefButton* pButton) +{ + m_pTheRefEdit = pEdit; + m_pTheRefButton = pButton; + + Selection aOrigSelection; + if (m_pTheRefEdit) + { + // grab selection before showing next widget in case the selection is blown away + // by it appearing + aOrigSelection = m_pTheRefEdit->GetSelection(); + } + + // because its initially hidden, give it its optimal size so clicking the + // refbutton has an initial size to work when retro-fitting this to .ui + m_xEdRef->GetWidget()->set_size_request(m_xEdRef->GetWidget()->get_preferred_size().Width(), -1); + m_xEdRef->GetWidget()->show(); + + if ( m_pTheRefEdit ) + { + m_xEdRef->SetRefString(m_pTheRefEdit->GetText()); + m_xEdRef->SetSelection(aOrigSelection); + m_xEdRef->GetWidget()->set_help_id(m_pTheRefEdit->GetWidget()->get_help_id()); + } + + m_xRefBtn->GetWidget()->set_visible(pButton != nullptr); + + ::std::pair<RefButton*, RefEdit*> aPair; + aPair.first = pButton ? m_xRefBtn.get() : nullptr; + aPair.second = m_xEdRef.get(); + return aPair; +} + +void FormulaDlg_Impl::RefInputStartAfter() +{ + m_xRefBtn->SetEndImage(); + + if (!m_pTheRefEdit) + return; + + OUString aStr = m_aTitle2 + " " + m_xFtEditName->get_label() + "( "; + + if ( m_xParaWin->GetActiveLine() > 0 ) + aStr += "...; "; + aStr += m_xParaWin->GetActiveArgName(); + if ( m_xParaWin->GetActiveLine() + 1 < m_nArgs ) + aStr += "; ..."; + aStr += " )"; + + m_rDialog.set_title(m_rDialog.strip_mnemonic(aStr)); +} + +void FormulaDlg_Impl::RefInputDoneAfter( bool bForced ) +{ + m_xRefBtn->SetStartImage(); + if (!bForced && m_xRefBtn->GetWidget()->get_visible()) + return; + + m_xEdRef->GetWidget()->hide(); + m_xRefBtn->GetWidget()->hide(); + if ( m_pTheRefEdit ) + { + m_pTheRefEdit->SetRefString( m_xEdRef->GetText() ); + m_pTheRefEdit->GrabFocus(); + + if ( m_pTheRefButton ) + m_pTheRefButton->SetStartImage(); + + sal_uInt16 nPrivActiv = m_xParaWin->GetActiveLine(); + m_xParaWin->SetArgument( nPrivActiv, m_xEdRef->GetText() ); + ModifyHdl( *m_xParaWin ); + m_pTheRefEdit = nullptr; + } + m_rDialog.set_title(m_aTitle1); +} + +RefEdit* FormulaDlg_Impl::GetCurrRefEdit() +{ + return m_xEdRef->GetWidget()->get_visible() ? m_xEdRef.get() : m_xParaWin->GetActiveEdit(); +} + +void FormulaDlg_Impl::Update() +{ + FormEditData* pData = m_pHelper->getFormEditData(); + const OUString sExpression = m_xMEdit->get_text(); + m_aOldFormula.clear(); + UpdateTokenArray(sExpression); + FormulaCursor(); + CalcStruct(sExpression); + if (pData->GetMode() == FormulaDlgMode::Formula) + m_xTabCtrl->set_current_page("function"); + else + m_xTabCtrl->set_current_page("struct"); + m_xBtnMatrix->set_active(pData->GetMatrixFlag()); +} + +void FormulaDlg_Impl::Update(const OUString& _sExp) +{ + CalcStruct(_sExp); + FillDialog(); + FuncSelHdl(*m_xFuncPage); +} + +void FormulaDlg_Impl::SetMeText(const OUString& _sText) +{ + FormEditData* pData = m_pHelper->getFormEditData(); + m_xMEdit->set_text(_sText); + auto aSelection = pData->GetSelection(); + m_xMEdit->select_region(aSelection.Min(), aSelection.Max()); + UpdateOldSel(); +} + +FormulaDlgMode FormulaDlg_Impl::SetMeText( const OUString& _sText, sal_Int32 PrivStart, sal_Int32 PrivEnd, bool bMatrix, bool _bSelect, bool _bUpdate) +{ + FormulaDlgMode eMode = FormulaDlgMode::Formula; + if (!m_bEditFlag) + m_xMEdit->set_text(_sText); + + if ( _bSelect || !m_bEditFlag ) + m_xMEdit->select_region(PrivStart, PrivEnd); + if ( _bUpdate ) + { + UpdateOldSel(); + int nStartPos, nEndPos; + m_xMEdit->get_selection_bounds(nStartPos, nEndPos); + if (nStartPos > nEndPos) + std::swap(nStartPos, nEndPos); + m_pHelper->showReference(m_xMEdit->get_text().copy(nStartPos, nEndPos - nStartPos)); + eMode = FormulaDlgMode::Edit; + + m_xBtnMatrix->set_active( bMatrix ); + } // if ( _bUpdate ) + return eMode; +} + +bool FormulaDlg_Impl::CheckMatrix(OUString& aFormula) +{ + m_xMEdit->grab_focus(); + sal_Int32 nLen = aFormula.getLength(); + bool bMatrix = nLen > 3 // Matrix-Formula + && aFormula[0] == '{' + && aFormula[1] == '=' + && aFormula[nLen-1] == '}'; + if ( bMatrix ) + { + aFormula = aFormula.copy( 1, aFormula.getLength()-2 ); + m_xBtnMatrix->set_active( bMatrix ); + m_xBtnMatrix->set_sensitive(false); + } // if ( bMatrix ) + + m_xTabCtrl->set_current_page("struct"); + return bMatrix; +} + +IMPL_LINK_NOARG( FormulaDlg_Impl, StructSelHdl, StructPage&, void) +{ + m_bStructUpdate = false; + if (m_xStructPage->IsVisible()) + m_xBtnForward->set_sensitive(false); //@New + m_bStructUpdate = true; +} + +IMPL_LINK_NOARG( FormulaDlg_Impl, MatrixHdl, weld::Toggleable&, void) +{ + m_bUserMatrixFlag = true; + UpdateValues(true); +} + +IMPL_LINK_NOARG( FormulaDlg_Impl, FuncSelHdl, FuncPage&, void) +{ + if ( (m_xFuncPage->GetFunctionEntryCount() > 0) + && (m_xFuncPage->GetFunction() != -1) ) + { + const IFunctionDescription* pDesc = m_xFuncPage->GetFuncDesc( m_xFuncPage->GetFunction() ); + + if (pDesc != m_pFuncDesc) + m_xBtnForward->set_sensitive(true); //new + + if (pDesc) + { + pDesc->initArgumentInfo(); // full argument info is needed + + OUString aSig = pDesc->getSignature(); + m_xFtHeadLine->set_label( pDesc->getFunctionName() ); + m_xFtFuncName->set_label( aSig ); + m_xFtFuncDesc->set_label( pDesc->getDescription() ); + } + } + else + { + m_xFtHeadLine->set_label( OUString() ); + m_xFtFuncName->set_label( OUString() ); + m_xFtFuncDesc->set_label( OUString() ); + } +} + +void FormulaDlg_Impl::UpdateParaWin( const Selection& _rSelection, const OUString& _sRefStr) +{ + Selection theSel = _rSelection; + m_xEdRef->GetWidget()->replace_selection(_sRefStr); + theSel.Max() = theSel.Min() + _sRefStr.getLength(); + m_xEdRef->SetSelection( theSel ); + + + // Manual Update of the results' fields: + + sal_uInt16 nPrivActiv = m_xParaWin->GetActiveLine(); + m_xParaWin->SetArgument( nPrivActiv, m_xEdRef->GetText()); + m_xParaWin->UpdateParas(); + + RefEdit* pEd = GetCurrRefEdit(); + if (pEd) + pEd->SetSelection( theSel ); +} + +bool FormulaDlg_Impl::UpdateParaWin(Selection& _rSelection) +{ + OUString aStrEd; + RefEdit* pEd = GetCurrRefEdit(); + if (pEd && !m_pTheRefEdit) + { + _rSelection = pEd->GetSelection(); + _rSelection.Justify(); + aStrEd = pEd->GetText(); + m_xEdRef->SetRefString(aStrEd); + m_xEdRef->SetSelection( _rSelection ); + } + else + { + _rSelection = m_xEdRef->GetSelection(); + _rSelection.Justify(); + aStrEd = m_xEdRef->GetText(); + } + return m_pTheRefEdit == nullptr; +} + +void FormulaDlg_Impl::SetEdSelection() +{ + RefEdit* pEd = GetCurrRefEdit()/*aScParaWin.GetActiveEdit()*/; + if (pEd) + { + Selection theSel = m_xEdRef->GetSelection(); + // Edit may have the focus -> call ModifyHdl in addition + // to what's happening in GetFocus + pEd->GetModifyHdl().Call(*pEd); + pEd->GrabFocus(); + pEd->SetSelection(theSel); + } // if ( pEd ) +} + +FormulaModalDialog::FormulaModalDialog(weld::Window* pParent, + IFunctionManager const * _pFunctionMgr, + IControlReferenceHandler* _pDlg) + : GenericDialogController(pParent, "formula/ui/formuladialog.ui", "FormulaDialog") + , m_pImpl(new FormulaDlg_Impl(*m_xDialog, *m_xBuilder, false/*_bSupportFunctionResult*/, + false/*_bSupportResult*/, false/*_bSupportMatrix*/, + this, _pFunctionMgr, _pDlg)) +{ + m_xDialog->set_title(m_pImpl->m_aTitle1); +} + +FormulaModalDialog::~FormulaModalDialog() { } + +void FormulaModalDialog::Update(const OUString& _sExp) +{ + m_pImpl->Update(_sExp); +} + +void FormulaModalDialog::SetMeText(const OUString& _sText) +{ + m_pImpl->SetMeText(_sText); +} + +void FormulaModalDialog::CheckMatrix(OUString& aFormula) +{ + m_pImpl->CheckMatrix(aFormula); +} + +void FormulaModalDialog::Update() +{ + m_pImpl->Update(); +} + +::std::pair<RefButton*, RefEdit*> FormulaModalDialog::RefInputStartBefore( RefEdit* pEdit, RefButton* pButton ) +{ + return m_pImpl->RefInputStartBefore( pEdit, pButton ); +} + +void FormulaModalDialog::RefInputStartAfter() +{ + m_pImpl->RefInputStartAfter(); +} + +void FormulaModalDialog::RefInputDoneAfter() +{ + m_pImpl->RefInputDoneAfter( true/*bForced*/ ); +} + +void FormulaModalDialog::StoreFormEditData(FormEditData* pData) +{ + m_pImpl->StoreFormEditData(pData); +} + +// Initialisation / General functions for Dialog +FormulaDlg::FormulaDlg(SfxBindings* pB, SfxChildWindow* pCW, + weld::Window* pParent, + IFunctionManager const * _pFunctionMgr, IControlReferenceHandler* _pDlg) + : SfxModelessDialogController( pB, pCW, pParent, "formula/ui/formuladialog.ui", "FormulaDialog") + , m_pImpl(new FormulaDlg_Impl(*m_xDialog, *m_xBuilder, true/*_bSupportFunctionResult*/ + , true/*_bSupportResult*/ + , true/*_bSupportMatrix*/ + , this, _pFunctionMgr, _pDlg)) +{ + m_xDialog->set_title(m_pImpl->m_aTitle1); +} + +FormulaDlg::~FormulaDlg() +{ +} + +void FormulaDlg::Update(const OUString& _sExp) +{ + m_pImpl->Update(_sExp); +} + +void FormulaDlg::SetMeText(const OUString& _sText) +{ + m_pImpl->SetMeText(_sText); +} + +FormulaDlgMode FormulaDlg::SetMeText( const OUString& _sText, sal_Int32 PrivStart, sal_Int32 PrivEnd, bool bMatrix, bool _bSelect, bool _bUpdate) +{ + return m_pImpl->SetMeText( _sText, PrivStart, PrivEnd, bMatrix, _bSelect, _bUpdate); +} + +bool FormulaDlg::CheckMatrix(OUString& aFormula) +{ + return m_pImpl->CheckMatrix(aFormula); +} + +OUString FormulaDlg::GetMeText() const +{ + return m_pImpl->m_xMEdit->get_text(); +} + +void FormulaDlg::Update() +{ + m_pImpl->Update(); +} + +void FormulaDlg::DoEnter() +{ + m_pImpl->DoEnter(false); +} + +::std::pair<RefButton*, RefEdit*> FormulaDlg::RefInputStartBefore( RefEdit* pEdit, RefButton* pButton ) +{ + return m_pImpl->RefInputStartBefore( pEdit, pButton ); +} + +void FormulaDlg::RefInputStartAfter() +{ + m_pImpl->RefInputStartAfter(); +} + +void FormulaDlg::RefInputDoneAfter( bool bForced ) +{ + m_pImpl->RefInputDoneAfter( bForced ); +} + +void FormulaDlg::disableOk() +{ + m_pImpl->m_xBtnEnd->set_sensitive(false); +} + +void FormulaDlg::StoreFormEditData(FormEditData* pData) +{ + m_pImpl->StoreFormEditData(pData); +} + +const IFunctionDescription* FormulaDlg::getCurrentFunctionDescription() const +{ + SAL_WARN_IF( (m_pImpl->m_pFuncDesc && m_pImpl->m_pFuncDesc->getSuppressedArgumentCount() != m_pImpl->m_nArgs), + "formula.ui", "FormulaDlg::getCurrentFunctionDescription: getSuppressedArgumentCount " << + m_pImpl->m_pFuncDesc->getSuppressedArgumentCount() << " != m_nArgs " << m_pImpl->m_nArgs << " for " << + m_pImpl->m_pFuncDesc->getFunctionName()); + return m_pImpl->m_pFuncDesc; +} + +void FormulaDlg::UpdateParaWin( const Selection& _rSelection, const OUString& _sRefStr) +{ + m_pImpl->UpdateParaWin( _rSelection, _sRefStr); +} + +bool FormulaDlg::UpdateParaWin(Selection& _rSelection) +{ + return m_pImpl->UpdateParaWin(_rSelection); +} + +RefEdit* FormulaDlg::GetActiveEdit() +{ + return m_pImpl->m_xParaWin->GetActiveEdit(); +} + +const FormulaHelper& FormulaDlg::GetFormulaHelper() const +{ + return m_pImpl->GetFormulaHelper(); +} + +void FormulaDlg::SetEdSelection() +{ + m_pImpl->SetEdSelection(); +} + +void FormEditData::SaveValues() +{ + Reset(); +} + +void FormEditData::Reset() +{ + nMode = FormulaDlgMode::Formula; + nFStart = 0; + nOffset = 0; + bMatrix = false; + aSelection.Min() = 0; + aSelection.Max() = 0; + aUndoStr.clear(); +} + +FormEditData& FormEditData::operator=( const FormEditData& r ) +{ + nMode = r.nMode; + nFStart = r.nFStart; + nOffset = r.nOffset; + aUndoStr = r.aUndoStr; + bMatrix = r.bMatrix ; + aSelection = r.aSelection; + return *this; +} + +FormEditData::FormEditData() +{ + Reset(); +} + +FormEditData::~FormEditData() +{ +} + +FormEditData::FormEditData( const FormEditData& r ) +{ + *this = r; +} + + +} // formula + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/formula/source/ui/dlg/funcpage.cxx b/formula/source/ui/dlg/funcpage.cxx new file mode 100644 index 000000000..553517ce7 --- /dev/null +++ b/formula/source/ui/dlg/funcpage.cxx @@ -0,0 +1,257 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include <vcl/event.hxx> +#include <vcl/svapp.hxx> +#include <formula/IFunctionDescription.hxx> + +#include "funcpage.hxx" +#include <unotools/syslocale.hxx> +#include <unotools/charclass.hxx> + +namespace formula +{ +IMPL_LINK(FuncPage, KeyInputHdl, const KeyEvent&, rKEvt, bool) +{ + if (rKEvt.GetCharCode() == ' ') + { + aDoubleClickLink.Call(*this); + return true; + } + return false; +} + +FuncPage::FuncPage(weld::Container* pParent, const IFunctionManager* _pFunctionManager) + : m_xBuilder(Application::CreateBuilder(pParent, "formula/ui/functionpage.ui")) + , m_xContainer(m_xBuilder->weld_container("FunctionPage")) + , m_xLbCategory(m_xBuilder->weld_combo_box("category")) + , m_xLbFunction(m_xBuilder->weld_tree_view("function")) + , m_xLbFunctionSearchString(m_xBuilder->weld_entry("search")) + , m_pFunctionManager(_pFunctionManager) +{ + m_xLbFunction->make_sorted(); + m_aHelpId = m_xLbFunction->get_help_id(); + + m_pFunctionManager->fillLastRecentlyUsedFunctions(aLRUList); + + const sal_uInt32 nCategoryCount = m_pFunctionManager->getCount(); + for (sal_uInt32 j = 0; j < nCategoryCount; ++j) + { + const IFunctionCategory* pCategory = m_pFunctionManager->getCategory(j); + OUString sId(weld::toId(pCategory)); + m_xLbCategory->append(sId, pCategory->getName()); + } + + m_xLbCategory->set_active(1); + OUString searchStr = m_xLbFunctionSearchString->get_text(); + UpdateFunctionList(searchStr); + // lock to its initial size + m_xLbFunction->set_size_request(m_xLbFunction->get_preferred_size().Width(), + m_xLbFunction->get_height_rows(15)); + m_xLbCategory->connect_changed(LINK(this, FuncPage, SelComboBoxHdl)); + m_xLbFunction->connect_changed(LINK(this, FuncPage, SelTreeViewHdl)); + m_xLbFunction->connect_row_activated(LINK(this, FuncPage, DblClkHdl)); + m_xLbFunction->connect_key_press(LINK(this, FuncPage, KeyInputHdl)); + m_xLbFunctionSearchString->connect_changed(LINK(this, FuncPage, ModifyHdl)); + + m_xLbFunctionSearchString->grab_focus(); +} + +FuncPage::~FuncPage() {} + +void FuncPage::impl_addFunctions(const IFunctionCategory* _pCategory) +{ + const sal_uInt32 nCount = _pCategory->getCount(); + for (sal_uInt32 i = 0; i < nCount; ++i) + { + TFunctionDesc pDesc(_pCategory->getFunction(i)); + if (!pDesc->isHidden()) + { + OUString sId(weld::toId(pDesc)); + m_xLbFunction->append(sId, pDesc->getFunctionName()); + } + } +} + +//aStr is non-empty when user types in the search box to search some function +void FuncPage::UpdateFunctionList(const OUString& aStr) +{ + m_xLbFunction->clear(); + m_xLbFunction->freeze(); + + const sal_Int32 nSelPos = m_xLbCategory->get_active(); + + if (aStr.isEmpty() || nSelPos == 0) + { + const IFunctionCategory* pCategory + = weld::fromId<const IFunctionCategory*>(m_xLbCategory->get_id(nSelPos)); + + if (nSelPos > 0) + { + if (pCategory == nullptr) + { + const sal_uInt32 nCount = m_pFunctionManager->getCount(); + for (sal_uInt32 i = 0; i < nCount; ++i) + { + impl_addFunctions(m_pFunctionManager->getCategory(i)); + } + } + else + { + impl_addFunctions(pCategory); + } + } + else // LRU-List + { + for (auto const& elem : aLRUList) + { + if (elem) // may be null if a function is no longer available + { + OUString sId(weld::toId(elem)); + m_xLbFunction->append(sId, elem->getFunctionName()); + } + } + } + } + else + { + SvtSysLocale aSysLocale; + const CharClass& rCharClass = aSysLocale.GetCharClass(); + const OUString aSearchStr(rCharClass.uppercase(aStr)); + + const sal_uInt32 nCategoryCount = m_pFunctionManager->getCount(); + // Category listbox holds additional entries for Last Used and All, so + // the offset should be two but hard coded numbers are ugly... + const sal_Int32 nCategoryOffset = m_xLbCategory->get_count() - nCategoryCount; + // If a real category (not Last Used or All) is selected, list only + // functions of that category. Else list all, LRU is handled above. + sal_Int32 nCatBeg = (nSelPos == -1 ? -1 : nSelPos - nCategoryOffset); + sal_uInt32 nCatEnd; + if (nCatBeg < 0) + { + nCatBeg = 0; + nCatEnd = nCategoryCount; + } + else + { + nCatEnd = nCatBeg + 1; + } + for (sal_uInt32 i = nCatBeg; i < nCatEnd; ++i) + { + const IFunctionCategory* pCategory = m_pFunctionManager->getCategory(i); + const sal_uInt32 nFunctionCount = pCategory->getCount(); + for (sal_uInt32 j = 0; j < nFunctionCount; ++j) + { + TFunctionDesc pDesc(pCategory->getFunction(j)); + if (rCharClass.uppercase(pDesc->getFunctionName()).indexOf(aSearchStr) >= 0) + { + if (!pDesc->isHidden()) + { + OUString sId(weld::toId(pDesc)); + m_xLbFunction->append(sId, pDesc->getFunctionName()); + } + } + } + } + } + + m_xLbFunction->thaw(); + // Ensure no function is selected so the Next button doesn't overwrite a + // function that is not in the list with an arbitrary selected one. + m_xLbFunction->unselect_all(); + + if (IsVisible()) + SelTreeViewHdl(*m_xLbFunction); +} + +IMPL_LINK_NOARG(FuncPage, SelComboBoxHdl, weld::ComboBox&, void) +{ + OUString searchStr = m_xLbFunctionSearchString->get_text(); + m_xLbFunction->set_help_id(m_aHelpId); + UpdateFunctionList(searchStr); +} + +IMPL_LINK_NOARG(FuncPage, SelTreeViewHdl, weld::TreeView&, void) +{ + const IFunctionDescription* pDesc = GetFuncDesc(GetFunction()); + if (pDesc) + { + const OString sHelpId = pDesc->getHelpId(); + if (!sHelpId.isEmpty()) + m_xLbFunction->set_help_id(sHelpId); + } + aSelectionLink.Call(*this); +} + +IMPL_LINK_NOARG(FuncPage, DblClkHdl, weld::TreeView&, bool) +{ + aDoubleClickLink.Call(*this); + return true; +} + +IMPL_LINK_NOARG(FuncPage, ModifyHdl, weld::Entry&, void) +{ + // While typing select All category. + m_xLbCategory->set_active(1); + OUString searchStr = m_xLbFunctionSearchString->get_text(); + UpdateFunctionList(searchStr); +} + +void FuncPage::SetCategory(sal_Int32 nCat) +{ + m_xLbCategory->set_active(nCat); + UpdateFunctionList(OUString()); +} + +sal_Int32 FuncPage::GetFuncPos(const IFunctionDescription* _pDesc) +{ + return m_xLbFunction->find_id(weld::toId(_pDesc)); +} + +void FuncPage::SetFunction(sal_Int32 nFunc) +{ + if (nFunc == -1) + m_xLbFunction->unselect_all(); + else + m_xLbFunction->select(nFunc); +} + +void FuncPage::SetFocus() { m_xLbFunction->grab_focus(); } + +sal_Int32 FuncPage::GetCategory() const { return m_xLbCategory->get_active(); } + +sal_Int32 FuncPage::GetCategoryEntryCount() const { return m_xLbCategory->get_count(); } + +sal_Int32 FuncPage::GetFunction() const { return m_xLbFunction->get_selected_index(); } + +sal_Int32 FuncPage::GetFunctionEntryCount() const { return m_xLbFunction->n_children(); } + +OUString FuncPage::GetSelFunctionName() const { return m_xLbFunction->get_selected_text(); } + +const IFunctionDescription* FuncPage::GetFuncDesc(sal_Int32 nPos) const +{ + if (nPos == -1) + return nullptr; + // not pretty, but hopefully rare + return weld::fromId<const IFunctionDescription*>(m_xLbFunction->get_id(nPos)); +} + +} // formula + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/formula/source/ui/dlg/funcpage.hxx b/formula/source/ui/dlg/funcpage.hxx new file mode 100644 index 000000000..6254dfc8a --- /dev/null +++ b/formula/source/ui/dlg/funcpage.hxx @@ -0,0 +1,87 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#pragma once + +#include <vcl/weld.hxx> +#include <vector> + +namespace formula +{ + +class IFunctionDescription; +class IFunctionManager; +class IFunctionCategory; + +typedef const IFunctionDescription* TFunctionDesc; + +class FuncPage final +{ +private: + std::unique_ptr<weld::Builder> m_xBuilder; + std::unique_ptr<weld::Container> m_xContainer; + + std::unique_ptr<weld::ComboBox> m_xLbCategory; + std::unique_ptr<weld::TreeView> m_xLbFunction; + std::unique_ptr<weld::Entry> m_xLbFunctionSearchString; + + Link<FuncPage&,void> aDoubleClickLink; + Link<FuncPage&,void> aSelectionLink; + const IFunctionManager* m_pFunctionManager; + + ::std::vector< TFunctionDesc > aLRUList; + OString m_aHelpId; + + void impl_addFunctions(const IFunctionCategory* _pCategory); + + DECL_LINK(SelComboBoxHdl, weld::ComboBox&, void); + DECL_LINK(SelTreeViewHdl, weld::TreeView&, void); + DECL_LINK(DblClkHdl, weld::TreeView&, bool); + DECL_LINK(KeyInputHdl, const KeyEvent&, bool); + DECL_LINK(ModifyHdl, weld::Entry&, void); + + void UpdateFunctionList(const OUString&); + +public: + + FuncPage(weld::Container* pContainer, const IFunctionManager* _pFunctionManager); + ~FuncPage(); + + void SetCategory(sal_Int32 nCat); + void SetFunction(sal_Int32 nFunc); + void SetFocus(); + sal_Int32 GetCategory() const; + sal_Int32 GetCategoryEntryCount() const; + sal_Int32 GetFunction() const; + sal_Int32 GetFunctionEntryCount() const; + + sal_Int32 GetFuncPos(const IFunctionDescription* _pDesc); + const IFunctionDescription* GetFuncDesc( sal_Int32 nPos ) const; + OUString GetSelFunctionName() const; + + void SetDoubleClickHdl( const Link<FuncPage&,void>& rLink ) { aDoubleClickLink = rLink; } + + void SetSelectHdl( const Link<FuncPage&,void>& rLink ) { aSelectionLink = rLink; } + + bool IsVisible() const { return m_xContainer->get_visible(); } +}; + +} // formula + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/formula/source/ui/dlg/funcutl.cxx b/formula/source/ui/dlg/funcutl.cxx new file mode 100644 index 000000000..58c2492c5 --- /dev/null +++ b/formula/source/ui/dlg/funcutl.cxx @@ -0,0 +1,486 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include <vcl/event.hxx> + +#include <formula/funcutl.hxx> +#include <formula/IControlReferenceHandler.hxx> +#include <vcl/svapp.hxx> +#include "ControlHelper.hxx" +#include "parawin.hxx" +#include <strings.hrc> +#include <bitmaps.hlst> +#include <core_resource.hxx> + +namespace formula +{ + +ArgEdit::ArgEdit(std::unique_ptr<weld::Entry> xControl) + : RefEdit(std::move(xControl)) + , pEdPrev(nullptr) + , pEdNext(nullptr) + , pSlider(nullptr) + , pParaWin(nullptr) + , nArgs(0) +{ +} + +void ArgEdit::Init(ArgEdit* pPrevEdit, ArgEdit* pNextEdit, + weld::ScrolledWindow& rArgSlider, + ParaWin& rParaWin, sal_uInt16 nArgCount) +{ + pEdPrev = pPrevEdit; + pEdNext = pNextEdit; + pSlider = &rArgSlider; + pParaWin = &rParaWin; + nArgs = nArgCount; +} + +// Cursor control for Edit Fields in Argument Dialog +bool ArgEdit::KeyInput(const KeyEvent& rKEvt) +{ + vcl::KeyCode aCode = rKEvt.GetKeyCode(); + bool bUp = (aCode.GetCode() == KEY_UP); + bool bDown = (aCode.GetCode() == KEY_DOWN); + + if ( pSlider + && ( !aCode.IsShift() && !aCode.IsMod1() && !aCode.IsMod2() ) + && ( bUp || bDown ) ) + { + if ( nArgs > 1 ) + { + ArgEdit* pEd = nullptr; + int nThumb = pSlider->vadjustment_get_value(); + bool bDoScroll = false; + bool bChangeFocus = false; + + if ( bDown ) + { + if ( nArgs > 4 ) + { + if ( !pEdNext ) + { + nThumb++; + bDoScroll = ( nThumb+3 < static_cast<tools::Long>(nArgs) ); + } + else + { + pEd = pEdNext; + bChangeFocus = true; + } + } + else if ( pEdNext ) + { + pEd = pEdNext; + bChangeFocus = true; + } + } + else // if ( bUp ) + { + if ( nArgs > 4 ) + { + if ( !pEdPrev ) + { + nThumb--; + bDoScroll = ( nThumb >= 0 ); + } + else + { + pEd = pEdPrev; + bChangeFocus = true; + } + } + else if ( pEdPrev ) + { + pEd = pEdPrev; + bChangeFocus = true; + } + } + + if ( bDoScroll ) + { + pSlider->vadjustment_set_value( nThumb ); + pParaWin->SliderMoved(); + } + else if ( bChangeFocus ) + { + pEd->GrabFocus(); + } + } + return true; + } + return RefEdit::KeyInput(rKEvt); +} + +ArgInput::ArgInput() +{ + pFtArg=nullptr; + pBtnFx=nullptr; + pEdArg=nullptr; + pRefBtn=nullptr; +} + +void ArgInput::InitArgInput(weld::Label* pftArg, weld::Button* pbtnFx, + ArgEdit* pedArg, RefButton* prefBtn) +{ + pFtArg =pftArg; + pBtnFx =pbtnFx; + pEdArg =pedArg; + pRefBtn=prefBtn; + + if(pBtnFx!=nullptr) + { + pBtnFx->connect_clicked( LINK( this, ArgInput, FxBtnClickHdl ) ); + pBtnFx->connect_focus_in( LINK( this, ArgInput, FxBtnFocusHdl ) ); + } + if(pEdArg!=nullptr) + { + pEdArg->SetGetFocusHdl ( LINK( this, ArgInput, EdFocusHdl ) ); + pEdArg->SetModifyHdl ( LINK( this, ArgInput, EdModifyHdl ) ); + } +} + +// Sets the Name for the Argument +void ArgInput::SetArgName(const OUString &aArg) +{ + if (pFtArg) + pFtArg->set_label(aArg ); +} + +// Returns the Name for the Argument +OUString ArgInput::GetArgName() const +{ + OUString aPrivArgName; + if (pFtArg) + aPrivArgName = pFtArg->get_label(); + return aPrivArgName; +} + +//Sets the Name for the Argument +void ArgInput::SetArgNameFont(const vcl::Font &aFont) +{ + if (pFtArg) + pFtArg->set_font(aFont); +} + +//Sets up the Selection for the EditBox. +void ArgInput::SelectAll() +{ + if (pEdArg) + pEdArg->SelectAll(); +} + +//Sets the Value for the Argument +void ArgInput::SetArgVal(const OUString &rVal) +{ + if (pEdArg) + pEdArg->SetRefString(rVal); +} + +//Returns the Value for the Argument +OUString ArgInput::GetArgVal() const +{ + OUString aResult; + if (pEdArg) + aResult=pEdArg->GetText(); + return aResult; +} + +//Hides the Controls +void ArgInput::Hide() +{ + if (pFtArg && pBtnFx && pEdArg && pRefBtn) + { + pFtArg->hide(); + pBtnFx->hide(); + pEdArg->GetWidget()->hide(); + pRefBtn->GetWidget()->hide(); + } +} + +//Casts the Controls again. +void ArgInput::Show() +{ + if (pFtArg && pBtnFx && pEdArg && pRefBtn) + { + pFtArg->show(); + pBtnFx->show(); + pEdArg->GetWidget()->show(); + pRefBtn->GetWidget()->show(); + } +} + +void ArgInput::UpdateAccessibleNames() +{ + OUString aArgName = ":" + pFtArg->get_label(); + + OUString aName = pBtnFx->get_tooltip_text() + aArgName; + pBtnFx->set_accessible_name(aName); + + aName = pRefBtn->GetWidget()->get_tooltip_text() + aArgName; + pRefBtn->GetWidget()->set_accessible_name(aName); +} + +IMPL_LINK(ArgInput, FxBtnClickHdl, weld::Button&, rBtn, void) +{ + if (&rBtn == pBtnFx) + aFxClickLink.Call(*this); +} + +IMPL_LINK( ArgInput, FxBtnFocusHdl, weld::Widget&, rControl, void ) +{ + if (&rControl == pBtnFx) + aFxFocusLink.Call(*this); +} + +IMPL_LINK( ArgInput, EdFocusHdl, RefEdit&, rControl, void ) +{ + if (&rControl == pEdArg) + aEdFocusLink.Call(*this); +} + +IMPL_LINK( ArgInput, EdModifyHdl, RefEdit&, rEdit, void ) +{ + if (&rEdit == pEdArg) + aEdModifyLink.Call(*this); +} + +RefEdit::RefEdit(std::unique_ptr<weld::Entry> xControl) + : xEntry(std::move(xControl)) + , aIdle("formula RefEdit Idle") + , pAnyRefDlg(nullptr) + , pLabelWidget(nullptr) + , mpFocusInEvent(nullptr) + , mpFocusOutEvent(nullptr) +{ + xEntry->connect_focus_in(LINK(this, RefEdit, GetFocusHdl)); + xEntry->connect_focus_out(LINK(this, RefEdit, LoseFocusHdl)); + xEntry->connect_key_press(LINK(this, RefEdit, KeyInputHdl)); + xEntry->connect_changed(LINK(this, RefEdit, Modify)); + aIdle.SetInvokeHandler( LINK( this, RefEdit, UpdateHdl ) ); +} + +RefEdit::~RefEdit() +{ + if (mpFocusInEvent) + Application::RemoveUserEvent(mpFocusInEvent); + if (mpFocusOutEvent) + Application::RemoveUserEvent(mpFocusOutEvent); + aIdle.ClearInvokeHandler(); + aIdle.Stop(); +} + +void RefEdit::SetRefString( const OUString& rStr ) +{ + // Prevent unwanted side effects by setting only a differing string. + // See commit message for reasons. + if (xEntry->get_text() != rStr) + xEntry->set_text(rStr); +} + +void RefEdit::SetRefValid(bool bValid) +{ + xEntry->set_message_type(bValid ? weld::EntryMessageType::Normal : weld::EntryMessageType::Error); +} + +void RefEdit::SetText(const OUString& rStr) +{ + xEntry->set_text(rStr); + UpdateHdl( &aIdle ); +} + +void RefEdit::StartUpdateData() +{ + aIdle.Start(); +} + +void RefEdit::SetReferences(IControlReferenceHandler* pDlg, weld::Label* pLabel) +{ + pAnyRefDlg = pDlg; + pLabelWidget = pLabel; + + if( pDlg ) + { + aIdle.SetInvokeHandler(LINK(this, RefEdit, UpdateHdl)); + } + else + { + aIdle.ClearInvokeHandler(); + aIdle.Stop(); + } +} + +IMPL_LINK_NOARG(RefEdit, Modify, weld::Entry&, void) +{ + maModifyHdl.Call(*this); + if (pAnyRefDlg) + pAnyRefDlg->HideReference(); +} + +IMPL_LINK(RefEdit, KeyInputHdl, const KeyEvent&, rKEvt, bool) +{ + return KeyInput(rKEvt); +} + +bool RefEdit::KeyInput(const KeyEvent& rKEvt) +{ + const vcl::KeyCode& rKeyCode = rKEvt.GetKeyCode(); + if (pAnyRefDlg && !rKeyCode.GetModifier() && rKeyCode.GetCode() == KEY_F2) + { + pAnyRefDlg->ReleaseFocus( this ); + return true; + } + + switch (rKeyCode.GetCode()) + { + case KEY_RETURN: + case KEY_ESCAPE: + return maActivateHdl.Call(*GetWidget()); + } + + return false; +} + +void RefEdit::GetFocus() +{ + maGetFocusHdl.Call(*this); + StartUpdateData(); +} + +void RefEdit::LoseFocus() +{ + maLoseFocusHdl.Call(*this); + if( pAnyRefDlg ) + pAnyRefDlg->HideReference(); +} + +IMPL_LINK_NOARG(RefEdit, GetFocusHdl, weld::Widget&, void) +{ + // in e.g. function wizard RefEdits we want to select all when we get focus + // but in the gtk case there are pending gtk handlers which change selection + // after our handler, so post our focus in event to happen after those complete + if (mpFocusInEvent) + Application::RemoveUserEvent(mpFocusInEvent); + mpFocusInEvent = Application::PostUserEvent(LINK(this, RefEdit, AsyncFocusInHdl)); +} + +IMPL_LINK_NOARG(RefEdit, LoseFocusHdl, weld::Widget&, void) +{ + // tdf#127262 because focus in is async, focus out must not appear out + // of sequence to focus in + if (mpFocusOutEvent) + Application::RemoveUserEvent(mpFocusOutEvent); + mpFocusOutEvent = Application::PostUserEvent(LINK(this, RefEdit, AsyncFocusOutHdl)); +} + +IMPL_LINK_NOARG(RefEdit, AsyncFocusInHdl, void*, void) +{ + mpFocusInEvent = nullptr; + GetFocus(); +} + +IMPL_LINK_NOARG(RefEdit, AsyncFocusOutHdl, void*, void) +{ + mpFocusOutEvent = nullptr; + LoseFocus(); +} + +IMPL_LINK_NOARG(RefEdit, UpdateHdl, Timer *, void) +{ + if( pAnyRefDlg ) + pAnyRefDlg->ShowReference(xEntry->get_text()); +} + +RefButton::RefButton(std::unique_ptr<weld::Button> xControl) + : xButton(std::move(xControl)) + , pAnyRefDlg( nullptr ) + , pRefEdit( nullptr ) +{ + xButton->connect_focus_in(LINK(this, RefButton, GetFocus)); + xButton->connect_focus_out(LINK(this, RefButton, LoseFocus)); + xButton->connect_key_press(LINK(this, RefButton, KeyInput)); + xButton->connect_clicked(LINK(this, RefButton, Click)); + SetStartImage(); +} + +RefButton::~RefButton() +{ +} + +void RefButton::SetStartImage() +{ + xButton->set_from_icon_name(RID_BMP_REFBTN1); + xButton->set_tooltip_text(ForResId(RID_STR_SHRINK)); +} + +void RefButton::SetEndImage() +{ + xButton->set_from_icon_name(RID_BMP_REFBTN2); + xButton->set_tooltip_text(ForResId(RID_STR_EXPAND)); +} + +void RefButton::SetReferences( IControlReferenceHandler* pDlg, RefEdit* pEdit ) +{ + pAnyRefDlg = pDlg; + pRefEdit = pEdit; +} + +IMPL_LINK_NOARG(RefButton, Click, weld::Button&, void) +{ + maClickHdl.Call(*this); + if( pAnyRefDlg ) + pAnyRefDlg->ToggleCollapsed( pRefEdit, this ); +} + +IMPL_LINK(RefButton, KeyInput, const KeyEvent&, rKEvt, bool) +{ + const vcl::KeyCode& rKeyCode = rKEvt.GetKeyCode(); + if (pAnyRefDlg && !rKeyCode.GetModifier() && rKeyCode.GetCode() == KEY_F2) + { + pAnyRefDlg->ReleaseFocus( pRefEdit ); + return true; + } + + switch (rKeyCode.GetCode()) + { + case KEY_RETURN: + case KEY_ESCAPE: + return maActivateHdl.Call(*GetWidget()); + } + + return false; +} + +IMPL_LINK_NOARG(RefButton, GetFocus, weld::Widget&, void) +{ + maGetFocusHdl.Call(*this); + if (pRefEdit) + pRefEdit->StartUpdateData(); +} + +IMPL_LINK_NOARG(RefButton, LoseFocus, weld::Widget&, void) +{ + maLoseFocusHdl.Call(*this); + if (pRefEdit) + pRefEdit->DoModify(); +} + +} // formula + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/formula/source/ui/dlg/parawin.cxx b/formula/source/ui/dlg/parawin.cxx new file mode 100644 index 000000000..1eaba4d19 --- /dev/null +++ b/formula/source/ui/dlg/parawin.cxx @@ -0,0 +1,600 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include <comphelper/string.hxx> +#include <vcl/svapp.hxx> +#include <sal/log.hxx> + +#include "parawin.hxx" +#include <formula/IFunctionDescription.hxx> +#include <formula/funcvarargs.h> +#include <strings.hrc> +#include <bitmaps.hlst> +#include <core_resource.hxx> + +namespace formula +{ + +// Formula token argument count is sal_uInt8, max 255, edit offset 254. +constexpr sal_uInt16 kMaxArgCount = 255; +constexpr sal_uInt16 kMaxArgOffset = kMaxArgCount - 1; + +ParaWin::ParaWin(weld::Container* pParent,IControlReferenceHandler* _pDlg) + : pFuncDesc(nullptr) + , pMyParent(_pDlg) + , m_sOptional(ForResId(STR_OPTIONAL)) + , m_sRequired(ForResId(STR_REQUIRED)) + , m_xBuilder(Application::CreateBuilder(pParent, "formula/ui/parameter.ui")) + , m_xContainer(m_xBuilder->weld_container("ParameterPage")) + , m_xSlider(m_xBuilder->weld_scrolled_window("scrollbar", true)) + , m_xParamGrid(m_xBuilder->weld_widget("paramgrid")) + , m_xGrid(m_xBuilder->weld_widget("grid")) + , m_xFtEditDesc(m_xBuilder->weld_label("editdesc")) + , m_xFtArgName(m_xBuilder->weld_label("parname")) + , m_xFtArgDesc(m_xBuilder->weld_label("pardesc")) + , m_xBtnFx1(m_xBuilder->weld_button("FX1")) + , m_xBtnFx2(m_xBuilder->weld_button("FX2")) + , m_xBtnFx3(m_xBuilder->weld_button("FX3")) + , m_xBtnFx4(m_xBuilder->weld_button("FX4")) + , m_xFtArg1(m_xBuilder->weld_label("FT_ARG1")) + , m_xFtArg2(m_xBuilder->weld_label("FT_ARG2")) + , m_xFtArg3(m_xBuilder->weld_label("FT_ARG3")) + , m_xFtArg4(m_xBuilder->weld_label("FT_ARG4")) + , m_xEdArg1(new ArgEdit(m_xBuilder->weld_entry("ED_ARG1"))) + , m_xEdArg2(new ArgEdit(m_xBuilder->weld_entry("ED_ARG2"))) + , m_xEdArg3(new ArgEdit(m_xBuilder->weld_entry("ED_ARG3"))) + , m_xEdArg4(new ArgEdit(m_xBuilder->weld_entry("ED_ARG4"))) + , m_xRefBtn1(new RefButton(m_xBuilder->weld_button("RB_ARG1"))) + , m_xRefBtn2(new RefButton(m_xBuilder->weld_button("RB_ARG2"))) + , m_xRefBtn3(new RefButton(m_xBuilder->weld_button("RB_ARG3"))) + , m_xRefBtn4(new RefButton(m_xBuilder->weld_button("RB_ARG4"))) +{ + // Space for three lines of text in function description. + m_xFtEditDesc->set_label("X\nX\nX\n"); + auto nEditHeight = m_xFtEditDesc->get_preferred_size().Height(); + m_xFtEditDesc->set_size_request(-1, nEditHeight); + m_xFtEditDesc->set_label(""); + // Space for two lines of text in parameter description. + m_xFtArgDesc->set_label("X\nX\n"); + auto nArgHeight = m_xFtArgDesc->get_preferred_size().Height(); + m_xFtArgDesc->set_size_request(-1, nArgHeight); + m_xFtArgDesc->set_label(""); + + m_xBtnFx1->set_from_icon_name(BMP_FX); + m_xBtnFx2->set_from_icon_name(BMP_FX); + m_xBtnFx3->set_from_icon_name(BMP_FX); + m_xBtnFx4->set_from_icon_name(BMP_FX); + + //lock down initial preferences + m_xParamGrid->set_size_request(-1, m_xParamGrid->get_preferred_size().Height()); + Size aSize(m_xContainer->get_preferred_size()); + m_xContainer->set_size_request(aSize.Width(), aSize.Height()); + + aDefaultString = m_xFtEditDesc->get_label(); + nEdFocus = NOT_FOUND; + nActiveLine = 0; + + m_xSlider->connect_vadjustment_changed(LINK(this, ParaWin, ScrollHdl)); + + InitArgInput( 0, *m_xFtArg1, *m_xBtnFx1, *m_xEdArg1, *m_xRefBtn1); + InitArgInput( 1, *m_xFtArg2, *m_xBtnFx2, *m_xEdArg2, *m_xRefBtn2); + InitArgInput( 2, *m_xFtArg3, *m_xBtnFx3, *m_xEdArg3, *m_xRefBtn3); + InitArgInput( 3, *m_xFtArg4, *m_xBtnFx4, *m_xEdArg4, *m_xRefBtn4); + ClearAll(); +} + +void ParaWin::UpdateArgDesc( sal_uInt16 nArg ) +{ + if (nArg == NOT_FOUND) + return; + + if (nMaxArgs > 4) + nArg = sal::static_int_cast<sal_uInt16>( nArg + GetSliderPos() ); + + if ((nMaxArgs <= 0) || (nArg >= nMaxArgs)) + return; + + OUString aArgDesc; + OUString aArgName; + + SetArgumentDesc( OUString() ); + SetArgumentText( OUString() ); + + if ( nArgs < VAR_ARGS ) + { + sal_uInt16 nRealArg = (nArg < aVisibleArgMapping.size()) ? aVisibleArgMapping[nArg] : nArg; + aArgDesc = pFuncDesc->getParameterDescription(nRealArg); + aArgName = pFuncDesc->getParameterName(nRealArg) + " " + + ((pFuncDesc->isParameterOptional(nRealArg)) ? m_sOptional : m_sRequired); + } + else if ( nArgs < PAIRED_VAR_ARGS ) + { + sal_uInt16 nFix = nArgs - VAR_ARGS; + sal_uInt16 nPos = std::min( nArg, nFix ); + sal_uInt16 nRealArg = (nPos < aVisibleArgMapping.size() ? + aVisibleArgMapping[nPos] : aVisibleArgMapping.back()); + aArgDesc = pFuncDesc->getParameterDescription(nRealArg); + aArgName = pFuncDesc->getParameterName(nRealArg); + sal_uInt16 nVarArgsStart = pFuncDesc->getVarArgsStart(); + if ( nArg >= nVarArgsStart ) + aArgName += OUString::number( nArg-nVarArgsStart+1 ); + aArgName += " " + ((nArg > nFix || pFuncDesc->isParameterOptional(nRealArg)) ? m_sOptional : m_sRequired) ; + } + else + { + sal_uInt16 nFix = nArgs - PAIRED_VAR_ARGS; + sal_uInt16 nPos; + if ( nArg < nFix ) + nPos = nArg; + else + nPos = nFix + ( (nArg-nFix) % 2); + sal_uInt16 nRealArg = (nPos < aVisibleArgMapping.size() ? + aVisibleArgMapping[nPos] : aVisibleArgMapping.back()); + aArgDesc = pFuncDesc->getParameterDescription(nRealArg); + aArgName = pFuncDesc->getParameterName(nRealArg); + sal_uInt16 nVarArgsStart = pFuncDesc->getVarArgsStart(); + if ( nArg >= nVarArgsStart ) + aArgName += OUString::number( (nArg-nVarArgsStart)/2 + 1 ); + aArgName += " " + ((nArg > (nFix+1) || pFuncDesc->isParameterOptional(nRealArg)) ? m_sOptional : m_sRequired) ; + } + + SetArgumentDesc(aArgDesc); + SetArgumentText(aArgName); +} + +void ParaWin::UpdateArgInput( sal_uInt16 nOffset, sal_uInt16 i ) +{ + sal_uInt16 nArg = nOffset + i; + if (nArg > kMaxArgOffset) + return; + + if ( nArgs < VAR_ARGS) + { + if (nArg < nMaxArgs) + { + sal_uInt16 nRealArg = aVisibleArgMapping[nArg]; + SetArgNameFont (i,(pFuncDesc->isParameterOptional(nRealArg)) + ? aFntLight : aFntBold ); + SetArgName (i,pFuncDesc->getParameterName(nRealArg)); + } + } + else if ( nArgs < PAIRED_VAR_ARGS) + { + sal_uInt16 nFix = nArgs - VAR_ARGS; + sal_uInt16 nPos = std::min( nArg, nFix ); + sal_uInt16 nRealArg = (nPos < aVisibleArgMapping.size() ? + aVisibleArgMapping[nPos] : aVisibleArgMapping.back()); + SetArgNameFont( i, + (nArg > nFix || pFuncDesc->isParameterOptional(nRealArg)) ? + aFntLight : aFntBold ); + sal_uInt16 nVarArgsStart = pFuncDesc->getVarArgsStart(); + if ( nArg >= nVarArgsStart ) + { + OUString aArgName = pFuncDesc->getParameterName(nRealArg) + + OUString::number(nArg-nVarArgsStart+1); + SetArgName( i, aArgName ); + } + else + SetArgName( i, pFuncDesc->getParameterName(nRealArg) ); + } + else + { + sal_uInt16 nFix = nArgs - PAIRED_VAR_ARGS; + sal_uInt16 nPos; + if ( nArg < nFix ) + nPos = nArg; + else + nPos = nFix + ( (nArg-nFix) % 2); + sal_uInt16 nRealArg = (nPos < aVisibleArgMapping.size() ? + aVisibleArgMapping[nPos] : aVisibleArgMapping.back()); + SetArgNameFont( i, + (nArg > (nFix+1) || pFuncDesc->isParameterOptional(nRealArg)) ? + aFntLight : aFntBold ); + sal_uInt16 nVarArgsStart = pFuncDesc->getVarArgsStart(); + if ( nArg >= nVarArgsStart ) + { + OUString aArgName = pFuncDesc->getParameterName(nRealArg) + + OUString::number( (nArg-nVarArgsStart)/2 + 1 ); + SetArgName( i, aArgName ); + } + else + SetArgName( i, pFuncDesc->getParameterName(nRealArg) ); + } + if (nArg < nMaxArgs) + aArgInput[i].SetArgVal(aParaArray[nArg]); +} + +ParaWin::~ParaWin() +{ + // #i66422# if the focus changes during destruction of the controls, + // don't call the focus handlers + Link<weld::Widget&,void> aEmptyLink; + m_xBtnFx1->connect_focus_in(aEmptyLink); + m_xBtnFx2->connect_focus_in(aEmptyLink); + m_xBtnFx3->connect_focus_in(aEmptyLink); + m_xBtnFx4->connect_focus_in(aEmptyLink); +} + +void ParaWin::SetActiveLine(sal_uInt16 no) +{ + if (no >= nMaxArgs) + return; + + tools::Long nOffset = GetSliderPos(); + nActiveLine=no; + tools::Long nNewEdPos=static_cast<tools::Long>(nActiveLine)-nOffset; + if(nNewEdPos<0 || nNewEdPos>3) + { + nOffset+=nNewEdPos; + SetSliderPos(static_cast<sal_uInt16>(nOffset)); + nOffset=GetSliderPos(); + } + nEdFocus=no-static_cast<sal_uInt16>(nOffset); + UpdateArgDesc( nEdFocus ); +} + +RefEdit* ParaWin::GetActiveEdit() +{ + if (nMaxArgs > 0 && nEdFocus != NOT_FOUND) + { + return aArgInput[nEdFocus].GetArgEdPtr(); + } + else + { + return nullptr; + } +} + + +OUString ParaWin::GetArgument(sal_uInt16 no) +{ + OUString aStr; + if(no<aParaArray.size()) + { + aStr=aParaArray[no]; + if(no==nActiveLine && aStr.isEmpty()) + aStr += " "; + } + return aStr; +} + +OUString ParaWin::GetActiveArgName() const +{ + OUString aStr; + if (nMaxArgs > 0 && nEdFocus != NOT_FOUND) + { + aStr=aArgInput[nEdFocus].GetArgName(); + } + return aStr; +} + + +void ParaWin::SetArgument(sal_uInt16 no, std::u16string_view aString) +{ + if (no < aParaArray.size()) + aParaArray[no] = comphelper::string::stripStart(aString, ' '); +} + +void ParaWin::SetArgumentFonts(const vcl::Font&aBoldFont,const vcl::Font&aLightFont) +{ + aFntBold=aBoldFont; + aFntLight=aLightFont; +} + +void ParaWin::SetFunctionDesc(const IFunctionDescription* pFDesc) +{ + pFuncDesc=pFDesc; + + SetArgumentDesc( OUString() ); + SetArgumentText( OUString() ); + SetEditDesc( OUString() ); + nMaxArgs = nArgs = 0; + if ( pFuncDesc!=nullptr) + { + if ( !pFuncDesc->getDescription().isEmpty() ) + { + SetEditDesc(pFuncDesc->getDescription()); + } + else + { + SetEditDesc(aDefaultString); + } + nArgs = pFuncDesc->getSuppressedArgumentCount(); + nMaxArgs = std::min( nArgs, kMaxArgCount); + if (sal_uInt16 nVarArgsLimit = pFuncDesc->getVarArgsLimit()) + nMaxArgs = std::min( nVarArgsLimit, nMaxArgs); + pFuncDesc->fillVisibleArgumentMapping(aVisibleArgMapping); + m_xSlider->set_vpolicy(VclPolicyType::NEVER); + m_xSlider->set_size_request(-1, -1); + OString sHelpId = pFuncDesc->getHelpId(); + m_xContainer->set_help_id(sHelpId); + m_xEdArg1->GetWidget()->set_help_id(sHelpId); + m_xEdArg2->GetWidget()->set_help_id(sHelpId); + m_xEdArg3->GetWidget()->set_help_id(sHelpId); + m_xEdArg4->GetWidget()->set_help_id(sHelpId); + + SetActiveLine(0); + } + else + { + nActiveLine=0; + } + +} + +void ParaWin::SetArgumentText(const OUString& aText) +{ + m_xFtArgName->set_label(aText); +} + +void ParaWin::SetArgumentDesc(const OUString& aText) +{ + m_xFtArgDesc->set_label(aText); +} + +void ParaWin::SetEditDesc(const OUString& aText) +{ + m_xFtEditDesc->set_label(aText); +} + +void ParaWin::SetArgName(sal_uInt16 no,const OUString& aText) +{ + aArgInput[no].SetArgName(aText); + aArgInput[no].UpdateAccessibleNames(); +} + +void ParaWin::SetArgNameFont(sal_uInt16 no,const vcl::Font& aFont) +{ + aArgInput[no].SetArgNameFont(aFont); +} + +void ParaWin::SetEdFocus() +{ + UpdateArgDesc(0); + if(!aParaArray.empty()) + aArgInput[0].GetArgEdPtr()->GrabFocus(); +} + +void ParaWin::InitArgInput(sal_uInt16 nPos, weld::Label& rFtArg, weld::Button& rBtnFx, + ArgEdit& rEdArg, RefButton& rRefBtn) +{ + + rRefBtn.SetReferences(pMyParent, &rEdArg); + rEdArg.SetReferences(pMyParent, &rFtArg); + + aArgInput[nPos].InitArgInput (&rFtArg,&rBtnFx,&rEdArg,&rRefBtn); + + aArgInput[nPos].Hide(); + + aArgInput[nPos].SetFxClickHdl ( LINK( this, ParaWin, GetFxHdl ) ); + aArgInput[nPos].SetFxFocusHdl ( LINK( this, ParaWin, GetFxFocusHdl ) ); + aArgInput[nPos].SetEdFocusHdl ( LINK( this, ParaWin, GetEdFocusHdl ) ); + aArgInput[nPos].SetEdModifyHdl ( LINK( this, ParaWin, ModifyHdl ) ); + aArgInput[nPos].UpdateAccessibleNames(); +} + +void ParaWin::ClearAll() +{ + SetFunctionDesc(nullptr); + SetArgumentOffset(0); +} + +void ParaWin::SetArgumentOffset(sal_uInt16 nOffset) +{ + aParaArray.clear(); + m_xSlider->vadjustment_set_value(0); + + aParaArray.resize(nMaxArgs); + + if (nMaxArgs > 0) + { + for ( int i=0; i<4 && i<nMaxArgs; i++ ) + { + aArgInput[i].SetArgVal(OUString()); + aArgInput[i].GetArgEdPtr()->Init( + (i==0) ? nullptr : aArgInput[i-1].GetArgEdPtr(), + (i==3 || i==nMaxArgs-1) ? nullptr : aArgInput[i+1].GetArgEdPtr(), + *m_xSlider, *this, nMaxArgs ); + } + } + + UpdateParas(); + + if (nMaxArgs < 5) + { + m_xSlider->set_vpolicy(VclPolicyType::NEVER); + m_xSlider->set_size_request(-1, -1); + } + else + { + m_xSlider->vadjustment_configure(nOffset, 0, nMaxArgs, 1, 4, 4); + m_xSlider->set_vpolicy(VclPolicyType::ALWAYS); + Size aPrefSize(m_xGrid->get_preferred_size()); + m_xSlider->set_size_request(aPrefSize.Width(), aPrefSize.Height()); + } +} + +void ParaWin::UpdateParas() +{ + sal_uInt16 i; + sal_uInt16 nOffset = GetSliderPos(); + + if ( nMaxArgs > 0 ) + { + for ( i=0; (i<nMaxArgs) && (i<4); i++ ) + { + UpdateArgInput( nOffset, i ); + aArgInput[i].Show(); + } + } + + for ( i=nMaxArgs; i<4; i++ ) + aArgInput[i].Hide(); +} + + +sal_uInt16 ParaWin::GetSliderPos() const +{ + return static_cast<sal_uInt16>(m_xSlider->vadjustment_get_value()); +} + +void ParaWin::SetSliderPos(sal_uInt16 nSliderPos) +{ + sal_uInt16 nOffset = GetSliderPos(); + + if(m_xSlider->get_visible() && nOffset!=nSliderPos) + { + m_xSlider->vadjustment_set_value(nSliderPos); + for ( sal_uInt16 i=0; i<4; i++ ) + { + UpdateArgInput( nSliderPos, i ); + } + } +} + +void ParaWin::SliderMoved() +{ + sal_uInt16 nOffset = GetSliderPos(); + + for ( sal_uInt16 i=0; i<4; i++ ) + { + UpdateArgInput( nOffset, i ); + } + if(nEdFocus!=NOT_FOUND) + { + UpdateArgDesc( nEdFocus ); + aArgInput[nEdFocus].SelectAll(); + nActiveLine=nEdFocus+nOffset; + ArgumentModified(); + aArgInput[nEdFocus].SelectAll(); // ensure all is still selected + aArgInput[nEdFocus].UpdateAccessibleNames(); + } +} + +void ParaWin::ArgumentModified() +{ + aArgModifiedLink.Call(*this); +} + +IMPL_LINK( ParaWin, GetFxHdl, ArgInput&, rPtr, void ) +{ + sal_uInt16 nOffset = GetSliderPos(); + nEdFocus=NOT_FOUND; + for (size_t nPos=0; nPos < SAL_N_ELEMENTS(aArgInput); ++nPos) + { + if(&rPtr == &aArgInput[nPos]) + { + nEdFocus=nPos; + break; + } + } + + if(nEdFocus!=NOT_FOUND) + { + aArgInput[nEdFocus].SelectAll(); + nActiveLine=nEdFocus+nOffset; + aFxLink.Call(*this); + } +} + +IMPL_LINK( ParaWin, GetFxFocusHdl, ArgInput&, rPtr, void ) +{ + sal_uInt16 nOffset = GetSliderPos(); + nEdFocus=NOT_FOUND; + for (size_t nPos=0; nPos < SAL_N_ELEMENTS(aArgInput); ++nPos) + { + if(&rPtr == &aArgInput[nPos]) + { + nEdFocus=nPos; + break; + } + } + + if(nEdFocus!=NOT_FOUND) + { + aArgInput[nEdFocus].SelectAll(); + UpdateArgDesc( nEdFocus ); + nActiveLine=nEdFocus+nOffset; + } +} + +IMPL_LINK( ParaWin, GetEdFocusHdl, ArgInput&, rPtr, void ) +{ + sal_uInt16 nOffset = GetSliderPos(); + nEdFocus=NOT_FOUND; + for (size_t nPos=0; nPos < SAL_N_ELEMENTS(aArgInput); ++nPos) + { + if(&rPtr == &aArgInput[nPos]) + { + nEdFocus=nPos; + break; + } + } + + if(nEdFocus!=NOT_FOUND) + { + aArgInput[nEdFocus].SelectAll(); + UpdateArgDesc( nEdFocus ); + nActiveLine=nEdFocus+nOffset; + ArgumentModified(); + aArgInput[nEdFocus].SelectAll(); // ensure all is still selected + aArgInput[nEdFocus].UpdateAccessibleNames(); + } +} + +IMPL_LINK_NOARG(ParaWin, ScrollHdl, weld::ScrolledWindow&, void) +{ + SliderMoved(); +} + +IMPL_LINK( ParaWin, ModifyHdl, ArgInput&, rPtr, void ) +{ + sal_uInt16 nOffset = GetSliderPos(); + nEdFocus=NOT_FOUND; + for (size_t nPos=0; nPos < SAL_N_ELEMENTS(aArgInput); ++nPos) + { + if(&rPtr == &aArgInput[nPos]) + { + nEdFocus=nPos; + break; + } + } + if(nEdFocus!=NOT_FOUND) + { + size_t nPara = nEdFocus + nOffset; + if (nPara < aParaArray.size()) + aParaArray[nPara] = aArgInput[nEdFocus].GetArgVal(); + else + { + SAL_WARN("formula.ui","ParaWin::ModifyHdl - shot in foot: nPara " << + nPara << " >= aParaArray.size() " << aParaArray.size() << + " with nEdFocus " << nEdFocus << + " and aArgInput[nEdFocus].GetArgVal() '" << aArgInput[nEdFocus].GetArgVal() << "'"); + } + UpdateArgDesc( nEdFocus); + nActiveLine = static_cast<sal_uInt16>(nPara); + } + + ArgumentModified(); +} + + +} // formula + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/formula/source/ui/dlg/parawin.hxx b/formula/source/ui/dlg/parawin.hxx new file mode 100644 index 000000000..b2fe7ece6 --- /dev/null +++ b/formula/source/ui/dlg/parawin.hxx @@ -0,0 +1,145 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#pragma once + +#include <formula/funcutl.hxx> +#include <vcl/weld.hxx> +#include "ControlHelper.hxx" +#include <vector> + +namespace formula +{ + +#define NOT_FOUND 0xffff + +class IFunctionDescription; +class IControlReferenceHandler; + +class ParaWin +{ +private: + Link<ParaWin&,void> aFxLink; + Link<ParaWin&,void> aArgModifiedLink; + + ::std::vector<sal_uInt16> aVisibleArgMapping; + const IFunctionDescription* pFuncDesc; + IControlReferenceHandler* pMyParent; + sal_uInt16 nArgs; // unsuppressed arguments, may be >= VAR_ARGS to indicate repeating parameters + sal_uInt16 nMaxArgs; // max arguments, limited to supported number of arguments + vcl::Font aFntBold; + vcl::Font aFntLight; + + OUString m_sOptional; + OUString m_sRequired; + + sal_uInt16 nEdFocus; + sal_uInt16 nActiveLine; + + ArgInput aArgInput[4]; + OUString aDefaultString; + ::std::vector<OUString> aParaArray; + + std::unique_ptr<weld::Builder> m_xBuilder; + std::unique_ptr<weld::Container> m_xContainer; + + std::unique_ptr<weld::ScrolledWindow> m_xSlider; + std::unique_ptr<weld::Widget> m_xParamGrid; + std::unique_ptr<weld::Widget> m_xGrid; + + std::unique_ptr<weld::Label> m_xFtEditDesc; + std::unique_ptr<weld::Label> m_xFtArgName; + std::unique_ptr<weld::Label> m_xFtArgDesc; + + std::unique_ptr<weld::Button> m_xBtnFx1; + std::unique_ptr<weld::Button> m_xBtnFx2; + std::unique_ptr<weld::Button> m_xBtnFx3; + std::unique_ptr<weld::Button> m_xBtnFx4; + + std::unique_ptr<weld::Label> m_xFtArg1; + std::unique_ptr<weld::Label> m_xFtArg2; + std::unique_ptr<weld::Label> m_xFtArg3; + std::unique_ptr<weld::Label> m_xFtArg4; + + std::unique_ptr<ArgEdit> m_xEdArg1; + std::unique_ptr<ArgEdit> m_xEdArg2; + std::unique_ptr<ArgEdit> m_xEdArg3; + std::unique_ptr<ArgEdit> m_xEdArg4; + + std::unique_ptr<RefButton> m_xRefBtn1; + std::unique_ptr<RefButton> m_xRefBtn2; + std::unique_ptr<RefButton> m_xRefBtn3; + std::unique_ptr<RefButton> m_xRefBtn4; + + DECL_LINK( ScrollHdl, weld::ScrolledWindow&, void); + DECL_LINK( ModifyHdl, ArgInput&, void ); + DECL_LINK( GetEdFocusHdl, ArgInput&, void ); + DECL_LINK( GetFxFocusHdl, ArgInput&, void ); + DECL_LINK( GetFxHdl, ArgInput&, void ); + + void ArgumentModified(); + + void InitArgInput(sal_uInt16 nPos, weld::Label& rFtArg, weld::Button& rBtnFx, + ArgEdit& rEdArg, RefButton& rRefBtn); + + void SetArgumentDesc(const OUString& aText); + void SetArgumentText(const OUString& aText); + + + void SetArgName (sal_uInt16 no,const OUString &aArg); + void SetArgNameFont (sal_uInt16 no,const vcl::Font&); + + void UpdateArgDesc( sal_uInt16 nArg ); + void UpdateArgInput( sal_uInt16 nOffset, sal_uInt16 i ); + +public: + ParaWin(weld::Container* pParent, IControlReferenceHandler* _pDlg); + ~ParaWin(); + + void SetFunctionDesc(const IFunctionDescription* pFDesc); + void SetArgumentOffset(sal_uInt16 nOffset); + void SetEditDesc(const OUString& aText); + void UpdateParas(); + void ClearAll(); + + sal_uInt16 GetActiveLine() const { return nActiveLine;} + void SetActiveLine(sal_uInt16 no); + RefEdit* GetActiveEdit(); + OUString GetActiveArgName() const; + + OUString GetArgument(sal_uInt16 no); + void SetArgument(sal_uInt16 no, std::u16string_view aString); + void SetArgumentFonts(const vcl::Font& aBoldFont,const vcl::Font& aLightFont); + + void SetEdFocus(); // visible edit lines + sal_uInt16 GetSliderPos() const; + void SetSliderPos(sal_uInt16 nSliderPos); + + void SetArgModifiedHdl( const Link<ParaWin&,void>& rLink ) { aArgModifiedLink = rLink; } + void SetFxHdl( const Link<ParaWin&,void>& rLink ) { aFxLink = rLink; } + + void SliderMoved(); + + void Show() { m_xContainer->show(); } +}; + + +} // formula + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/formula/source/ui/dlg/structpg.cxx b/formula/source/ui/dlg/structpg.cxx new file mode 100644 index 000000000..6cfc34a96 --- /dev/null +++ b/formula/source/ui/dlg/structpg.cxx @@ -0,0 +1,154 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include <vcl/svapp.hxx> + +#include "structpg.hxx" +#include <formula/formula.hxx> +#include <formula/token.hxx> +#include <bitmaps.hlst> + +namespace formula +{ + +void StructPage::SetActiveFlag(bool bFlag) +{ + bActiveFlag = bFlag; +} + +StructPage::StructPage(weld::Container* pParent) + : m_xBuilder(Application::CreateBuilder(pParent, "formula/ui/structpage.ui")) + , m_xContainer(m_xBuilder->weld_container("StructPage")) + , m_xTlbStruct(m_xBuilder->weld_tree_view("struct")) + , maImgEnd(BMP_STR_END) + , maImgError(BMP_STR_ERROR) + , pSelectedToken(nullptr) + , bActiveFlag(false) +{ + m_xTlbStruct->set_size_request(m_xTlbStruct->get_approximate_digit_width() * 20, + m_xTlbStruct->get_height_rows(17)); + + m_xTlbStruct->connect_changed(LINK( this, StructPage, SelectHdl ) ); +} + +StructPage::~StructPage() +{ +} + +void StructPage::ClearStruct() +{ + SetActiveFlag(false); + m_xTlbStruct->clear(); +} + +bool StructPage::InsertEntry(const OUString& rText, const weld::TreeIter* pParent, + sal_uInt16 nFlag, int nPos, + const FormulaToken* pIFormulaToken, + weld::TreeIter& rRet) +{ + SetActiveFlag(false); + + OUString sId(weld::toId(pIFormulaToken)); + + bool bEntry = false; + switch (nFlag) + { + case STRUCT_FOLDER: + m_xTlbStruct->insert(pParent, nPos, &rText, &sId, nullptr, nullptr, + false, &rRet); + m_xTlbStruct->set_image(rRet, BMP_STR_OPEN); + bEntry = true; + break; + case STRUCT_END: + m_xTlbStruct->insert(pParent, nPos, &rText, &sId, nullptr, nullptr, + false, &rRet); + m_xTlbStruct->set_image(rRet, maImgEnd); + bEntry = true; + break; + case STRUCT_ERROR: + m_xTlbStruct->insert(pParent, nPos, &rText, &sId, nullptr, nullptr, + false, &rRet); + m_xTlbStruct->set_image(rRet, maImgError); + bEntry = true; + break; + } + + if (bEntry && pParent) + m_xTlbStruct->expand_row(*pParent); + return bEntry; +} + +OUString StructPage::GetEntryText(const weld::TreeIter* pEntry) const +{ + OUString aString; + if (pEntry) + aString = m_xTlbStruct->get_text(*pEntry); + return aString; +} + +const FormulaToken* StructPage::GetFunctionEntry(const weld::TreeIter* pEntry) +{ + if (!pEntry) + return nullptr; + + const FormulaToken * pToken = weld::fromId<const FormulaToken*>(m_xTlbStruct->get_id(*pEntry)); + if (pToken) + { + if ( !(pToken->IsFunction() || pToken->GetParamCount() > 1 ) ) + { + std::unique_ptr<weld::TreeIter> xParent(m_xTlbStruct->make_iterator(pEntry)); + if (!m_xTlbStruct->iter_parent(*xParent)) + return nullptr; + return GetFunctionEntry(xParent.get()); + } + else + { + return pToken; + } + } + return nullptr; +} + +IMPL_LINK(StructPage, SelectHdl, weld::TreeView&, rTlb, void) +{ + if (!GetActiveFlag()) + return; + + if (&rTlb == m_xTlbStruct.get()) + { + std::unique_ptr<weld::TreeIter> xCurEntry(m_xTlbStruct->make_iterator()); + if (m_xTlbStruct->get_cursor(xCurEntry.get())) + { + pSelectedToken = weld::fromId<const FormulaToken*>(m_xTlbStruct->get_id(*xCurEntry)); + if (pSelectedToken) + { + if ( !(pSelectedToken->IsFunction() || pSelectedToken->GetParamCount() > 1) ) + { + pSelectedToken = GetFunctionEntry(xCurEntry.get()); + } + } + } + } + + aSelLink.Call(*this); +} + +} // formula + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/formula/source/ui/dlg/structpg.hxx b/formula/source/ui/dlg/structpg.hxx new file mode 100644 index 000000000..116403189 --- /dev/null +++ b/formula/source/ui/dlg/structpg.hxx @@ -0,0 +1,74 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#pragma once + +#include <vcl/weld.hxx> + +namespace formula +{ + +class FormulaToken; + + +class StructPage final +{ +private: + std::unique_ptr<weld::Builder> m_xBuilder; + std::unique_ptr<weld::Container> m_xContainer; + std::unique_ptr<weld::TreeView> m_xTlbStruct; + + Link<StructPage&,void> aSelLink; + + OUString maImgEnd; + OUString maImgError; + + const FormulaToken* pSelectedToken; + bool bActiveFlag; + + DECL_LINK(SelectHdl, weld::TreeView&, void); + + const FormulaToken* GetFunctionEntry(const weld::TreeIter* pEntry); + + void SetActiveFlag(bool bFlag); + bool GetActiveFlag() const { return bActiveFlag;} + +public: + + explicit StructPage(weld::Container* pParent); + ~StructPage(); + + void ClearStruct(); + bool InsertEntry(const OUString& rText, const weld::TreeIter* pParent, + sal_uInt16 nFlag, int nPos, + const FormulaToken* pIFormulaToken, + weld::TreeIter& rRet); + + OUString GetEntryText(const weld::TreeIter* pEntry) const; + + void SetSelectionHdl( const Link<StructPage&,void>& rLink ) { aSelLink = rLink; } + + weld::TreeView& GetTlbStruct() const { return *m_xTlbStruct; } + + bool IsVisible() const { return m_xContainer->get_visible(); } +}; + +} // formula + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |