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