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