sc/source/filter/xml/xmldrani.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 "xmldrani.hxx"
  21 #include "xmlimprt.hxx"
  22 #include "xmlfilti.hxx"
  23 #include "xmlsorti.hxx"
  24 #include <document.hxx>
  25 #include <globalnames.hxx>
  26 #include <dbdata.hxx>
  27 #include <datauno.hxx>
  28 #include <attrib.hxx>
  29 #include <unonames.hxx>
  30 #include "XMLConverter.hxx"
  31 #include <rangeutl.hxx>
  32 #include <dputil.hxx>
  33 #include <sortparam.hxx>
  34
  35 #include <xmloff/xmltoken.hxx>
  36 #include <xmloff/xmlnamespace.hxx>
  37
  38 #include <sax/tools/converter.hxx>
  39
  40 #include <com/sun/star/sheet/DataImportMode.hpp>
  41 #include <com/sun/star/table/TableOrientation.hpp>
  42 #include <osl/diagnose.h>
  43 #include <o3tl/string_view.hxx>
  44
  45 #include <memory>
  46
  47 using namespace com::sun::star;
  48 using namespace xmloff::token;
  49
  50 ScXMLDatabaseRangesContext::ScXMLDatabaseRangesContext( ScXMLImport& rImport ) :
  51     ScXMLImportContext( rImport )
  52 {
  53     // has no attributes
  54     rImport.LockSolarMutex();
  55 }
  56
  57 ScXMLDatabaseRangesContext::~ScXMLDatabaseRangesContext()
  58 {
  59     GetScImport().UnlockSolarMutex();
  60 }
  61
  62 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL ScXMLDatabaseRangesContext::createFastChildContext(
  63                                       sal_Int32 nElement,
  64                                       const uno::Reference< xml::sax::XFastAttributeList >& xAttrList )
  65 {
  66     SvXMLImportContext *pContext = nullptr;
  67     sax_fastparser::FastAttributeList *pAttribList =
  68         &sax_fastparser::castToFastAttributeList( xAttrList );
  69
  70     switch( nElement )
  71     {
  72         case XML_ELEMENT( TABLE, XML_DATABASE_RANGE ):
  73         {
  74             pContext = new ScXMLDatabaseRangeContext( GetScImport(), pAttribList );
  75         }
  76         break;
  77     }
  78
  79     return pContext;
  80 }
  81
  82 ScXMLDatabaseRangeContext::ScXMLDatabaseRangeContext( ScXMLImport& rImport,
  83                                       const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList ) :
  84     ScXMLImportContext( rImport ),
  85     mpQueryParam(new ScQueryParam),
  86     sDatabaseRangeName(STR_DB_LOCAL_NONAME),
  87     nSourceType(sheet::DataImportMode_NONE),
  88     nRefresh(0),
  89     nSubTotalsUserListIndex(0),
  90     mbValidRange(true),
  91     bContainsSort(false),
  92     bContainsSubTotal(false),
  93     bNative(true),
  94     bIsSelection(false),
  95     bKeepFormats(false),
  96     bMoveCells(false),
  97     bStripData(false),
  98     bAutoFilter(false),
  99     bSubTotalsBindFormatsToContent(false),
 100     bSubTotalsIsCaseSensitive(false),
 101     bSubTotalsInsertPageBreaks(false),
 102     bSubTotalsSummaryBelow(true),
 103     bSubTotalsSortGroups(false),
 104     bSubTotalsEnabledUserList(false),
 105     bSubTotalsAscending(true),
 106     bFilterConditionSourceRange(false),
 107     bHasHeader(true),
 108     bHasFooter(false),
 109     bByRow(true),
 110     meRangeType(ScDBCollection::GlobalNamed)
 111 {
 112     if( rAttrList.is() )
 113     {
 114         for( auto &aIter : *rAttrList )
 115         {
 116             switch( aIter.getToken() )
 117             {
 118                 case XML_ELEMENT( TABLE, XML_NAME ):
 119                 {
 120                     sDatabaseRangeName = aIter.toString();
 121                 }
 122                 break;
 123                 case XML_ELEMENT( TABLE, XML_IS_SELECTION ):
 124                 {
 125                     bIsSelection = IsXMLToken( aIter, XML_TRUE );
 126                 }
 127                 break;
 128                 case XML_ELEMENT( TABLE, XML_ON_UPDATE_KEEP_STYLES ):
 129                 {
 130                     bKeepFormats = IsXMLToken( aIter, XML_TRUE );
 131                 }
 132                 break;
 133                 case XML_ELEMENT( TABLE, XML_ON_UPDATE_KEEP_SIZE ):
 134                 {
 135                     bMoveCells = !IsXMLToken( aIter, XML_TRUE );
 136                 }
 137                 break;
 138                 case XML_ELEMENT( TABLE, XML_HAS_PERSISTENT_DATA ):
 139                 {
 140                     bStripData = !IsXMLToken( aIter, XML_TRUE );
 141                 }
 142                 break;
 143                 case XML_ELEMENT( TABLE, XML_ORIENTATION ):
 144                 {
 145                     bByRow = !IsXMLToken( aIter, XML_COLUMN );
 146                     mpQueryParam->bByRow = bByRow;
 147                 }
 148                 break;
 149                 case XML_ELEMENT( TABLE, XML_CONTAINS_HEADER ):
 150                 {
 151                     bHasHeader = IsXMLToken( aIter, XML_TRUE );
 152                     mpQueryParam->bHasHeader = bHasHeader;
 153                 }
 154                 break;
 155                 case XML_ELEMENT( TABLE, XML_CONTAINS_FOOTER ):
 156                 case XML_ELEMENT( CALC_EXT, XML_CONTAINS_FOOTER ):
 157                 {
 158                     bHasFooter = IsXMLToken( aIter, XML_TRUE );
 159                     mpQueryParam->bHasTotals = bHasFooter;
 160                 }
 161                 break;
 162                 case XML_ELEMENT( TABLE, XML_DISPLAY_FILTER_BUTTONS ):
 163                 {
 164                     bAutoFilter = IsXMLToken( aIter, XML_TRUE );
 165                 }
 166                 break;
 167                 case XML_ELEMENT( TABLE, XML_TARGET_RANGE_ADDRESS ):
 168                 {
 169                     ScDocument* pDoc = GetScImport().GetDocument();
 170                     assert(pDoc);
 171                     sal_Int32 nOffset = 0;
 172                     if (!ScRangeStringConverter::GetRangeFromString(
 173                         maRange, aIter.toString(), *pDoc, ::formula::FormulaGrammar::CONV_OOO, nOffset))
 174                         mbValidRange = false;
 175                 }
 176                 break;
 177                 case XML_ELEMENT( TABLE, XML_REFRESH_DELAY ):
 178                 {
 179                     double fTime;
 180                     if (::sax::Converter::convertDuration( fTime, aIter.toView() ))
 181                         nRefresh = std::max( static_cast<sal_Int32>(fTime * 86400.0), sal_Int32(0) );
 182                 }
 183                 break;
 184             }
 185         }
 186     }
 187
 188     mpQueryParam->nTab = maRange.aStart.Tab();
 189     mpQueryParam->nCol1 = maRange.aStart.Col();
 190     mpQueryParam->nRow1 = maRange.aStart.Row();
 191     mpQueryParam->nCol2 = maRange.aEnd.Col();
 192     mpQueryParam->nRow2 = maRange.aEnd.Row();
 193
 194     if (sDatabaseRangeName.startsWith(STR_DB_LOCAL_NONAME))
 195         meRangeType = ScDBCollection::SheetAnonymous;
 196     else if (sDatabaseRangeName.startsWith(STR_DB_GLOBAL_NONAME))
 197         meRangeType = ScDBCollection::GlobalAnonymous;
 198 }
 199
 200 ScXMLDatabaseRangeContext::~ScXMLDatabaseRangeContext()
 201 {
 202 }
 203
 204 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL ScXMLDatabaseRangeContext::createFastChildContext(
 205     sal_Int32 nElement, const uno::Reference< xml::sax::XFastAttributeList >& xAttrList )
 206 {
 207     SvXMLImportContext *pContext = nullptr;
 208     sax_fastparser::FastAttributeList *pAttribList =
 209         &sax_fastparser::castToFastAttributeList( xAttrList );
 210
 211     switch (nElement)
 212     {
 213         case XML_ELEMENT( TABLE, XML_DATABASE_SOURCE_SQL ):
 214         {
 215             pContext = new ScXMLSourceSQLContext( GetScImport(), pAttribList, this);
 216         }
 217         break;
 218         case XML_ELEMENT( TABLE, XML_DATABASE_SOURCE_TABLE ):
 219         {
 220             pContext = new ScXMLSourceTableContext( GetScImport(), pAttribList, this);
 221         }
 222         break;
 223         case XML_ELEMENT( TABLE, XML_DATABASE_SOURCE_QUERY ):
 224         {
 225             pContext = new ScXMLSourceQueryContext( GetScImport(), pAttribList, this);
 226         }
 227         break;
 228         case XML_ELEMENT( TABLE, XML_FILTER ):
 229         {
 230             pContext = new ScXMLFilterContext(
 231                 GetScImport(), pAttribList, *mpQueryParam, this);
 232         }
 233         break;
 234         case XML_ELEMENT( TABLE, XML_SORT ):
 235         {
 236             bContainsSort = true;
 237             pContext = new ScXMLSortContext( GetScImport(), pAttribList, this);
 238         }
 239         break;
 240         case XML_ELEMENT( TABLE, XML_SUBTOTAL_RULES ):
 241         {
 242             bContainsSubTotal = true;
 243             pContext = new ScXMLSubTotalRulesContext( GetScImport(), pAttribList, this);
 244         }
 245         break;
 246     }
 247
 248     return pContext;
 249 }
 250
 251 std::unique_ptr<ScDBData> ScXMLDatabaseRangeContext::ConvertToDBData(const OUString& rName)
 252 {
 253     if (!mbValidRange)
 254         return nullptr;
 255
 256     ScDocument* pDoc = GetScImport().GetDocument();
 257
 258     ::std::unique_ptr<ScDBData> pData(
 259         new ScDBData(rName, maRange.aStart.Tab(), maRange.aStart.Col(), maRange.aStart.Row(), maRange.aEnd.Col(), maRange.aEnd.Row(), bByRow, bHasHeader, bHasFooter));
 260
 261     pData->SetAutoFilter(bAutoFilter);
 262     pData->SetKeepFmt(bKeepFormats);
 263     pData->SetDoSize(bMoveCells);
 264     pData->SetStripData(bStripData);
 265
 266     pDoc->PrepareQuery(mpQueryParam->nTab, *mpQueryParam);
 267
 268     pData->SetQueryParam(*mpQueryParam);
 269
 270     if (bFilterConditionSourceRange)
 271     {
 272         pData->SetAdvancedQuerySource( &aFilterConditionSourceRangeAddress );
 273     }
 274
 275     {
 276         ScImportParam aParam;
 277         aParam.bNative = bNative;
 278         aParam.aDBName = sDatabaseName.isEmpty() ? sConnectionResource : sDatabaseName;
 279         aParam.aStatement = sSourceObject;
 280         switch (nSourceType)
 281         {
 282             case sheet::DataImportMode_NONE:
 283                 aParam.bImport = false;
 284                 break;
 285             case sheet::DataImportMode_SQL:
 286                 aParam.bImport = true;
 287                 aParam.bSql    = true;
 288                 break;
 289             case sheet::DataImportMode_TABLE:
 290                 aParam.bImport = true;
 291                 aParam.bSql    = false;
 292                 aParam.nType   = ScDbTable;
 293                 break;
 294             case sheet::DataImportMode_QUERY:
 295                 aParam.bImport = true;
 296                 aParam.bSql    = false;
 297                 aParam.nType   = ScDbQuery;
 298                 break;
 299             default:
 300                 OSL_FAIL("Unknown data import mode");
 301                 aParam.bImport = false;
 302         }
 303         pData->SetImportParam(aParam);
 304     }
 305
 306     if (bContainsSort)
 307     {
 308         size_t nOldSize = aSortSequence.getLength();
 309         aSortSequence.realloc(nOldSize + 1);
 310         beans::PropertyValue aProperty;
 311         aProperty.Name = SC_UNONAME_ORIENT;
 312         table::TableOrientation eOrient = mpQueryParam->bByRow ?
 313             table::TableOrientation_ROWS : table::TableOrientation_COLUMNS;
 314         aProperty.Value <<= eOrient;
 315         aSortSequence.getArray()[nOldSize] = std::move(aProperty);
 316         ScSortParam aParam;
 317         ScSortDescriptor::FillSortParam(aParam, aSortSequence);
 318
 319         SCCOLROW nStartPos = aParam.bByRow ? maRange.aStart.Col() : maRange.aStart.Row();
 320         for (size_t i = 0; i < aParam.GetSortKeyCount(); ++i)
 321         {
 322             if (!aParam.maKeyState[i].bDoSort)
 323                 break;
 324             aParam.maKeyState[i].nField += nStartPos;
 325         }
 326
 327         pData->SetSortParam(aParam);
 328     }
 329
 330     if (bContainsSubTotal)
 331     {
 332         ScSubTotalParam aParam;
 333         aParam.bIncludePattern = bSubTotalsBindFormatsToContent;
 334         aParam.bUserDef = bSubTotalsEnabledUserList;
 335         aParam.nUserIndex = nSubTotalsUserListIndex;
 336         aParam.bPagebreak = bSubTotalsInsertPageBreaks;
 337         aParam.bSummaryBelow = bSubTotalsSummaryBelow;
 338         aParam.bCaseSens = bSubTotalsIsCaseSensitive;
 339         aParam.bDoSort = bSubTotalsSortGroups;
 340         aParam.bAscending = bSubTotalsAscending;
 341         size_t nPos = 0;
 342         for (const auto& rSubTotalRule : aSubTotalRules)
 343         {
 344             if (nPos >= MAXSUBTOTAL)
 345                 break;
 346             auto& group = aParam.aGroups[nPos];
 347
 348             const uno::Sequence<sheet::SubTotalColumn>& rColumns = rSubTotalRule.aSubTotalColumns;
 349             sal_Int16 nGroupColumn = rSubTotalRule.nSubTotalRuleGroupFieldNumber;
 350             group.bActive = true;
 351             group.nField = static_cast<SCCOL>(nGroupColumn);
 352
 353             group.SetSubtotals(rColumns);
 354             ++nPos;
 355         }
 356
 357         pData->SetSubTotalParam(aParam);
 358     }
 359
 360     if (pData->HasImportParam() && !pData->HasImportSelection())
 361     {
 362         pData->SetRefreshDelay(nRefresh);
 363         pData->SetRefreshHandler(pDoc->GetDBCollection()->GetRefreshHandler());
 364         pData->SetRefreshControl(&pDoc->GetRefreshTimerControlAddress());
 365     }
 366
 367     return pData;
 368 }
 369
 370 namespace {
 371
 372 bool setAutoFilterFlags(ScDocument& rDoc, const ScDBData& rData)
 373 {
 374     if (!rData.HasAutoFilter())
 375         return false;
 376
 377     // Set autofilter flags so that the buttons get displayed.
 378     ScRange aRange;
 379     rData.GetArea(aRange);
 380     rDoc.ApplyFlagsTab(
 381         aRange.aStart.Col(), aRange.aStart.Row(), aRange.aEnd.Col(), aRange.aStart.Row(),
 382         aRange.aStart.Tab(), ScMF::Auto);
 383     return false;
 384 }
 385
 386 }
 387
 388 void SAL_CALL ScXMLDatabaseRangeContext::endFastElement( sal_Int32 /*nElement*/ )
 389 {
 390     ScDocument* pDoc = GetScImport().GetDocument();
 391     if (!pDoc)
 392         return;
 393
 394     if (meRangeType == ScDBCollection::SheetAnonymous)
 395     {
 396         ::std::unique_ptr<ScDBData> pData(ConvertToDBData(STR_DB_LOCAL_NONAME));
 397
 398         if (pData)
 399         {
 400             ScRange aRange;
 401             pData->GetArea(aRange);
 402
 403             setAutoFilterFlags(*pDoc, *pData);
 404             pDoc->SetAnonymousDBData(aRange.aStart.Tab(), std::move(pData));
 405         }
 406         return;
 407     }
 408     else if (meRangeType == ScDBCollection::GlobalAnonymous)
 409     {
 410         ::std::unique_ptr<ScDBData> pData(ConvertToDBData(STR_DB_GLOBAL_NONAME));
 411
 412         if (pData)
 413         {
 414             ScRange aRange;
 415             pData->GetArea(aRange);
 416
 417             if (setAutoFilterFlags(*pDoc, *pData))
 418                 pDoc->SetAnonymousDBData(aRange.aStart.Tab(), std::move(pData));
 419             else
 420                 pDoc->GetDBCollection()->getAnonDBs().insert(pData.release());
 421         }
 422         return;
 423     }
 424     else if (meRangeType == ScDBCollection::GlobalNamed)
 425     {
 426         ::std::unique_ptr<ScDBData> pData(ConvertToDBData(sDatabaseRangeName));
 427
 428         if (pData)
 429         {
 430             setAutoFilterFlags(*pDoc, *pData);
 431             (void)pDoc->GetDBCollection()->getNamedDBs().insert(std::move(pData));
 432         }
 433     }
 434 }
 435
 436 ScXMLSourceSQLContext::ScXMLSourceSQLContext( ScXMLImport& rImport,
 437                                       const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
 438                                       ScXMLDatabaseRangeContext* pTempDatabaseRangeContext) :
 439     ScXMLImportContext( rImport ),
 440     pDatabaseRangeContext(pTempDatabaseRangeContext)
 441 {
 442     if ( rAttrList.is() )
 443     {
 444         for (auto &aIter : *rAttrList)
 445         {
 446             switch (aIter.getToken())
 447             {
 448                 case XML_ELEMENT( TABLE, XML_DATABASE_NAME ):
 449                     sDBName = aIter.toString();
 450                     break;
 451                 case XML_ELEMENT( TABLE, XML_SQL_STATEMENT ):
 452                     pDatabaseRangeContext->SetSourceObject(aIter.toString());
 453                     break;
 454                 case XML_ELEMENT( TABLE, XML_PARSE_SQL_STATEMENT ):
 455                     pDatabaseRangeContext->SetNative(IsXMLToken(aIter, XML_TRUE));
 456                     break;
 457             }
 458         }
 459     }
 460     pDatabaseRangeContext->SetSourceType(sheet::DataImportMode_SQL);
 461 }
 462
 463 ScXMLSourceSQLContext::~ScXMLSourceSQLContext()
 464 {
 465 }
 466
 467 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL ScXMLSourceSQLContext::createFastChildContext(
 468     sal_Int32 nElement, const uno::Reference< xml::sax::XFastAttributeList >& xAttrList )
 469 {
 470     SvXMLImportContext *pContext = nullptr;
 471     sax_fastparser::FastAttributeList *pAttribList =
 472         &sax_fastparser::castToFastAttributeList( xAttrList );
 473
 474     if ( nElement == XML_ELEMENT( FORM, XML_CONNECTION_RESOURCE ) && sDBName.isEmpty() )
 475     {
 476         pContext = new ScXMLConResContext( GetScImport(), pAttribList, pDatabaseRangeContext);
 477     }
 478
 479     return pContext;
 480 }
 481
 482 void SAL_CALL ScXMLSourceSQLContext::endFastElement( sal_Int32 /*nElement*/ )
 483 {
 484     if (!sDBName.isEmpty())
 485         pDatabaseRangeContext->SetDatabaseName(sDBName);
 486 }
 487
 488 ScXMLSourceTableContext::ScXMLSourceTableContext( ScXMLImport& rImport,
 489                                       const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
 490                                       ScXMLDatabaseRangeContext* pTempDatabaseRangeContext) :
 491     ScXMLImportContext( rImport ),
 492     pDatabaseRangeContext(pTempDatabaseRangeContext)
 493 {
 494     if ( rAttrList.is() )
 495     {
 496         for (auto &aIter : *rAttrList)
 497         {
 498             switch (aIter.getToken())
 499             {
 500                 case XML_ELEMENT( TABLE, XML_DATABASE_NAME ):
 501                     sDBName = aIter.toString();
 502                     break;
 503                 case XML_ELEMENT( TABLE, XML_TABLE_NAME ):
 504                 case XML_ELEMENT( TABLE, XML_DATABASE_TABLE_NAME ):
 505                     pDatabaseRangeContext->SetSourceObject(aIter.toString());
 506                     break;
 507             }
 508         }
 509     }
 510     pDatabaseRangeContext->SetSourceType(sheet::DataImportMode_TABLE);
 511 }
 512
 513 ScXMLSourceTableContext::~ScXMLSourceTableContext()
 514 {
 515 }
 516
 517 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL ScXMLSourceTableContext::createFastChildContext(
 518     sal_Int32 nElement, const uno::Reference< xml::sax::XFastAttributeList >& xAttrList )
 519 {
 520     SvXMLImportContext *pContext = nullptr;
 521     sax_fastparser::FastAttributeList *pAttribList =
 522         &sax_fastparser::castToFastAttributeList( xAttrList );
 523
 524     if ( nElement == XML_ELEMENT( FORM, XML_CONNECTION_RESOURCE ) && sDBName.isEmpty() )
 525     {
 526         pContext = new ScXMLConResContext( GetScImport(), pAttribList, pDatabaseRangeContext);
 527     }
 528
 529     return pContext;
 530 }
 531
 532 void SAL_CALL ScXMLSourceTableContext::endFastElement( sal_Int32 /*nElement*/ )
 533 {
 534     if (!sDBName.isEmpty())
 535         pDatabaseRangeContext->SetDatabaseName(sDBName);
 536 }
 537
 538 ScXMLSourceQueryContext::ScXMLSourceQueryContext( ScXMLImport& rImport,
 539                                       const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
 540                                       ScXMLDatabaseRangeContext* pTempDatabaseRangeContext) :
 541     ScXMLImportContext( rImport ),
 542     pDatabaseRangeContext(pTempDatabaseRangeContext)
 543 {
 544     if ( rAttrList.is() )
 545     {
 546         for (auto &aIter : *rAttrList)
 547         {
 548             switch (aIter.getToken())
 549             {
 550                 case XML_ELEMENT( TABLE, XML_DATABASE_NAME ):
 551                     sDBName = aIter.toString();
 552                     break;
 553                 case XML_ELEMENT( TABLE, XML_QUERY_NAME ):
 554                     pDatabaseRangeContext->SetSourceObject(aIter.toString());
 555                     break;
 556             }
 557         }
 558     }
 559     pDatabaseRangeContext->SetSourceType(sheet::DataImportMode_QUERY);
 560 }
 561
 562 ScXMLSourceQueryContext::~ScXMLSourceQueryContext()
 563 {
 564 }
 565
 566 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL ScXMLSourceQueryContext::createFastChildContext(
 567     sal_Int32 nElement, const uno::Reference< xml::sax::XFastAttributeList >& xAttrList )
 568 {
 569     SvXMLImportContext *pContext = nullptr;
 570     sax_fastparser::FastAttributeList *pAttribList =
 571         &sax_fastparser::castToFastAttributeList( xAttrList );
 572
 573     if ( nElement == XML_ELEMENT( FORM, XML_CONNECTION_RESOURCE ) && sDBName.isEmpty() )
 574     {
 575         pContext = new ScXMLConResContext( GetScImport(), pAttribList, pDatabaseRangeContext);
 576     }
 577
 578     return pContext;
 579 }
 580
 581 void SAL_CALL ScXMLSourceQueryContext::endFastElement( sal_Int32 /*nElement*/ )
 582 {
 583     if (!sDBName.isEmpty())
 584         pDatabaseRangeContext->SetDatabaseName(sDBName);
 585 }
 586
 587 ScXMLConResContext::ScXMLConResContext( ScXMLImport& rImport,
 588                                       const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
 589                                       ScXMLDatabaseRangeContext* pDatabaseRangeContext) :
 590     ScXMLImportContext( rImport )
 591 {
 592     OUString sConRes;
 593     if ( rAttrList.is() )
 594     {
 595         auto aIter( rAttrList->find( XML_ELEMENT( XLINK, XML_HREF ) ) );
 596         if (aIter != rAttrList->end())
 597             sConRes = aIter.toString();
 598     }
 599     if (!sConRes.isEmpty())
 600         pDatabaseRangeContext->SetConnectionResource(sConRes);
 601 }
 602
 603 ScXMLConResContext::~ScXMLConResContext()
 604 {
 605 }
 606
 607 ScXMLSubTotalRulesContext::ScXMLSubTotalRulesContext( ScXMLImport& rImport,
 608                                       const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
 609                                       ScXMLDatabaseRangeContext* pTempDatabaseRangeContext) :
 610     ScXMLImportContext( rImport ),
 611     pDatabaseRangeContext(pTempDatabaseRangeContext)
 612 {
 613     if ( !rAttrList.is() )
 614         return;
 615
 616     for (auto &aIter : *rAttrList)
 617     {
 618         switch (aIter.getToken())
 619         {
 620             case XML_ELEMENT( TABLE, XML_BIND_STYLES_TO_CONTENT ):
 621                 pDatabaseRangeContext->SetSubTotalsBindFormatsToContent(IsXMLToken(aIter, XML_TRUE));
 622                 break;
 623             case XML_ELEMENT( TABLE, XML_CASE_SENSITIVE ):
 624                 pDatabaseRangeContext->SetSubTotalsIsCaseSensitive(IsXMLToken(aIter, XML_TRUE));
 625                 break;
 626             case XML_ELEMENT( TABLE, XML_PAGE_BREAKS_ON_GROUP_CHANGE ):
 627                 pDatabaseRangeContext->SetSubTotalsInsertPageBreaks(IsXMLToken(aIter, XML_TRUE));
 628                 break;
 629             case XML_ELEMENT( LO_EXT, XML_SUMMARY_BELOW ):
 630                 pDatabaseRangeContext->SetSubTotalsSummaryBelow(IsXMLToken(aIter, XML_TRUE));
 631                 break;
 632         }
 633     }
 634 }
 635
 636 ScXMLSubTotalRulesContext::~ScXMLSubTotalRulesContext()
 637 {
 638 }
 639
 640 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL ScXMLSubTotalRulesContext::createFastChildContext(
 641     sal_Int32 nElement, const uno::Reference< xml::sax::XFastAttributeList >& xAttrList )
 642 {
 643     SvXMLImportContext *pContext = nullptr;
 644     sax_fastparser::FastAttributeList *pAttribList =
 645         &sax_fastparser::castToFastAttributeList( xAttrList );
 646
 647     switch (nElement)
 648     {
 649         case XML_ELEMENT( TABLE, XML_SORT_GROUPS ):
 650         {
 651             pContext = new ScXMLSortGroupsContext( GetScImport(), pAttribList, pDatabaseRangeContext);
 652         }
 653         break;
 654         case XML_ELEMENT( TABLE, XML_SUBTOTAL_RULE ):
 655         {
 656             pContext = new ScXMLSubTotalRuleContext( GetScImport(), pAttribList, pDatabaseRangeContext);
 657         }
 658         break;
 659     }
 660
 661     return pContext;
 662 }
 663
 664 ScXMLSortGroupsContext::ScXMLSortGroupsContext( ScXMLImport& rImport,
 665                                       const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
 666                                       ScXMLDatabaseRangeContext* pDatabaseRangeContext) :
 667     ScXMLImportContext( rImport )
 668 {
 669     pDatabaseRangeContext->SetSubTotalsSortGroups(true);
 670     if ( !rAttrList.is() )
 671         return;
 672
 673     for (auto &aIter : *rAttrList)
 674     {
 675         switch (aIter.getToken())
 676         {
 677             case XML_ELEMENT( TABLE, XML_DATA_TYPE ):
 678             {
 679                 const OUString sValue = aIter.toString();
 680                 if (sValue.getLength() > 8)
 681                 {
 682                     std::u16string_view sTemp = sValue.subView(0, 8);
 683                     if (sTemp == u"UserList")
 684                     {
 685                         pDatabaseRangeContext->SetSubTotalsEnabledUserList(true);
 686                         sTemp = sValue.subView(8);
 687                         pDatabaseRangeContext->SetSubTotalsUserListIndex(static_cast<sal_Int16>(o3tl::toInt32(sTemp)));
 688                     }
 689                     else
 690                     {
 691                         //if (IsXMLToken(aIter, XML_AUTOMATIC))
 692                             //aSortField.FieldType = util::SortFieldType_AUTOMATIC;
 693                             // is not supported by StarOffice
 694                     }
 695                 }
 696                 else
 697                 {
 698                     //if (IsXMLToken(aIter, XML_TEXT))
 699                         //aSortField.FieldType = util::SortFieldType_ALPHANUMERIC;
 700                         // is not supported by StarOffice
 701                     //else if (IsXMLToken(aIter, XML_NUMBER))
 702                         //aSortField.FieldType = util::SortFieldType_NUMERIC;
 703                         // is not supported by StarOffice
 704                 }
 705             }
 706             break;
 707             case XML_ELEMENT( TABLE, XML_ORDER ):
 708             {
 709                 if (IsXMLToken(aIter, XML_ASCENDING))
 710                     pDatabaseRangeContext->SetSubTotalsAscending(true);
 711                 else
 712                     pDatabaseRangeContext->SetSubTotalsAscending(false);
 713             }
 714             break;
 715         }
 716     }
 717 }
 718
 719 ScXMLSortGroupsContext::~ScXMLSortGroupsContext()
 720 {
 721 }
 722
 723 ScXMLSubTotalRuleContext::ScXMLSubTotalRuleContext( ScXMLImport& rImport,
 724                                       const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
 725                                       ScXMLDatabaseRangeContext* pTempDatabaseRangeContext) :
 726     ScXMLImportContext( rImport ),
 727     pDatabaseRangeContext(pTempDatabaseRangeContext)
 728 {
 729     if ( rAttrList.is() )
 730     {
 731         for (auto &aIter : *rAttrList)
 732         {
 733             switch (aIter.getToken())
 734             {
 735                 case XML_ELEMENT( TABLE, XML_GROUP_BY_FIELD_NUMBER ):
 736                     aSubTotalRule.nSubTotalRuleGroupFieldNumber = static_cast<sal_Int16>(aIter.toInt32());
 737                     break;
 738             }
 739         }
 740     }
 741 }
 742
 743 ScXMLSubTotalRuleContext::~ScXMLSubTotalRuleContext()
 744 {
 745 }
 746
 747 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL ScXMLSubTotalRuleContext::createFastChildContext(
 748     sal_Int32 nElement, const uno::Reference< xml::sax::XFastAttributeList >& xAttrList )
 749 {
 750     SvXMLImportContext *pContext = nullptr;
 751     sax_fastparser::FastAttributeList *pAttribList =
 752         &sax_fastparser::castToFastAttributeList( xAttrList );
 753
 754     switch (nElement)
 755     {
 756         case XML_ELEMENT( TABLE, XML_SUBTOTAL_FIELD ):
 757         {
 758             pContext = new ScXMLSubTotalFieldContext( GetScImport(), pAttribList, this);
 759         }
 760         break;
 761     }
 762
 763     return pContext;
 764 }
 765
 766 void SAL_CALL ScXMLSubTotalRuleContext::endFastElement( sal_Int32 /*nElement*/ )
 767 {
 768     if (pDatabaseRangeContext)
 769         pDatabaseRangeContext->AddSubTotalRule(aSubTotalRule);
 770 }
 771
 772 ScXMLSubTotalFieldContext::ScXMLSubTotalFieldContext( ScXMLImport& rImport,
 773                                       const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
 774                                       ScXMLSubTotalRuleContext* pTempSubTotalRuleContext) :
 775     ScXMLImportContext( rImport ),
 776     pSubTotalRuleContext(pTempSubTotalRuleContext)
 777 {
 778     if ( !rAttrList.is() )
 779         return;
 780
 781     for (auto &aIter : *rAttrList)
 782     {
 783         switch (aIter.getToken())
 784         {
 785             case XML_ELEMENT( TABLE, XML_FIELD_NUMBER ):
 786                 sFieldNumber = aIter.toString();
 787                 break;
 788             case XML_ELEMENT( TABLE, XML_FUNCTION ):
 789                 sFunction = aIter.toString();
 790                 break;
 791         }
 792     }
 793 }
 794
 795 ScXMLSubTotalFieldContext::~ScXMLSubTotalFieldContext()
 796 {
 797 }
 798
 799 void SAL_CALL ScXMLSubTotalFieldContext::endFastElement( sal_Int32 /*nElement*/ )
 800 {
 801     sheet::SubTotalColumn aSubTotalColumn;
 802     aSubTotalColumn.Column = sFieldNumber.toInt32();
 803     aSubTotalColumn.Function = ScXMLConverter::GetFunctionFromString( sFunction );
 804     pSubTotalRuleContext->AddSubTotalColumn(aSubTotalColumn);
 805 }
 806
 807 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */