sc/source/core/tool/cellform.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <cellform.hxx>
  21 #include <cellformtmpl.hxx>
  22
  23 #include <svl/numformat.hxx>
  24 #include <svl/sharedstring.hxx>
  25 #include <svl/sharedstringpool.hxx>
  26
  27 #include <formulacell.hxx>
  28 #include <document.hxx>
  29 #include <cellvalue.hxx>
  30 #include <formula/errorcodes.hxx>
  31 #include <editutil.hxx>
  32
  33 OUString ScCellFormat::GetString( const ScRefCellValue& rCell, sal_uInt32 nFormat,
  34                               const Color** ppColor, ScInterpreterContext* pContext, const ScDocument& rDoc,
  35                               bool bNullVals, bool bFormula, bool bUseStarFormat )
  36 {
  37     *ppColor = nullptr;
  38
  39     ScInterpreterContext& rContext = pContext ? *pContext : rDoc.GetNonThreadedContext();
  40
  41     switch (rCell.getType())
  42     {
  43         case CELLTYPE_STRING:
  44         {
  45             OUString str;
  46             rContext.NFGetOutputString(rCell.getSharedString()->getString(), nFormat, str, ppColor, bUseStarFormat);
  47             return str;
  48         }
  49         case CELLTYPE_EDIT:
  50         {
  51             OUString str;
  52             rContext.NFGetOutputString(rCell.getString(&rDoc), nFormat, str, ppColor );
  53             return str;
  54         }
  55         case CELLTYPE_VALUE:
  56         {
  57             const double nValue = rCell.getDouble();
  58             if (!bNullVals && nValue == 0.0)
  59                 return OUString();
  60             else
  61             {
  62                 OUString str;
  63                 rContext.NFGetOutputString( nValue, nFormat, str, ppColor, bUseStarFormat );
  64                 return str;
  65             }
  66         }
  67         case CELLTYPE_FORMULA:
  68         {
  69             ScFormulaCell*  pFCell = rCell.getFormula();
  70             if ( bFormula )
  71             {
  72                 return pFCell->GetFormula();
  73             }
  74             else
  75             {
  76                 // A macro started from the interpreter, which has
  77                 // access to Formula Cells, becomes a CellText, even if
  78                 // that triggers further interpretation, except if those
  79                 // cells are already being interpreted.
  80                 // IdleCalc generally doesn't trigger further interpretation,
  81                 // as not to get Err522 (circular).
  82                 if ( pFCell->GetDocument().IsInInterpreter() &&
  83                         (!pFCell->GetDocument().GetMacroInterpretLevel()
  84                         || pFCell->IsRunning()) )
  85                 {
  86                     return u"..."_ustr;
  87                 }
  88                 else
  89                 {
  90                     const FormulaError nErrCode = pFCell->GetErrCode();
  91
  92                     if (nErrCode != FormulaError::NONE)
  93                         return ScGlobal::GetErrorString(nErrCode);
  94                     else if ( pFCell->IsEmptyDisplayedAsString() )
  95                         return OUString();
  96                     else if ( pFCell->IsValue() )
  97                     {
  98                         double fValue = pFCell->GetValue();
  99                         if ( !bNullVals && fValue == 0.0 )
 100                             return OUString();
 101                         else
 102                         {
 103                             OUString str;
 104                             rContext.NFGetOutputString( fValue, nFormat, str, ppColor, bUseStarFormat );
 105                             return str;
 106                         }
 107                     }
 108                     else
 109                     {
 110                         OUString str;
 111                         rContext.NFGetOutputString( pFCell->GetString().getString(),
 112                                                     nFormat, str, ppColor, bUseStarFormat );
 113                         return str;
 114                     }
 115                 }
 116             }
 117         }
 118         default:
 119             return OUString();
 120     }
 121 }
 122
 123 OUString ScCellFormat::GetString(
 124     ScDocument& rDoc, const ScAddress& rPos, sal_uInt32 nFormat, const Color** ppColor,
 125     ScInterpreterContext* pContext, bool bNullVals, bool bFormula )
 126 {
 127     *ppColor = nullptr;
 128
 129     ScRefCellValue aCell(rDoc, rPos);
 130     return GetString(aCell, nFormat, ppColor, pContext, rDoc, bNullVals, bFormula);
 131 }
 132
 133 OUString ScCellFormat::GetInputString(
 134     const ScRefCellValue& rCell, sal_uInt32 nFormat, ScInterpreterContext* pContext, const ScDocument& rDoc,
 135     bool bFiltering, bool bForceSystemLocale )
 136 {
 137     ScInterpreterContext& rContext = pContext ? *pContext : rDoc.GetNonThreadedContext();
 138
 139     switch (rCell.getType())
 140     {
 141         case CELLTYPE_STRING:
 142         case CELLTYPE_EDIT:
 143             return rCell.getString(&rDoc);
 144         case CELLTYPE_VALUE:
 145             return rContext.NFGetInputLineString(rCell.getDouble(), nFormat, bFiltering, bForceSystemLocale);
 146         break;
 147         case CELLTYPE_FORMULA:
 148         {
 149             std::optional<OUString> str;
 150             ScFormulaCell* pFC = rCell.getFormula();
 151             if (pFC->IsEmptyDisplayedAsString())
 152                 ; // empty
 153             else if (pFC->IsValue())
 154                 str = rContext.NFGetInputLineString(pFC->GetValue(), nFormat, bFiltering, bForceSystemLocale);
 155             else
 156                 str = pFC->GetString().getString();
 157
 158             const FormulaError nErrCode = pFC->GetErrCode();
 159             if (nErrCode != FormulaError::NONE)
 160                 str.reset();
 161
 162             return str ? std::move(*str) : svl::SharedString::EMPTY_STRING;
 163         }
 164         case CELLTYPE_NONE:
 165             return svl::SharedString::EMPTY_STRING;
 166         default:
 167             return svl::SharedString::EMPTY_STRING;
 168     }
 169 }
 170
 171 OUString ScCellFormat::GetOutputString( ScDocument& rDoc, const ScAddress& rPos, const ScRefCellValue& rCell )
 172 {
 173     if (rCell.isEmpty())
 174         return OUString();
 175
 176     if (rCell.getType() == CELLTYPE_EDIT)
 177     {
 178         //  GetString converts line breaks into spaces in EditCell,
 179         //  but here we need the line breaks
 180         const EditTextObject* pData = rCell.getEditText();
 181         if (pData)
 182         {
 183             ScFieldEditEngine& rEngine = rDoc.GetEditEngine();
 184             rEngine.SetTextCurrentDefaults(*pData);
 185             return rEngine.GetText();
 186         }
 187         //  also do not format EditCells as numbers
 188         //  (fitting to output)
 189         return OUString();
 190     }
 191     else
 192     {
 193         //  like in GetString for document (column)
 194         const Color* pColor;
 195         sal_uInt32 nNumFmt = rDoc.GetNumberFormat(ScRange(rPos));
 196         return GetString(rCell, nNumFmt, &pColor, nullptr, rDoc);
 197     }
 198 }
 199
 200 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */