sc/source/filter/xml/xmlfilti.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 "xmlfilti.hxx"
  21 #include "xmlimprt.hxx"
  22 #include "xmldrani.hxx"
  23 #include "xmldpimp.hxx"
  24 #include <rangeutl.hxx>
  25 #include <queryentry.hxx>
  26 #include <document.hxx>
  27
  28 #include <o3tl/safeint.hxx>
  29 #include <svl/sharedstringpool.hxx>
  30 #include <xmloff/xmltoken.hxx>
  31 #include <xmloff/xmlnmspe.hxx>
  32
  33 using namespace com::sun::star;
  34 using namespace xmloff::token;
  35
  36 using ::com::sun::star::uno::Reference;
  37 using ::com::sun::star::xml::sax::XAttributeList;
  38
  39 ScXMLFilterContext::ConnStackItem::ConnStackItem(bool bOr) : mbOr(bOr), mnCondCount(0) {}
  40
  41 ScXMLFilterContext::ScXMLFilterContext( ScXMLImport& rImport,
  42                                         const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
  43                                         ScQueryParam& rParam,
  44                                         ScXMLDatabaseRangeContext* pTempDatabaseRangeContext) :
  45     ScXMLImportContext( rImport ),
  46     mrQueryParam(rParam),
  47     pDatabaseRangeContext(pTempDatabaseRangeContext),
  48     bSkipDuplicates(false),
  49     bCopyOutputData(false),
  50     bConditionSourceRange(false)
  51 {
  52     ScDocument* pDoc(GetScImport().GetDocument());
  53
  54     if ( rAttrList.is() )
  55     {
  56         for (auto &aIter : *rAttrList)
  57         {
  58             switch (aIter.getToken())
  59             {
  60                 case XML_ELEMENT( TABLE, XML_TARGET_RANGE_ADDRESS ):
  61                 {
  62                     ScRange aScRange;
  63                     sal_Int32 nOffset(0);
  64                     if (ScRangeStringConverter::GetRangeFromString( aScRange, aIter.toString(), pDoc, ::formula::FormulaGrammar::CONV_OOO, nOffset ))
  65                     {
  66                         aOutputPosition = aScRange.aStart;
  67                         bCopyOutputData = true;
  68                     }
  69                 }
  70                 break;
  71                 case XML_ELEMENT( TABLE, XML_CONDITION_SOURCE_RANGE_ADDRESS ):
  72                 {
  73                     sal_Int32 nOffset(0);
  74                     if (ScRangeStringConverter::GetRangeFromString( aConditionSourceRangeAddress, aIter.toString(), pDoc, ::formula::FormulaGrammar::CONV_OOO, nOffset ) )
  75                         bConditionSourceRange = true;
  76                 }
  77                 break;
  78                 case XML_ELEMENT( TABLE, XML_CONDITION_SOURCE ):
  79                 {
  80                     // not supported by StarOffice
  81                 }
  82                 break;
  83                 case XML_ELEMENT( TABLE, XML_DISPLAY_DUPLICATES ):
  84                 {
  85                     bSkipDuplicates = !IsXMLToken(aIter, XML_TRUE);
  86                 }
  87                 break;
  88             }
  89         }
  90     }
  91 }
  92
  93 ScXMLFilterContext::~ScXMLFilterContext()
  94 {
  95 }
  96
  97 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL ScXMLFilterContext::createFastChildContext(
  98     sal_Int32 nElement, const uno::Reference< xml::sax::XFastAttributeList >& xAttrList )
  99 {
 100     SvXMLImportContext *pContext(nullptr);
 101     sax_fastparser::FastAttributeList *pAttribList =
 102         sax_fastparser::FastAttributeList::castToFastAttributeList( xAttrList );
 103
 104     switch (nElement)
 105     {
 106         case XML_ELEMENT( TABLE, XML_FILTER_AND ):
 107         {
 108             pContext = new ScXMLAndContext(
 109                 GetScImport(), mrQueryParam, this);
 110         }
 111         break;
 112         case XML_ELEMENT( TABLE, XML_FILTER_OR ):
 113         {
 114             pContext = new ScXMLOrContext(
 115                 GetScImport(), mrQueryParam, this);
 116         }
 117         break;
 118         case XML_ELEMENT( TABLE, XML_FILTER_CONDITION ):
 119         {
 120             pContext = new ScXMLConditionContext(
 121                 GetScImport(), nElement, pAttribList, mrQueryParam, this);
 122         }
 123         break;
 124     }
 125
 126     if( !pContext )
 127         pContext = new SvXMLImportContext( GetImport() );
 128
 129     return pContext;
 130 }
 131
 132 void SAL_CALL ScXMLFilterContext::endFastElement( sal_Int32 /*nElement*/ )
 133 {
 134     mrQueryParam.bInplace = !bCopyOutputData;
 135     mrQueryParam.bDuplicate = !bSkipDuplicates;
 136
 137     if (bCopyOutputData)
 138     {
 139         mrQueryParam.nDestCol = aOutputPosition.Col();
 140         mrQueryParam.nDestRow = aOutputPosition.Row();
 141         mrQueryParam.nDestTab = aOutputPosition.Tab();
 142     }
 143
 144     if (bConditionSourceRange)
 145         pDatabaseRangeContext->SetFilterConditionSourceRangeAddress(aConditionSourceRangeAddress);
 146 }
 147
 148 void ScXMLFilterContext::OpenConnection(bool b)
 149 {
 150     maConnStack.emplace_back(b);
 151 }
 152
 153 void ScXMLFilterContext::CloseConnection()
 154 {
 155     maConnStack.pop_back();
 156 }
 157
 158 bool ScXMLFilterContext::GetConnection()
 159 {
 160     // For condition items in each stack, the first one gets the connection of
 161     // the last stack, while the rest of them get that of the current stack.
 162
 163     if (maConnStack.empty())
 164         // This should never happen.
 165         return true;
 166
 167     ConnStackItem& rItem = maConnStack.back();
 168     if (rItem.mnCondCount)
 169         // secondary item gets the current connection.
 170         return rItem.mbOr;
 171
 172     // The next condition of this stack will get the current connection.
 173     ++rItem.mnCondCount;
 174
 175     if (maConnStack.size() < 2)
 176         // There is no last stack.  Likely the first condition in the first
 177         // stack whose connection is not used.  Default in
 178         // ScQueryEntry::eConnect is SC_AND, so return false (AND instead of
 179         // OR) here. Otherwise, when saving the document again, we'd write a
 180         // uselessly stacked
 181         // <table:filter-or><table:filter-and>...</table:filter-and></table:filter-or>
 182         // for two conditions connected with AND.
 183         return false;
 184
 185     std::vector<ConnStackItem>::reverse_iterator itr = maConnStack.rbegin();
 186     ++itr;
 187     return itr->mbOr; // connection of the last stack.
 188 }
 189
 190 ScXMLAndContext::ScXMLAndContext( ScXMLImport& rImport,
 191                                   ScQueryParam& rParam,
 192                                   ScXMLFilterContext* pTempFilterContext) :
 193     ScXMLImportContext( rImport ),
 194     mrQueryParam(rParam),
 195     pFilterContext(pTempFilterContext)
 196 {
 197     pFilterContext->OpenConnection(false);
 198 }
 199
 200 ScXMLAndContext::~ScXMLAndContext()
 201 {
 202 }
 203
 204 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL ScXMLAndContext::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::FastAttributeList::castToFastAttributeList( xAttrList );
 210
 211     switch (nElement)
 212     {
 213         case XML_ELEMENT( TABLE, XML_FILTER_OR ):
 214         {
 215             // not supported in StarOffice
 216         }
 217         break;
 218         case XML_ELEMENT( TABLE, XML_FILTER_CONDITION ):
 219         {
 220             pContext = new ScXMLConditionContext(
 221                 GetScImport(), nElement, pAttribList, mrQueryParam, pFilterContext);
 222         }
 223         break;
 224     }
 225
 226     if( !pContext )
 227         pContext = new SvXMLImportContext( GetImport() );
 228
 229     return pContext;
 230 }
 231
 232 void SAL_CALL ScXMLAndContext::endFastElement( sal_Int32 /*nElement*/ )
 233 {
 234     pFilterContext->CloseConnection();
 235 }
 236
 237 ScXMLOrContext::ScXMLOrContext( ScXMLImport& rImport,
 238                                 ScQueryParam& rParam,
 239                                 ScXMLFilterContext* pTempFilterContext) :
 240     ScXMLImportContext( rImport ),
 241     mrQueryParam(rParam),
 242     pFilterContext(pTempFilterContext)
 243 {
 244     pFilterContext->OpenConnection(true);
 245 }
 246
 247 ScXMLOrContext::~ScXMLOrContext()
 248 {
 249 }
 250
 251 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL ScXMLOrContext::createFastChildContext(
 252     sal_Int32 nElement, const uno::Reference< xml::sax::XFastAttributeList >& xAttrList )
 253 {
 254     SvXMLImportContext *pContext(nullptr);
 255     sax_fastparser::FastAttributeList *pAttribList =
 256         sax_fastparser::FastAttributeList::castToFastAttributeList( xAttrList );
 257
 258     switch (nElement)
 259     {
 260         case XML_ELEMENT( TABLE, XML_FILTER_AND ):
 261         {
 262             pContext = new ScXMLAndContext(
 263                 GetScImport(), mrQueryParam, pFilterContext);
 264         }
 265         break;
 266         case XML_ELEMENT( TABLE, XML_FILTER_CONDITION ):
 267         {
 268             pContext = new ScXMLConditionContext(
 269                 GetScImport(), nElement, pAttribList, mrQueryParam, pFilterContext);
 270         }
 271         break;
 272     }
 273
 274     if( !pContext )
 275         pContext = new SvXMLImportContext( GetImport() );
 276
 277     return pContext;
 278 }
 279
 280 void SAL_CALL ScXMLOrContext::endFastElement( sal_Int32 /*nElement*/ )
 281 {
 282     pFilterContext->CloseConnection();
 283 }
 284
 285 ScXMLConditionContext::ScXMLConditionContext(
 286     ScXMLImport& rImport, sal_Int32 /*nElement*/,
 287     const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
 288     ScQueryParam& rParam,
 289     ScXMLFilterContext* pTempFilterContext) :
 290     ScXMLImportContext( rImport ),
 291     mrQueryParam(rParam),
 292     pFilterContext(pTempFilterContext),
 293     nField(0),
 294     bIsCaseSensitive(false)
 295 {
 296     sDataType = GetXMLToken(XML_TEXT);
 297
 298     if ( rAttrList.is() )
 299     {
 300         for (auto &aIter : *rAttrList)
 301         {
 302             switch (aIter.getToken())
 303             {
 304                 case XML_ELEMENT( TABLE, XML_FIELD_NUMBER ):
 305                 {
 306                     nField = aIter.toInt32();
 307                 }
 308                 break;
 309                 case XML_ELEMENT( TABLE, XML_CASE_SENSITIVE ):
 310                 {
 311                     bIsCaseSensitive = IsXMLToken(aIter, XML_TRUE);
 312                 }
 313                 break;
 314                 case XML_ELEMENT( TABLE, XML_DATA_TYPE ):
 315                 {
 316                     sDataType = aIter.toString();
 317                 }
 318                 break;
 319                 case XML_ELEMENT( TABLE, XML_VALUE ):
 320                 {
 321                     sConditionValue = aIter.toString();
 322                 }
 323                 break;
 324                 case XML_ELEMENT( TABLE, XML_OPERATOR ):
 325                 {
 326                     sOperator = aIter.toString();
 327                 }
 328                 break;
 329             }
 330         }
 331     }
 332 }
 333
 334 ScXMLConditionContext::~ScXMLConditionContext()
 335 {
 336 }
 337
 338 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL ScXMLConditionContext::createFastChildContext(
 339     sal_Int32 nElement, const uno::Reference< xml::sax::XFastAttributeList >& xAttrList )
 340 {
 341     SvXMLImportContext *pContext = nullptr;
 342     sax_fastparser::FastAttributeList *pAttribList =
 343         sax_fastparser::FastAttributeList::castToFastAttributeList( xAttrList );
 344
 345     switch (nElement)
 346     {
 347         case XML_ELEMENT( TABLE, XML_FILTER_SET_ITEM ):
 348         {
 349             pContext = new ScXMLSetItemContext(
 350                 GetScImport(), nElement, pAttribList, *this);
 351         }
 352         break;
 353     }
 354
 355     if( !pContext )
 356         pContext = new SvXMLImportContext( GetImport() );
 357
 358     return pContext;
 359 }
 360
 361 void ScXMLConditionContext::GetOperator(
 362     const OUString& aOpStr, ScQueryParam& rParam, ScQueryEntry& rEntry)
 363 {
 364     rParam.eSearchType = utl::SearchParam::SearchType::Normal;
 365     if (IsXMLToken(aOpStr, XML_MATCH))
 366     {
 367         rParam.eSearchType = utl::SearchParam::SearchType::Regexp;
 368         rEntry.eOp = SC_EQUAL;
 369     }
 370     else if (IsXMLToken(aOpStr, XML_NOMATCH))
 371     {
 372         rParam.eSearchType = utl::SearchParam::SearchType::Regexp;
 373         rEntry.eOp = SC_NOT_EQUAL;
 374     }
 375     else if (aOpStr == "=")
 376         rEntry.eOp = SC_EQUAL;
 377     else if (aOpStr == "!=")
 378         rEntry.eOp = SC_NOT_EQUAL;
 379     else if (IsXMLToken(aOpStr, XML_BOTTOM_PERCENT))
 380         rEntry.eOp = SC_BOTPERC;
 381     else if (IsXMLToken(aOpStr, XML_BOTTOM_VALUES))
 382         rEntry.eOp = SC_BOTVAL;
 383     else if (IsXMLToken(aOpStr, XML_EMPTY))
 384         rEntry.SetQueryByEmpty();
 385     else if (aOpStr == ">")
 386         rEntry.eOp = SC_GREATER;
 387     else if (aOpStr == ">=")
 388         rEntry.eOp = SC_GREATER_EQUAL;
 389     else if (aOpStr == "<")
 390         rEntry.eOp = SC_LESS;
 391     else if (aOpStr == "<=")
 392         rEntry.eOp = SC_LESS_EQUAL;
 393     else if (IsXMLToken(aOpStr, XML_NOEMPTY))
 394         rEntry.SetQueryByNonEmpty();
 395     else if (IsXMLToken(aOpStr, XML_TOP_PERCENT))
 396         rEntry.eOp = SC_TOPPERC;
 397     else if (IsXMLToken(aOpStr, XML_TOP_VALUES))
 398         rEntry.eOp = SC_TOPVAL;
 399     else if (IsXMLToken(aOpStr, XML_CONTAINS))
 400         rEntry.eOp = SC_CONTAINS;
 401     else if (IsXMLToken(aOpStr, XML_DOES_NOT_CONTAIN))
 402         rEntry.eOp = SC_DOES_NOT_CONTAIN;
 403     else if (IsXMLToken(aOpStr, XML_BEGINS_WITH))
 404         rEntry.eOp = SC_BEGINS_WITH;
 405     else if (IsXMLToken(aOpStr, XML_DOES_NOT_BEGIN_WITH))
 406         rEntry.eOp = SC_DOES_NOT_BEGIN_WITH;
 407     else if (IsXMLToken(aOpStr, XML_ENDS_WITH))
 408         rEntry.eOp = SC_ENDS_WITH;
 409     else if (IsXMLToken(aOpStr, XML_DOES_NOT_END_WITH))
 410         rEntry.eOp = SC_DOES_NOT_END_WITH;
 411 }
 412
 413 void ScXMLConditionContext::AddSetItem(const ScQueryEntry::Item& rItem)
 414 {
 415     maQueryItems.push_back(rItem);
 416 }
 417
 418 void SAL_CALL ScXMLConditionContext::endFastElement( sal_Int32 /*nElement*/ )
 419 {
 420     ScQueryEntry& rEntry = mrQueryParam.AppendEntry();
 421
 422     // We currently don't support per-condition case sensitivity.
 423     mrQueryParam.bCaseSens = bIsCaseSensitive;
 424
 425     rEntry.bDoQuery = true;
 426     rEntry.eConnect = pFilterContext->GetConnection() ? SC_OR : SC_AND;
 427
 428     GetOperator(sOperator, mrQueryParam, rEntry);
 429     SCCOLROW nStartPos = mrQueryParam.bByRow ? mrQueryParam.nCol1 : mrQueryParam.nRow1;
 430     rEntry.nField = o3tl::saturating_add(nField, nStartPos);
 431
 432     if (maQueryItems.empty())
 433     {
 434         ScQueryEntry::Item& rItem = rEntry.GetQueryItem();
 435         if (IsXMLToken(sDataType, XML_NUMBER))
 436         {
 437             rItem.mfVal = sConditionValue.toDouble();
 438             rItem.meType = ScQueryEntry::ByValue;
 439         }
 440         else
 441         {
 442             svl::SharedStringPool& rPool = GetScImport().GetDocument()->GetSharedStringPool();
 443             rItem.maString = rPool.intern(sConditionValue);
 444             rItem.meType = ScQueryEntry::ByString;
 445         }
 446     }
 447     else
 448         rEntry.GetQueryItems().swap(maQueryItems);
 449 }
 450
 451 ScXMLSetItemContext::ScXMLSetItemContext(
 452     ScXMLImport& rImport, sal_Int32 /*nElement*/,
 453     const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList, ScXMLConditionContext& rParent) :
 454     ScXMLImportContext(rImport)
 455 {
 456     if ( rAttrList.is() )
 457     {
 458         for (auto &aIter : *rAttrList)
 459         {
 460             switch (aIter.getToken())
 461             {
 462                 case XML_ELEMENT( TABLE, XML_VALUE ):
 463                 {
 464                     svl::SharedStringPool& rPool = GetScImport().GetDocument()->GetSharedStringPool();
 465                     ScQueryEntry::Item aItem;
 466                     aItem.maString = rPool.intern(aIter.toString());
 467                     aItem.meType = ScQueryEntry::ByString;
 468                     aItem.mfVal = 0.0;
 469                     rParent.AddSetItem(aItem);
 470                 }
 471                 break;
 472             }
 473         }
 474     }
 475 }
 476
 477 ScXMLSetItemContext::~ScXMLSetItemContext()
 478 {
 479 }
 480
 481 ScXMLDPFilterContext::ScXMLDPFilterContext( ScXMLImport& rImport,
 482                                       const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
 483                                       ScXMLDataPilotTableContext* pTempDataPilotTableContext) :
 484     ScXMLImportContext( rImport ),
 485     pDataPilotTable(pTempDataPilotTableContext),
 486     aFilterFields(),
 487     eSearchType(utl::SearchParam::SearchType::Normal),
 488     nFilterFieldCount(0),
 489     bSkipDuplicates(false),
 490     bIsCaseSensitive(false),
 491     bConnectionOr(true),
 492     bNextConnectionOr(true)
 493 {
 494     if ( rAttrList.is() )
 495     {
 496         for (auto &aIter : *rAttrList)
 497         {
 498             switch (aIter.getToken())
 499             {
 500                 case XML_ELEMENT( TABLE, XML_TARGET_RANGE_ADDRESS ):
 501                 {
 502                     // not supported
 503                 }
 504                 break;
 505                 case XML_ELEMENT( TABLE, XML_CONDITION_SOURCE_RANGE_ADDRESS ):
 506                 {
 507                     // not supported
 508                 }
 509                 break;
 510                 case XML_ELEMENT( TABLE, XML_CONDITION_SOURCE ):
 511                 {
 512                     // not supported by StarOffice
 513                 }
 514                 break;
 515                 case XML_ELEMENT( TABLE, XML_DISPLAY_DUPLICATES ):
 516                 {
 517                     bSkipDuplicates = !IsXMLToken(aIter, XML_TRUE);
 518                 }
 519                 break;
 520                 }
 521         }
 522     }
 523 }
 524
 525 ScXMLDPFilterContext::~ScXMLDPFilterContext()
 526 {
 527 }
 528
 529 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL ScXMLDPFilterContext::createFastChildContext(
 530     sal_Int32 nElement, const uno::Reference< xml::sax::XFastAttributeList >& xAttrList )
 531 {
 532     SvXMLImportContext *pContext(nullptr);
 533     sax_fastparser::FastAttributeList *pAttribList =
 534         sax_fastparser::FastAttributeList::castToFastAttributeList( xAttrList );
 535
 536     switch (nElement)
 537     {
 538         case XML_ELEMENT( TABLE, XML_FILTER_AND ):
 539         {
 540             pContext = new ScXMLDPAndContext( GetScImport(), this);
 541         }
 542         break;
 543         case XML_ELEMENT( TABLE, XML_FILTER_OR ):
 544         {
 545             pContext = new ScXMLDPOrContext( GetScImport(), this);
 546         }
 547         break;
 548         case XML_ELEMENT( TABLE, XML_FILTER_CONDITION ):
 549         {
 550             pContext = new ScXMLDPConditionContext( GetScImport(), nElement, pAttribList, this);
 551         }
 552         break;
 553     }
 554
 555     if( !pContext )
 556         pContext = new SvXMLImportContext( GetImport() );
 557
 558     return pContext;
 559 }
 560
 561 void SAL_CALL ScXMLDPFilterContext::endFastElement( sal_Int32 /*nElement*/ )
 562 {
 563     aFilterFields.eSearchType = eSearchType;
 564     aFilterFields.bCaseSens = bIsCaseSensitive;
 565     aFilterFields.bDuplicate = !bSkipDuplicates;
 566
 567     pDataPilotTable->SetSourceQueryParam(aFilterFields);
 568 }
 569
 570 void ScXMLDPFilterContext::AddFilterField (const ScQueryEntry& aFilterField)
 571 {
 572     aFilterFields.Resize(nFilterFieldCount + 1);
 573     ScQueryEntry& rEntry(aFilterFields.GetEntry(nFilterFieldCount));
 574     rEntry = aFilterField;
 575     rEntry.bDoQuery = true;
 576     ++nFilterFieldCount;
 577 }
 578
 579 ScXMLDPAndContext::ScXMLDPAndContext( ScXMLImport& rImport,
 580                                       ScXMLDPFilterContext* pTempFilterContext) :
 581     ScXMLImportContext( rImport )
 582 {
 583     pFilterContext = pTempFilterContext;
 584     pFilterContext->OpenConnection(false);
 585 }
 586
 587 ScXMLDPAndContext::~ScXMLDPAndContext()
 588 {
 589 }
 590
 591 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL ScXMLDPAndContext::createFastChildContext(
 592     sal_Int32 nElement, const uno::Reference< xml::sax::XFastAttributeList >& xAttrList )
 593 {
 594     SvXMLImportContext *pContext(nullptr);
 595     sax_fastparser::FastAttributeList *pAttribList =
 596         sax_fastparser::FastAttributeList::castToFastAttributeList( xAttrList );
 597
 598     switch (nElement)
 599     {
 600         case XML_ELEMENT( TABLE, XML_FILTER_OR ):
 601         {
 602             // not supported in StarOffice
 603         }
 604         break;
 605         case XML_ELEMENT( TABLE, XML_FILTER_CONDITION ):
 606         {
 607             pContext = new ScXMLDPConditionContext( GetScImport(), nElement, pAttribList, pFilterContext);
 608         }
 609         break;
 610     }
 611
 612     if( !pContext )
 613         pContext = new SvXMLImportContext( GetImport() );
 614
 615     return pContext;
 616 }
 617
 618 void SAL_CALL ScXMLDPAndContext::endFastElement( sal_Int32 /*nElement*/ )
 619 {
 620     pFilterContext->CloseConnection();
 621 }
 622
 623 ScXMLDPOrContext::ScXMLDPOrContext( ScXMLImport& rImport,
 624                                     ScXMLDPFilterContext* pTempFilterContext) :
 625     ScXMLImportContext( rImport ),
 626     pFilterContext(pTempFilterContext)
 627 {
 628     pFilterContext->OpenConnection(true);
 629 }
 630
 631 ScXMLDPOrContext::~ScXMLDPOrContext()
 632 {
 633 }
 634
 635 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL ScXMLDPOrContext::createFastChildContext(
 636     sal_Int32 nElement, const uno::Reference< xml::sax::XFastAttributeList >& xAttrList )
 637 {
 638     SvXMLImportContext *pContext(nullptr);
 639     sax_fastparser::FastAttributeList *pAttribList =
 640         sax_fastparser::FastAttributeList::castToFastAttributeList( xAttrList );
 641
 642     switch (nElement)
 643     {
 644         case XML_ELEMENT( TABLE, XML_FILTER_AND ):
 645         {
 646             pContext = new ScXMLDPAndContext( GetScImport(), pFilterContext);
 647         }
 648         break;
 649         case XML_ELEMENT( TABLE, XML_FILTER_CONDITION ):
 650         {
 651             pContext = new ScXMLDPConditionContext( GetScImport(), nElement, pAttribList, pFilterContext);
 652         }
 653         break;
 654     }
 655
 656     if( !pContext )
 657         pContext = new SvXMLImportContext( GetImport() );
 658
 659     return pContext;
 660 }
 661
 662 void SAL_CALL ScXMLDPOrContext::endFastElement( sal_Int32 /*nElement*/ )
 663 {
 664     pFilterContext->CloseConnection();
 665 }
 666
 667 ScXMLDPConditionContext::ScXMLDPConditionContext( ScXMLImport& rImport,
 668                                       sal_Int32 /*nElement*/,
 669                                       const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
 670                                       ScXMLDPFilterContext* pTempFilterContext) :
 671     ScXMLImportContext( rImport ),
 672     pFilterContext(pTempFilterContext),
 673     sDataType(GetXMLToken(XML_TEXT)),
 674     nField(0),
 675     bIsCaseSensitive(false)
 676 {
 677
 678     if ( rAttrList.is() )
 679     {
 680         for (auto &aIter : *rAttrList)
 681         {
 682             switch (aIter.getToken())
 683             {
 684                 case XML_ELEMENT( TABLE, XML_FIELD_NUMBER ):
 685                 {
 686                     nField = aIter.toInt32();
 687                 }
 688                 break;
 689                 case XML_ELEMENT( TABLE, XML_CASE_SENSITIVE ):
 690                 {
 691                     bIsCaseSensitive = IsXMLToken(aIter, XML_TRUE);
 692                 }
 693                 break;
 694                 case XML_ELEMENT( TABLE, XML_DATA_TYPE ):
 695                 {
 696                     sDataType = aIter.toString();
 697                 }
 698                 break;
 699                 case XML_ELEMENT( TABLE, XML_VALUE ):
 700                 {
 701                     sConditionValue = aIter.toString();
 702                 }
 703                 break;
 704                 case XML_ELEMENT( TABLE, XML_OPERATOR ):
 705                 {
 706                     sOperator = aIter.toString();
 707                 }
 708                 break;
 709             }
 710         }
 711     }
 712 }
 713
 714 ScXMLDPConditionContext::~ScXMLDPConditionContext()
 715 {
 716 }
 717
 718 void ScXMLDPConditionContext::getOperatorXML(
 719     const OUString& sTempOperator, ScQueryOp& aFilterOperator, utl::SearchParam::SearchType& rSearchType)
 720 {
 721     rSearchType = utl::SearchParam::SearchType::Normal;
 722     if (IsXMLToken(sTempOperator, XML_MATCH))
 723     {
 724         rSearchType = utl::SearchParam::SearchType::Regexp;
 725         aFilterOperator = SC_EQUAL;
 726     }
 727     else if (IsXMLToken(sTempOperator, XML_NOMATCH))
 728     {
 729         rSearchType = utl::SearchParam::SearchType::Regexp;
 730         aFilterOperator = SC_NOT_EQUAL;
 731     }
 732     else if (sTempOperator == "=")
 733         aFilterOperator = SC_EQUAL;
 734     else if (sTempOperator == "!=")
 735         aFilterOperator = SC_NOT_EQUAL;
 736     else if (IsXMLToken(sTempOperator, XML_BOTTOM_PERCENT))
 737         aFilterOperator = SC_BOTPERC;
 738     else if (IsXMLToken(sTempOperator, XML_BOTTOM_VALUES))
 739         aFilterOperator = SC_BOTVAL;
 740     else if (sTempOperator == ">")
 741         aFilterOperator = SC_GREATER;
 742     else if (sTempOperator == ">=")
 743         aFilterOperator = SC_GREATER_EQUAL;
 744     else if (sTempOperator == "<")
 745         aFilterOperator = SC_LESS;
 746     else if (sTempOperator == "<=")
 747         aFilterOperator = SC_LESS_EQUAL;
 748     else if (IsXMLToken(sTempOperator, XML_TOP_PERCENT))
 749         aFilterOperator = SC_TOPPERC;
 750     else if (IsXMLToken(sTempOperator, XML_TOP_VALUES))
 751         aFilterOperator = SC_TOPVAL;
 752 }
 753
 754 void SAL_CALL ScXMLDPConditionContext::endFastElement( sal_Int32 /*nElement*/ )
 755 {
 756     ScQueryEntry aFilterField;
 757     if (pFilterContext->GetConnection())
 758         aFilterField.eConnect = SC_OR;
 759     else
 760         aFilterField.eConnect = SC_AND;
 761     pFilterContext->SetIsCaseSensitive(bIsCaseSensitive);
 762     if (IsXMLToken(sOperator, XML_EMPTY))
 763         aFilterField.SetQueryByEmpty();
 764     else if (IsXMLToken(sOperator, XML_NOEMPTY))
 765         aFilterField.SetQueryByNonEmpty();
 766     else
 767     {
 768         utl::SearchParam::SearchType eSearchType = utl::SearchParam::SearchType::Normal;
 769         getOperatorXML(sOperator, aFilterField.eOp, eSearchType);
 770         pFilterContext->SetSearchType(eSearchType);
 771         aFilterField.nField = nField;
 772         ScQueryEntry::Item& rItem = aFilterField.GetQueryItem();
 773         svl::SharedStringPool& rPool = GetScImport().GetDocument()->GetSharedStringPool();
 774
 775         if (IsXMLToken(sDataType, XML_NUMBER))
 776         {
 777             rItem.mfVal = sConditionValue.toDouble();
 778             rItem.maString = rPool.intern(sConditionValue);
 779             rItem.meType = ScQueryEntry::ByValue;
 780         }
 781         else
 782         {
 783             rItem.maString = rPool.intern(sConditionValue);
 784             rItem.meType = ScQueryEntry::ByString;
 785             rItem.mfVal = 0.0;
 786         }
 787     }
 788     pFilterContext->AddFilterField(aFilterField);
 789 }
 790
 791 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */