sc/source/filter/xml/xmlexternaltabi.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 "xmlexternaltabi.hxx"
  21 #include "xmlimprt.hxx"
  22 #include "xmltabi.hxx"
  23 #include "xmlstyli.hxx"
  24
  25 #include <document.hxx>
  26 #include <documentimport.hxx>
  27
  28 #include <svl/sharedstringpool.hxx>
  29 #include <xmloff/xmlnmspe.hxx>
  30 #include <xmloff/xmltoken.hxx>
  31 #include <xmloff/xmluconv.hxx>
  32
  33 #include <sax/tools/converter.hxx>
  34
  35 #include <com/sun/star/util/NumberFormat.hpp>
  36
  37 using namespace ::com::sun::star;
  38 using namespace ::com::sun::star::xml::sax;
  39
  40 using ::com::sun::star::uno::Reference;
  41
  42 ScXMLExternalRefTabSourceContext::ScXMLExternalRefTabSourceContext(
  43     ScXMLImport& rImport,
  44     const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList, ScXMLExternalTabData& rRefInfo ) :
  45     ScXMLImportContext( rImport ),
  46     mrExternalRefInfo(rRefInfo)
  47 {
  48     using namespace ::xmloff::token;
  49
  50     if ( rAttrList.is() )
  51     {
  52         for (auto &it : *rAttrList)
  53         {
  54             sal_Int32 nAttrToken = it.getToken();
  55             if ( nAttrToken == XML_ELEMENT( XLINK, XML_HREF ) )
  56                 maRelativeUrl = it.toString();
  57             else if ( nAttrToken == XML_ELEMENT( TABLE, XML_TABLE_NAME ) )
  58                 // todo
  59                 ;
  60             else if ( nAttrToken == XML_ELEMENT( TABLE, XML_FILTER_NAME ) )
  61                 maFilterName = it.toString();
  62             else if ( nAttrToken == XML_ELEMENT( TABLE, XML_FILTER_OPTIONS ) )
  63                 maFilterOptions = it.toString();
  64         }
  65     }
  66 }
  67
  68 ScXMLExternalRefTabSourceContext::~ScXMLExternalRefTabSourceContext()
  69 {
  70 }
  71
  72 /**
  73  * Make sure the URL is a valid relative URL, mainly to avoid storing
  74  * absolute URL as relative URL by accident.  For now, we only check the first
  75  * three characters which are assumed to be always '../', because the relative
  76  * URL for an external document is always in reference to the content.xml
  77  * fragment of the original document.
  78  */
  79 static bool lcl_isValidRelativeURL(const OUString& rUrl)
  80 {
  81     sal_Int32 n = ::std::min( rUrl.getLength(), static_cast<sal_Int32>(3));
  82     if (n < 3)
  83         return false;
  84     const sal_Unicode* p = rUrl.getStr();
  85     for (sal_Int32 i = 0; i < n; ++i)
  86     {
  87         sal_Unicode c = p[i];
  88         if (i < 2 && c != '.')
  89             // the path must begin with '..'
  90             return false;
  91         else if (i == 2 && c != '/')
  92             // a '/' path separator must follow
  93             return false;
  94     }
  95     return true;
  96 }
  97
  98 void SAL_CALL ScXMLExternalRefTabSourceContext::endFastElement( sal_Int32 /*nElement*/ )
  99 {
 100     ScDocument* pDoc = GetScImport().GetDocument();
 101     if (!pDoc)
 102         return;
 103
 104     ScExternalRefManager* pRefMgr = pDoc->GetExternalRefManager();
 105     if (lcl_isValidRelativeURL(maRelativeUrl))
 106         pRefMgr->setRelativeFileName(mrExternalRefInfo.mnFileId, maRelativeUrl);
 107     pRefMgr->setFilterData(mrExternalRefInfo.mnFileId, maFilterName, maFilterOptions);
 108 }
 109
 110 ScXMLExternalRefRowsContext::ScXMLExternalRefRowsContext(
 111     ScXMLImport& rImport, ScXMLExternalTabData& rRefInfo ) :
 112     ScXMLImportContext( rImport ),
 113     mrExternalRefInfo(rRefInfo)
 114 {
 115 }
 116
 117 ScXMLExternalRefRowsContext::~ScXMLExternalRefRowsContext()
 118 {
 119 }
 120
 121 Reference< XFastContextHandler > SAL_CALL ScXMLExternalRefRowsContext::createFastChildContext(
 122     sal_Int32 nElement, const Reference< XFastAttributeList >& xAttrList )
 123 {
 124     // #i101319# row elements inside group, rows or header-rows
 125     // are treated like row elements directly in the table element
 126
 127     const SvXMLTokenMap& rTokenMap = GetScImport().GetTableRowsElemTokenMap();
 128     sal_uInt16 nToken = rTokenMap.Get( nElement );
 129     sax_fastparser::FastAttributeList *pAttribList =
 130         sax_fastparser::FastAttributeList::castToFastAttributeList( xAttrList );
 131
 132     switch (nToken)
 133     {
 134         case XML_TOK_TABLE_ROWS_ROW_GROUP:
 135         case XML_TOK_TABLE_ROWS_HEADER_ROWS:
 136         case XML_TOK_TABLE_ROWS_ROWS:
 137             return new ScXMLExternalRefRowsContext(
 138                 GetScImport(), mrExternalRefInfo);
 139         case XML_TOK_TABLE_ROWS_ROW:
 140             return new ScXMLExternalRefRowContext(
 141                 GetScImport(), pAttribList, mrExternalRefInfo);
 142         default:
 143             ;
 144     }
 145     return new SvXMLImportContext( GetImport() );
 146 }
 147
 148 ScXMLExternalRefRowContext::ScXMLExternalRefRowContext(
 149     ScXMLImport& rImport,
 150     const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList, ScXMLExternalTabData& rRefInfo ) :
 151     ScXMLImportContext( rImport ),
 152     mrScImport(rImport),
 153     mrExternalRefInfo(rRefInfo),
 154     mnRepeatRowCount(1)
 155 {
 156     mrExternalRefInfo.mnCol = 0;
 157
 158     const SvXMLTokenMap& rAttrTokenMap = mrScImport.GetTableRowAttrTokenMap();
 159     if ( rAttrList.is() )
 160     {
 161         for (auto &it : *rAttrList)
 162         {
 163             switch ( rAttrTokenMap.Get( it.getToken() ) )
 164             {
 165                 case XML_TOK_TABLE_ROW_ATTR_REPEATED:
 166                 {
 167                     mnRepeatRowCount = std::max(it.toInt32(), static_cast<sal_Int32>(1));
 168                 }
 169                 break;
 170             }
 171         }
 172     }
 173 }
 174
 175 ScXMLExternalRefRowContext::~ScXMLExternalRefRowContext()
 176 {
 177 }
 178
 179 Reference< XFastContextHandler > SAL_CALL ScXMLExternalRefRowContext::createFastChildContext(
 180     sal_Int32 nElement, const Reference< XFastAttributeList >& xAttrList )
 181 {
 182     const SvXMLTokenMap& rTokenMap = mrScImport.GetTableRowElemTokenMap();
 183     sal_uInt16 nToken = rTokenMap.Get( nElement );
 184     sax_fastparser::FastAttributeList *pAttribList =
 185         sax_fastparser::FastAttributeList::castToFastAttributeList( xAttrList );
 186
 187     if (nToken == XML_TOK_TABLE_ROW_CELL || nToken == XML_TOK_TABLE_ROW_COVERED_CELL)
 188         return new ScXMLExternalRefCellContext(mrScImport, pAttribList, mrExternalRefInfo);
 189
 190     return new SvXMLImportContext( GetImport() );
 191 }
 192
 193 void SAL_CALL ScXMLExternalRefRowContext::endFastElement( sal_Int32 /* nElement */ )
 194 {
 195     ScExternalRefCache::TableTypeRef pTab = mrExternalRefInfo.mpCacheTable;
 196
 197     for (sal_Int32 i = 1; i < mnRepeatRowCount; ++i)
 198     {
 199         // Performance: duplicates of a non-existent row will still not exist.
 200         // Don't find that out for every cell.
 201         // External references often are a sparse matrix.
 202         if (i == 1 && !pTab->hasRow( mrExternalRefInfo.mnRow))
 203         {
 204             mrExternalRefInfo.mnRow += mnRepeatRowCount;
 205             return;
 206         }
 207
 208         for (sal_Int32 j = 0; j < mrExternalRefInfo.mnCol; ++j)
 209         {
 210             ScExternalRefCache::TokenRef pToken = pTab->getCell(
 211                 static_cast<SCCOL>(j), static_cast<SCROW>(mrExternalRefInfo.mnRow));
 212
 213             if (pToken.get())
 214             {
 215                 pTab->setCell(static_cast<SCCOL>(j),
 216                               static_cast<SCROW>(mrExternalRefInfo.mnRow+i), pToken);
 217             }
 218         }
 219     }
 220     mrExternalRefInfo.mnRow += mnRepeatRowCount;
 221 }
 222
 223 ScXMLExternalRefCellContext::ScXMLExternalRefCellContext(
 224     ScXMLImport& rImport,
 225     const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList, ScXMLExternalTabData& rRefInfo ) :
 226     ScXMLImportContext( rImport ),
 227     mrScImport(rImport),
 228     mrExternalRefInfo(rRefInfo),
 229     mfCellValue(0.0),
 230     mnRepeatCount(1),
 231     mnNumberFormat(-1),
 232     mnCellType(css::util::NumberFormat::UNDEFINED),
 233     mbIsNumeric(false),
 234     mbIsEmpty(true)
 235 {
 236     using namespace ::xmloff::token;
 237
 238     const SvXMLTokenMap& rTokenMap = rImport.GetTableRowCellAttrTokenMap();
 239     if ( rAttrList.is() )
 240     {
 241         for (auto &it : *rAttrList)
 242         {
 243             switch ( rTokenMap.Get( it.getToken() ) )
 244             {
 245                 case XML_TOK_TABLE_ROW_CELL_ATTR_STYLE_NAME:
 246                 {
 247                     XMLTableStylesContext* pStyles = static_cast<XMLTableStylesContext*>(mrScImport.GetAutoStyles());
 248                     const XMLTableStyleContext* pStyle = static_cast<const XMLTableStyleContext*>(
 249                         pStyles->FindStyleChildContext(XML_STYLE_FAMILY_TABLE_CELL, it.toString(), true));
 250                     if (pStyle)
 251                         mnNumberFormat = const_cast<XMLTableStyleContext*>(pStyle)->GetNumberFormat();
 252                 }
 253                 break;
 254                 case XML_TOK_TABLE_ROW_CELL_ATTR_REPEATED:
 255                 {
 256                     mnRepeatCount = ::std::max( it.toInt32(), static_cast<sal_Int32>(1) );
 257                 }
 258                 break;
 259                 case XML_TOK_TABLE_ROW_CELL_ATTR_VALUE_TYPE:
 260                 {
 261                     mnCellType = ScXMLImport::GetCellType( it.toCString(), it.getLength() );
 262                 }
 263                 break;
 264                 case XML_TOK_TABLE_ROW_CELL_ATTR_VALUE:
 265                 {
 266                     if ( !it.isEmpty() )
 267                     {
 268                         mfCellValue = it.toDouble();
 269                         mbIsNumeric = true;
 270                         mbIsEmpty = false;
 271                     }
 272                 }
 273                 break;
 274                 case XML_TOK_TABLE_ROW_CELL_ATTR_DATE_VALUE:
 275                 {
 276                     if ( !it.isEmpty() && mrScImport.SetNullDateOnUnitConverter() )
 277                     {
 278                         mrScImport.GetMM100UnitConverter().convertDateTime( mfCellValue, it.toString() );
 279                         mbIsNumeric = true;
 280                         mbIsEmpty = false;
 281                     }
 282                 }
 283                 break;
 284                 case XML_TOK_TABLE_ROW_CELL_ATTR_TIME_VALUE:
 285                 {
 286                     if ( !it.isEmpty() )
 287                     {
 288                         ::sax::Converter::convertDuration( mfCellValue, it.toString() );
 289                         mbIsNumeric = true;
 290                         mbIsEmpty = false;
 291                     }
 292                 }
 293                 break;
 294                 case XML_TOK_TABLE_ROW_CELL_ATTR_STRING_VALUE:
 295                 {
 296                     if ( !it.isEmpty() )
 297                     {
 298                         maCellString = it.toString();
 299                         mbIsNumeric = false;
 300                         mbIsEmpty = false;
 301                     }
 302                 }
 303                 break;
 304                 case XML_TOK_TABLE_ROW_CELL_ATTR_BOOLEAN_VALUE:
 305                 {
 306                     if ( !it.isEmpty() )
 307                     {
 308                         mfCellValue = IsXMLToken( it, XML_TRUE ) ? 1.0 : 0.0;
 309                         mbIsNumeric = true;
 310                         mbIsEmpty = false;
 311                     }
 312                 }
 313                 break;
 314                 default:
 315                     ;
 316             }
 317         }
 318     }
 319 }
 320
 321 ScXMLExternalRefCellContext::~ScXMLExternalRefCellContext()
 322 {
 323 }
 324
 325 Reference< XFastContextHandler > SAL_CALL ScXMLExternalRefCellContext::createFastChildContext(
 326     sal_Int32 nElement, const Reference< XFastAttributeList >& /*xAttrList*/ )
 327 {
 328     const SvXMLTokenMap& rTokenMap = mrScImport.GetTableRowCellElemTokenMap();
 329     sal_uInt16 nToken = rTokenMap.Get( nElement );
 330
 331     if (nToken == XML_TOK_TABLE_ROW_CELL_P)
 332         return new ScXMLExternalRefCellTextContext(mrScImport, *this);
 333
 334     return new SvXMLImportContext( GetImport() );
 335 }
 336
 337 void SAL_CALL ScXMLExternalRefCellContext::endFastElement( sal_Int32 /*nElement*/ )
 338 {
 339     if (!maCellString.isEmpty())
 340         mbIsEmpty = false;
 341
 342     for (sal_Int32 i = 0; i < mnRepeatCount; ++i, ++mrExternalRefInfo.mnCol)
 343     {
 344         if (mbIsEmpty)
 345             continue;
 346
 347         ScExternalRefCache::TokenRef aToken;
 348         if (mbIsNumeric)
 349             aToken.reset(new formula::FormulaDoubleToken(mfCellValue));
 350         else
 351         {
 352             ScDocument& rDoc = mrScImport.GetDoc().getDoc();
 353             svl::SharedString aSS = rDoc.GetSharedStringPool().intern(maCellString);
 354             aToken.reset(new formula::FormulaStringToken(aSS));
 355         }
 356
 357         sal_uInt32 nNumFmt = mnNumberFormat >= 0 ? static_cast<sal_uInt32>(mnNumberFormat) : 0;
 358         mrExternalRefInfo.mpCacheTable->setCell(
 359             static_cast<SCCOL>(mrExternalRefInfo.mnCol),
 360             static_cast<SCROW>(mrExternalRefInfo.mnRow),
 361             aToken, nNumFmt);
 362     }
 363 }
 364
 365 void ScXMLExternalRefCellContext::SetCellString(const OUString& rStr)
 366 {
 367     maCellString = rStr;
 368 }
 369
 370 ScXMLExternalRefCellTextContext::ScXMLExternalRefCellTextContext(
 371     ScXMLImport& rImport,
 372     ScXMLExternalRefCellContext& rParent ) :
 373     ScXMLImportContext( rImport ),
 374     mrParent(rParent)
 375 {
 376 }
 377
 378 ScXMLExternalRefCellTextContext::~ScXMLExternalRefCellTextContext()
 379 {
 380 }
 381
 382 void SAL_CALL ScXMLExternalRefCellTextContext::characters( const OUString& rChars )
 383 {
 384     maCellStrBuf.append( rChars );
 385 }
 386
 387 void SAL_CALL ScXMLExternalRefCellTextContext::endFastElement( sal_Int32 /*nElement*/ )
 388 {
 389     mrParent.SetCellString( maCellStrBuf.makeStringAndClear() );
 390 }
 391
 392 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */