sc/source/filter/oox/defnamesbuffer.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 <memory>
  21 #include <defnamesbuffer.hxx>
  22
  23 #include <com/sun/star/sheet/NamedRangeFlag.hpp>
  24 #include <com/sun/star/sheet/XPrintAreas.hpp>
  25 #include <osl/diagnose.h>
  26 #include <rtl/ustrbuf.hxx>
  27 #include <oox/helper/binaryinputstream.hxx>
  28 #include <oox/helper/attributelist.hxx>
  29 #include <oox/token/tokens.hxx>
  30 #include <addressconverter.hxx>
  31 #include <biffhelper.hxx>
  32 #include <externallinkbuffer.hxx>
  33 #include <formulabase.hxx>
  34 #include <formulaparser.hxx>
  35 #include <worksheetbuffer.hxx>
  36 #include <tokenarray.hxx>
  37 #include <tokenuno.hxx>
  38 #include <compiler.hxx>
  39 #include <document.hxx>
  40
  41 namespace oox {
  42 namespace xls {
  43
  44 using namespace ::com::sun::star::sheet;
  45 using namespace ::com::sun::star::table;
  46 using namespace ::com::sun::star::uno;
  47
  48 namespace {
  49
  50 const sal_uInt32 BIFF12_DEFNAME_HIDDEN      = 0x00000001;
  51 const sal_uInt32 BIFF12_DEFNAME_FUNC        = 0x00000002;
  52 const sal_uInt32 BIFF12_DEFNAME_VBNAME      = 0x00000004;
  53 const sal_uInt32 BIFF12_DEFNAME_MACRO       = 0x00000008;
  54 const sal_uInt32 BIFF12_DEFNAME_BUILTIN     = 0x00000020;
  55
  56 const OUStringLiteral spcOoxPrefix("_xlnm.");
  57
  58 const sal_Char* const sppcBaseNames[] =
  59 {
  60     "Consolidate_Area",
  61     "Auto_Open",
  62     "Auto_Close",
  63     "Extract",
  64     "Database",
  65     "Criteria",
  66     "Print_Area",
  67     "Print_Titles",
  68     "Recorder",
  69     "Data_Form",
  70     "Auto_Activate",
  71     "Auto_Deactivate",
  72     "Sheet_Title",
  73     "_FilterDatabase"
  74 };
  75
  76 OUString lclGetBaseName( sal_Unicode cBuiltinId )
  77 {
  78     OSL_ENSURE( cBuiltinId < SAL_N_ELEMENTS( sppcBaseNames ), "lclGetBaseName - unsupported built-in identifier" );
  79     OUStringBuffer aBuffer;
  80     if( cBuiltinId < SAL_N_ELEMENTS( sppcBaseNames ) )
  81         aBuffer.appendAscii( sppcBaseNames[ cBuiltinId ] );
  82     else
  83         aBuffer.append( static_cast< sal_Int32 >( cBuiltinId ) );
  84     return aBuffer.makeStringAndClear();
  85 }
  86
  87 OUString lclGetPrefixedName( sal_Unicode cBuiltinId )
  88 {
  89     return spcOoxPrefix + lclGetBaseName( cBuiltinId );
  90 }
  91
  92 /** returns the built-in name identifier from a prefixed built-in name, e.g. '_xlnm.Print_Area'. */
  93 sal_Unicode lclGetBuiltinIdFromPrefixedName( const OUString& rModelName )
  94 {
  95     if( rModelName.matchIgnoreAsciiCase( spcOoxPrefix ) )
  96     {
  97         for( sal_Unicode cBuiltinId = 0; cBuiltinId < SAL_N_ELEMENTS( sppcBaseNames ); ++cBuiltinId )
  98         {
  99             OUString aBaseName = lclGetBaseName( cBuiltinId );
 100             sal_Int32 nBaseNameLen = aBaseName.getLength();
 101             if( (rModelName.getLength() == spcOoxPrefix.size + nBaseNameLen) && rModelName.matchIgnoreAsciiCase( aBaseName, spcOoxPrefix.size ) )
 102                 return cBuiltinId;
 103         }
 104     }
 105     return BIFF_DEFNAME_UNKNOWN;
 106 }
 107
 108 /** returns the built-in name identifier from a built-in base name, e.g. 'Print_Area'. */
 109 sal_Unicode lclGetBuiltinIdFromBaseName( const OUString& rModelName )
 110 {
 111     for( sal_Unicode cBuiltinId = 0; cBuiltinId < SAL_N_ELEMENTS( sppcBaseNames ); ++cBuiltinId )
 112         if( rModelName.equalsIgnoreAsciiCaseAscii( sppcBaseNames[ cBuiltinId ] ) )
 113             return cBuiltinId;
 114     return BIFF_DEFNAME_UNKNOWN;
 115 }
 116
 117 OUString lclGetUpcaseModelName( const OUString& rModelName )
 118 {
 119     // TODO: i18n?
 120     return rModelName.toAsciiUpperCase();
 121 }
 122
 123 } // namespace
 124
 125 DefinedNameModel::DefinedNameModel() :
 126     mnSheet( -1 ),
 127     mnFuncGroupId( -1 ),
 128     mbMacro( false ),
 129     mbFunction( false ),
 130     mbVBName( false ),
 131     mbHidden( false )
 132 {
 133 }
 134
 135 DefinedNameBase::DefinedNameBase( const WorkbookHelper& rHelper ) :
 136     WorkbookHelper( rHelper )
 137 {
 138 }
 139
 140 const OUString& DefinedNameBase::getUpcaseModelName() const
 141 {
 142     if( maUpModelName.isEmpty() )
 143         maUpModelName = lclGetUpcaseModelName( maModel.maName );
 144     return maUpModelName;
 145 }
 146
 147 DefinedName::DefinedName( const WorkbookHelper& rHelper ) :
 148     DefinedNameBase( rHelper ),
 149     mpScRangeData(nullptr),
 150     mnTokenIndex( -1 ),
 151     mnCalcSheet( 0 ),
 152     mcBuiltinId( BIFF_DEFNAME_UNKNOWN )
 153 {
 154 }
 155
 156 void DefinedName::importDefinedName( const AttributeList& rAttribs )
 157 {
 158     maModel.maName        = rAttribs.getXString( XML_name, OUString() );
 159     maModel.mnSheet       = rAttribs.getInteger( XML_localSheetId, -1 );
 160     maModel.mnFuncGroupId = rAttribs.getInteger( XML_functionGroupId, -1 );
 161     maModel.mbMacro       = rAttribs.getBool( XML_xlm, false );
 162     maModel.mbFunction    = rAttribs.getBool( XML_function, false );
 163     maModel.mbVBName      = rAttribs.getBool( XML_vbProcedure, false );
 164     maModel.mbHidden      = rAttribs.getBool( XML_hidden, false );
 165     mnCalcSheet = (maModel.mnSheet >= 0) ? getWorksheets().getCalcSheetIndex( maModel.mnSheet ) : -1;
 166
 167     /*  Detect built-in state from name itself, there is no built-in flag.
 168         Built-in names are prefixed with '_xlnm.' instead. */
 169     mcBuiltinId = lclGetBuiltinIdFromPrefixedName( maModel.maName );
 170 }
 171
 172 void DefinedName::setFormula( const OUString& rFormula )
 173 {
 174     maModel.maFormula = rFormula;
 175 }
 176
 177 void DefinedName::importDefinedName( SequenceInputStream& rStrm )
 178 {
 179     sal_uInt32 nFlags;
 180     nFlags = rStrm.readuInt32();
 181     rStrm.skip( 1 );    // keyboard shortcut
 182     maModel.mnSheet = rStrm.readInt32();
 183     rStrm >> maModel.maName;
 184     mnCalcSheet = (maModel.mnSheet >= 0) ? getWorksheets().getCalcSheetIndex( maModel.mnSheet ) : -1;
 185
 186     // macro function/command, hidden flag
 187     maModel.mnFuncGroupId = extractValue< sal_Int32 >( nFlags, 6, 9 );
 188     maModel.mbMacro       = getFlag( nFlags, BIFF12_DEFNAME_MACRO );
 189     maModel.mbFunction    = getFlag( nFlags, BIFF12_DEFNAME_FUNC );
 190     maModel.mbVBName      = getFlag( nFlags, BIFF12_DEFNAME_VBNAME );
 191     maModel.mbHidden      = getFlag( nFlags, BIFF12_DEFNAME_HIDDEN );
 192
 193     // get built-in name index from name
 194     if( getFlag( nFlags, BIFF12_DEFNAME_BUILTIN ) )
 195         mcBuiltinId = lclGetBuiltinIdFromBaseName( maModel.maName );
 196
 197     // store token array data
 198     sal_Int64 nRecPos = rStrm.tell();
 199     sal_Int32 nFmlaSize = rStrm.readInt32();
 200     rStrm.skip( nFmlaSize );
 201     sal_Int32 nAddDataSize = rStrm.readInt32();
 202     if( !rStrm.isEof() && (nFmlaSize > 0) && (nAddDataSize >= 0) && (rStrm.getRemaining() >= nAddDataSize) )
 203     {
 204         sal_Int32 nTotalSize = 8 + nFmlaSize + nAddDataSize;
 205         mxFormula.reset( new StreamDataSequence );
 206         rStrm.seek( nRecPos );
 207         rStrm.readData( *mxFormula, nTotalSize );
 208     }
 209 }
 210
 211 void DefinedName::createNameObject( sal_Int32 nIndex )
 212 {
 213     // do not create names for (macro) functions or VBA procedures
 214     // #163146# do not ignore hidden names (may be regular names created by VBA scripts)
 215     if( /*maModel.mbHidden ||*/ maModel.mbFunction || maModel.mbVBName )
 216         return;
 217
 218     // convert original name to final Calc name (TODO: filter invalid characters from model name)
 219     maCalcName = isBuiltinName() ? lclGetPrefixedName( mcBuiltinId ) : maModel.maName;
 220
 221     // #163146# do not rename sheet-local names by default, this breaks VBA scripts
 222
 223     // special flags for this name
 224     sal_Int32 nNameFlags = 0;
 225     using namespace ::com::sun::star::sheet::NamedRangeFlag;
 226     if( !isGlobalName() ) switch( mcBuiltinId )
 227     {
 228         case BIFF_DEFNAME_CRITERIA:     nNameFlags = FILTER_CRITERIA;               break;
 229         case BIFF_DEFNAME_PRINTAREA:    nNameFlags = PRINT_AREA;                    break;
 230         case BIFF_DEFNAME_PRINTTITLES:  nNameFlags = COLUMN_HEADER | ROW_HEADER;    break;
 231     }
 232
 233     // create the name and insert it into the document, maCalcName will be changed to the resulting name
 234     if (maModel.mnSheet >= 0)
 235         mpScRangeData = createLocalNamedRangeObject( maCalcName, ApiTokenSequence(), nIndex, nNameFlags, maModel.mnSheet );
 236     else
 237         mpScRangeData = createNamedRangeObject( maCalcName, ApiTokenSequence(), nIndex, nNameFlags );
 238     mnTokenIndex = nIndex;
 239 }
 240
 241 std::unique_ptr<ScTokenArray> DefinedName::getScTokens(
 242         const css::uno::Sequence<css::sheet::ExternalLinkInfo>& rExternalLinks )
 243 {
 244     ScCompiler aCompiler(&getScDocument(), ScAddress(0, 0, mnCalcSheet), formula::FormulaGrammar::GRAM_OOXML);
 245     aCompiler.SetExternalLinks( rExternalLinks);
 246     std::unique_ptr<ScTokenArray> pArray(aCompiler.CompileString(maModel.maFormula));
 247     // Compile the tokens into RPN once to populate information into tokens
 248     // where necessary, e.g. for TableRef inner reference. RPN can be discarded
 249     // after, a resulting error must be reset.
 250     FormulaError nErr = pArray->GetCodeError();
 251     aCompiler.CompileTokenArray();
 252     getScDocument().CheckLinkFormulaNeedingCheck( *pArray);
 253     pArray->DelRPN();
 254     pArray->SetCodeError(nErr);
 255
 256     return pArray;
 257 }
 258
 259 void DefinedName::convertFormula( const css::uno::Sequence<css::sheet::ExternalLinkInfo>& rExternalLinks )
 260 {
 261     // macro function or vba procedure
 262     if(!mpScRangeData)
 263         return;
 264
 265     // convert and set formula of the defined name
 266     {
 267         std::unique_ptr<ScTokenArray> pTokenArray = getScTokens( rExternalLinks);
 268         mpScRangeData->SetCode( *pTokenArray );
 269     }
 270
 271     ScTokenArray* pTokenArray = mpScRangeData->GetCode();
 272     Sequence< FormulaToken > aFTokenSeq;
 273     ScTokenConversion::ConvertToTokenSequence( getScDocument(), aFTokenSeq, *pTokenArray );
 274     // set built-in names (print ranges, repeated titles, filter ranges)
 275     if( !isGlobalName() ) switch( mcBuiltinId )
 276     {
 277         case BIFF_DEFNAME_PRINTAREA:
 278         {
 279             Reference< XPrintAreas > xPrintAreas( getSheetFromDoc( mnCalcSheet ), UNO_QUERY );
 280             ScRangeList aPrintRanges;
 281             getFormulaParser().extractCellRangeList( aPrintRanges, aFTokenSeq, mnCalcSheet );
 282             if( xPrintAreas.is() && !aPrintRanges.empty() )
 283                 xPrintAreas->setPrintAreas( AddressConverter::toApiSequence(aPrintRanges) );
 284         }
 285         break;
 286         case BIFF_DEFNAME_PRINTTITLES:
 287         {
 288             Reference< XPrintAreas > xPrintAreas( getSheetFromDoc( mnCalcSheet ), UNO_QUERY );
 289             ScRangeList aTitleRanges;
 290             getFormulaParser().extractCellRangeList( aTitleRanges, aFTokenSeq, mnCalcSheet );
 291             if( xPrintAreas.is() && !aTitleRanges.empty() )
 292             {
 293                 bool bHasRowTitles = false;
 294                 bool bHasColTitles = false;
 295                 const ScAddress& rMaxPos = getAddressConverter().getMaxAddress();
 296                 for (size_t i = 0, nSize = aTitleRanges.size(); i < nSize; ++i)
 297                 {
 298                     const ScRange& rRange = aTitleRanges[i];
 299                     bool bFullRow = (rRange.aStart.Col() == 0) && ( rRange.aEnd.Col() >= rMaxPos.Col() );
 300                     bool bFullCol = (rRange.aStart.Row() == 0) && ( rRange.aEnd.Row() >= rMaxPos.Row() );
 301                     if( !bHasRowTitles && bFullRow && !bFullCol )
 302                     {
 303                         xPrintAreas->setTitleRows( CellRangeAddress(rRange.aStart.Tab(),
 304                                                                     rRange.aStart.Col(), rRange.aStart.Row(),
 305                                                                     rRange.aEnd.Col(), rRange.aEnd.Row()) );
 306                         xPrintAreas->setPrintTitleRows( true );
 307                         bHasRowTitles = true;
 308                     }
 309                     else if( !bHasColTitles && bFullCol && !bFullRow )
 310                     {
 311                         xPrintAreas->setTitleColumns( CellRangeAddress(rRange.aStart.Tab(),
 312                                                                        rRange.aStart.Col(), rRange.aStart.Row(),
 313                                                                        rRange.aEnd.Col(), rRange.aEnd.Row()) );
 314                         xPrintAreas->setPrintTitleColumns( true );
 315                         bHasColTitles = true;
 316                     }
 317                 }
 318             }
 319         }
 320         break;
 321     }
 322 }
 323
 324 bool DefinedName::getAbsoluteRange( ScRange& orRange ) const
 325 {
 326     ScTokenArray* pTokenArray = mpScRangeData->GetCode();
 327     Sequence< FormulaToken > aFTokenSeq;
 328     ScTokenConversion::ConvertToTokenSequence(getScDocument(), aFTokenSeq, *pTokenArray);
 329     return getFormulaParser().extractCellRange( orRange, aFTokenSeq );
 330 }
 331
 332
 333 DefinedNamesBuffer::DefinedNamesBuffer( const WorkbookHelper& rHelper ) :
 334     WorkbookHelper( rHelper )
 335 {
 336 }
 337
 338 DefinedNameRef DefinedNamesBuffer::importDefinedName( const AttributeList& rAttribs )
 339 {
 340     DefinedNameRef xDefName = createDefinedName();
 341     xDefName->importDefinedName( rAttribs );
 342     return xDefName;
 343 }
 344
 345 void DefinedNamesBuffer::importDefinedName( SequenceInputStream& rStrm )
 346 {
 347     createDefinedName()->importDefinedName( rStrm );
 348 }
 349
 350 void DefinedNamesBuffer::finalizeImport()
 351 {
 352     // first insert all names without formula definition into the document, and insert them into the maps
 353     int index = 0;
 354     for( DefinedNameRef& xDefName : maDefNames )
 355     {
 356         xDefName->createNameObject( ++index );
 357         // map by sheet index and original model name
 358         maModelNameMap[ SheetNameKey( xDefName->getLocalCalcSheet(), xDefName->getUpcaseModelName() ) ] = xDefName;
 359         // map by sheet index and built-in identifier
 360         if( !xDefName->isGlobalName() && xDefName->isBuiltinName() )
 361             maBuiltinMap[ BuiltinKey( xDefName->getLocalCalcSheet(), xDefName->getBuiltinId() ) ] = xDefName;
 362         // map by API formula token identifier
 363         sal_Int32 nTokenIndex = xDefName->getTokenIndex();
 364         if( nTokenIndex >= 0 )
 365             maTokenIdMap[ nTokenIndex ] = xDefName;
 366     }
 367
 368     /*  Now convert all name formulas, so that the formula parser can find all
 369         names in case of circular dependencies. */
 370     maDefNames.forEachMem( &DefinedName::convertFormula, getExternalLinks().getLinkInfos());
 371 }
 372
 373 DefinedNameRef DefinedNamesBuffer::getByIndex( sal_Int32 nIndex ) const
 374 {
 375     return maDefNames.get( nIndex );
 376 }
 377
 378 DefinedNameRef DefinedNamesBuffer::getByTokenIndex( sal_Int32 nIndex ) const
 379 {
 380     return maTokenIdMap.get( nIndex );
 381 }
 382
 383 DefinedNameRef DefinedNamesBuffer::getByModelName( const OUString& rModelName, sal_Int16 nCalcSheet ) const
 384 {
 385     OUString aUpcaseName = lclGetUpcaseModelName( rModelName );
 386     DefinedNameRef xDefName = maModelNameMap.get( SheetNameKey( nCalcSheet, aUpcaseName ) );
 387     // lookup global name, if no local name exists
 388     if( !xDefName && (nCalcSheet >= 0) )
 389         xDefName = maModelNameMap.get( SheetNameKey( -1, aUpcaseName ) );
 390     return xDefName;
 391 }
 392
 393 DefinedNameRef DefinedNamesBuffer::getByBuiltinId( sal_Unicode cBuiltinId, sal_Int16 nCalcSheet ) const
 394 {
 395     return maBuiltinMap.get( BuiltinKey( nCalcSheet, cBuiltinId ) );
 396 }
 397
 398 DefinedNameRef DefinedNamesBuffer::createDefinedName()
 399 {
 400     DefinedNameRef xDefName( new DefinedName( *this ) );
 401     maDefNames.push_back( xDefName );
 402     return xDefName;
 403 }
 404
 405 } // namespace xls
 406 } // namespace oox
 407
 408 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */