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