sc/source/filter/xml/xmlfilti.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: xmlfilti.cxx,v $
  10  * $Revision: 1.17 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sc.hxx"
  33
  34
  35 // INCLUDE ---------------------------------------------------------------
  36
  37 #include "xmlfilti.hxx"
  38 #include "xmlimprt.hxx"
  39 #include "docuno.hxx"
  40 #include "convuno.hxx"
  41 #include "XMLConverter.hxx"
  42 #include "rangeutl.hxx"
  43
  44 #include <xmloff/xmltkmap.hxx>
  45 #include <xmloff/nmspmap.hxx>
  46 #include <xmloff/xmltoken.hxx>
  47
  48 using namespace com::sun::star;
  49 using namespace xmloff::token;
  50
  51 //------------------------------------------------------------------
  52
  53 ScXMLFilterContext::ScXMLFilterContext( ScXMLImport& rImport,
  54                                                                           USHORT nPrfx,
  55                                                                           const ::rtl::OUString& rLName,
  56                                                                           const ::com::sun::star::uno::Reference<
  57                                                                           ::com::sun::star::xml::sax::XAttributeList>& xAttrList,
  58                                                                                 ScXMLDatabaseRangeContext* pTempDatabaseRangeContext) :
  59         SvXMLImportContext( rImport, nPrfx, rLName ),
  60         pDatabaseRangeContext(pTempDatabaseRangeContext),
  61         aFilterFields(),
  62         bSkipDuplicates(sal_False),
  63         bCopyOutputData(sal_False),
  64         bUseRegularExpressions(sal_False),
  65         bConnectionOr(sal_True),
  66         bNextConnectionOr(sal_True),
  67         bConditionSourceRange(sal_False)
  68 {
  69         ScDocument* pDoc(GetScImport().GetDocument());
  70
  71         sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
  72         const SvXMLTokenMap& rAttrTokenMap = GetScImport().GetFilterAttrTokenMap();
  73         for( sal_Int16 i=0; i < nAttrCount; ++i )
  74         {
  75                 const rtl::OUString& sAttrName(xAttrList->getNameByIndex( i ));
  76                 rtl::OUString aLocalName;
  77                 USHORT nPrefix = GetScImport().GetNamespaceMap().GetKeyByAttrName(
  78                                                                                         sAttrName, &aLocalName );
  79                 const rtl::OUString& sValue(xAttrList->getValueByIndex( i ));
  80
  81                 switch( rAttrTokenMap.Get( nPrefix, aLocalName ) )
  82                 {
  83                         case XML_TOK_FILTER_ATTR_TARGET_RANGE_ADDRESS :
  84                         {
  85                                 ScRange aScRange;
  86                                 sal_Int32 nOffset(0);
  87                                 if (ScRangeStringConverter::GetRangeFromString( aScRange, sValue, pDoc, ::formula::FormulaGrammar::CONV_OOO, nOffset ))
  88                                 {
  89                                         ScUnoConversion::FillApiAddress( aOutputPosition, aScRange.aStart );
  90                                         bCopyOutputData = sal_True;
  91                                 }
  92                         }
  93                         break;
  94                         case XML_TOK_FILTER_ATTR_CONDITION_SOURCE_RANGE_ADDRESS :
  95                         {
  96                                 sal_Int32 nOffset(0);
  97                                 if (ScRangeStringConverter::GetRangeFromString( aConditionSourceRangeAddress, sValue, pDoc, ::formula::FormulaGrammar::CONV_OOO, nOffset ))
  98                                         bConditionSourceRange = sal_True;
  99                         }
 100                         break;
 101                         case XML_TOK_FILTER_ATTR_CONDITION_SOURCE :
 102                         {
 103                                 // not supported by StarOffice
 104                         }
 105                         break;
 106                         case XML_TOK_FILTER_ATTR_DISPLAY_DUPLICATES :
 107                         {
 108                                 bSkipDuplicates = !IsXMLToken(sValue, XML_TRUE);
 109                         }
 110                         break;
 111                 }
 112         }
 113 }
 114
 115 ScXMLFilterContext::~ScXMLFilterContext()
 116 {
 117 }
 118
 119 SvXMLImportContext *ScXMLFilterContext::CreateChildContext( USHORT nPrefix,
 120                                                                                         const ::rtl::OUString& rLName,
 121                                                                                         const ::com::sun::star::uno::Reference<
 122                                                                                 ::com::sun::star::xml::sax::XAttributeList>& xAttrList )
 123 {
 124         SvXMLImportContext *pContext(0);
 125
 126         const SvXMLTokenMap& rTokenMap(GetScImport().GetFilterElemTokenMap());
 127         switch( rTokenMap.Get( nPrefix, rLName ) )
 128         {
 129                 case XML_TOK_FILTER_AND:
 130                 {
 131                         pContext = new ScXMLAndContext( GetScImport(), nPrefix,
 132                                                                                                                 rLName, xAttrList, this);
 133                 }
 134                 break;
 135                 case XML_TOK_FILTER_OR:
 136                 {
 137                         pContext = new ScXMLOrContext( GetScImport(), nPrefix,
 138                                                                                                                 rLName, xAttrList, this);
 139                 }
 140                 break;
 141                 case XML_TOK_FILTER_CONDITION:
 142                 {
 143                         pContext = new ScXMLConditionContext( GetScImport(), nPrefix,
 144                                                                                                                 rLName, xAttrList, this);
 145                 }
 146                 break;
 147         }
 148
 149         if( !pContext )
 150                 pContext = new SvXMLImportContext( GetImport(), nPrefix, rLName );
 151
 152         return pContext;
 153 }
 154
 155 void ScXMLFilterContext::EndElement()
 156 {
 157         pDatabaseRangeContext->SetFilterUseRegularExpressions(bUseRegularExpressions);
 158         if (bCopyOutputData)
 159         {
 160                 pDatabaseRangeContext->SetFilterOutputPosition(aOutputPosition);
 161                 pDatabaseRangeContext->SetFilterCopyOutputData(bCopyOutputData);
 162         }
 163         else
 164                 pDatabaseRangeContext->SetFilterCopyOutputData(sal_False);
 165         pDatabaseRangeContext->SetFilterIsCaseSensitive(bIsCaseSensitive);
 166         pDatabaseRangeContext->SetFilterSkipDuplicates(bSkipDuplicates);
 167         pDatabaseRangeContext->SetFilterFields(aFilterFields);
 168         if (bConditionSourceRange)
 169                 pDatabaseRangeContext->SetFilterConditionSourceRangeAddress(aConditionSourceRangeAddress);
 170 }
 171
 172 ScXMLAndContext::ScXMLAndContext( ScXMLImport& rImport,
 173                                                                           USHORT nPrfx,
 174                                                                           const ::rtl::OUString& rLName,
 175                                                                           const ::com::sun::star::uno::Reference<
 176                                       ::com::sun::star::xml::sax::XAttributeList>& /* xAttrList */,
 177                                                                                 ScXMLFilterContext* pTempFilterContext) :
 178         SvXMLImportContext( rImport, nPrfx, rLName ),
 179         pFilterContext(pTempFilterContext)
 180 {
 181         pFilterContext->OpenConnection(sal_False);
 182 }
 183
 184 ScXMLAndContext::~ScXMLAndContext()
 185 {
 186 }
 187
 188 SvXMLImportContext *ScXMLAndContext::CreateChildContext( USHORT nPrefix,
 189                                                                                         const ::rtl::OUString& rLName,
 190                                                                                         const ::com::sun::star::uno::Reference<
 191                                                                                 ::com::sun::star::xml::sax::XAttributeList>& xAttrList )
 192 {
 193         SvXMLImportContext *pContext(0);
 194
 195         const SvXMLTokenMap& rTokenMap(GetScImport().GetFilterElemTokenMap());
 196         switch( rTokenMap.Get( nPrefix, rLName ) )
 197         {
 198                 case XML_TOK_FILTER_OR:
 199                 {
 200                         // not supported in StarOffice
 201                 }
 202                 break;
 203                 case XML_TOK_FILTER_CONDITION:
 204                 {
 205                         pContext = new ScXMLConditionContext( GetScImport(), nPrefix,
 206                                                                                                                 rLName, xAttrList, pFilterContext);
 207                 }
 208                 break;
 209         }
 210
 211         if( !pContext )
 212                 pContext = new SvXMLImportContext( GetImport(), nPrefix, rLName );
 213
 214         return pContext;
 215 }
 216
 217 void ScXMLAndContext::EndElement()
 218 {
 219         pFilterContext->CloseConnection();
 220 }
 221
 222 ScXMLOrContext::ScXMLOrContext( ScXMLImport& rImport,
 223                                                                           USHORT nPrfx,
 224                                                                           const ::rtl::OUString& rLName,
 225                                                                           const ::com::sun::star::uno::Reference<
 226                                       ::com::sun::star::xml::sax::XAttributeList>& /* xAttrList */,
 227                                                                                 ScXMLFilterContext* pTempFilterContext) :
 228         SvXMLImportContext( rImport, nPrfx, rLName ),
 229         pFilterContext(pTempFilterContext)
 230 {
 231         pFilterContext->OpenConnection(sal_True);
 232 }
 233
 234 ScXMLOrContext::~ScXMLOrContext()
 235 {
 236 }
 237
 238 SvXMLImportContext *ScXMLOrContext::CreateChildContext( USHORT nPrefix,
 239                                                                                         const ::rtl::OUString& rLName,
 240                                                                                         const ::com::sun::star::uno::Reference<
 241                                                                                 ::com::sun::star::xml::sax::XAttributeList>& xAttrList )
 242 {
 243         SvXMLImportContext *pContext(0);
 244
 245         const SvXMLTokenMap& rTokenMap(GetScImport().GetFilterElemTokenMap());
 246         switch( rTokenMap.Get( nPrefix, rLName ) )
 247         {
 248                 case XML_TOK_FILTER_AND:
 249                 {
 250                         pContext = new ScXMLAndContext( GetScImport(), nPrefix,
 251                                                                                                                 rLName, xAttrList, pFilterContext);
 252                 }
 253                 break;
 254                 case XML_TOK_FILTER_CONDITION:
 255                 {
 256                         pContext = new ScXMLConditionContext( GetScImport(), nPrefix,
 257                                                                                                                 rLName, xAttrList, pFilterContext);
 258                 }
 259                 break;
 260         }
 261
 262         if( !pContext )
 263                 pContext = new SvXMLImportContext( GetImport(), nPrefix, rLName );
 264
 265         return pContext;
 266 }
 267
 268 void ScXMLOrContext::EndElement()
 269 {
 270         pFilterContext->CloseConnection();
 271 }
 272
 273 ScXMLConditionContext::ScXMLConditionContext( ScXMLImport& rImport,
 274                                                                           USHORT nPrfx,
 275                                                                           const ::rtl::OUString& rLName,
 276                                                                           const ::com::sun::star::uno::Reference<
 277                                                                           ::com::sun::star::xml::sax::XAttributeList>& xAttrList,
 278                                                                                 ScXMLFilterContext* pTempFilterContext) :
 279         SvXMLImportContext( rImport, nPrfx, rLName ),
 280         pFilterContext(pTempFilterContext),
 281         bIsCaseSensitive(sal_False)
 282 {
 283         sDataType = GetXMLToken(XML_TEXT);
 284
 285         sal_Int16 nAttrCount(xAttrList.is() ? xAttrList->getLength() : 0);
 286         const SvXMLTokenMap& rAttrTokenMap(GetScImport().GetFilterConditionAttrTokenMap());
 287         for( sal_Int16 i=0; i < nAttrCount; ++i )
 288         {
 289                 const rtl::OUString& sAttrName(xAttrList->getNameByIndex( i ));
 290                 rtl::OUString aLocalName;
 291                 USHORT nPrefix = GetScImport().GetNamespaceMap().GetKeyByAttrName(
 292                                                                                         sAttrName, &aLocalName );
 293                 const rtl::OUString& sValue(xAttrList->getValueByIndex( i ));
 294
 295                 switch( rAttrTokenMap.Get( nPrefix, aLocalName ) )
 296                 {
 297                         case XML_TOK_CONDITION_ATTR_FIELD_NUMBER :
 298                         {
 299                                 nField = sValue.toInt32();
 300                         }
 301                         break;
 302                         case XML_TOK_CONDITION_ATTR_CASE_SENSITIVE :
 303                         {
 304                                 bIsCaseSensitive = IsXMLToken(sValue, XML_TRUE);
 305                         }
 306                         break;
 307                         case XML_TOK_CONDITION_ATTR_DATA_TYPE :
 308                         {
 309                                 sDataType = sValue;
 310                         }
 311                         break;
 312                         case XML_TOK_CONDITION_ATTR_VALUE :
 313                         {
 314                                 sConditionValue = sValue;
 315                         }
 316                         break;
 317                         case XML_TOK_CONDITION_ATTR_OPERATOR :
 318                         {
 319                                 sOperator = sValue;
 320                         }
 321                         break;
 322                 }
 323         }
 324 }
 325
 326 ScXMLConditionContext::~ScXMLConditionContext()
 327 {
 328 }
 329
 330 SvXMLImportContext *ScXMLConditionContext::CreateChildContext( USHORT nPrefix,
 331                                                                                         const ::rtl::OUString& rLName,
 332                                                                                         const ::com::sun::star::uno::Reference<
 333                                         ::com::sun::star::xml::sax::XAttributeList>& /* xAttrList */ )
 334 {
 335         return new SvXMLImportContext( GetImport(), nPrefix, rLName );
 336 }
 337
 338 void ScXMLConditionContext::getOperatorXML(const rtl::OUString sTempOperator, sheet::FilterOperator& aFilterOperator, sal_Bool& bUseRegularExpressions) const
 339 {
 340         bUseRegularExpressions = sal_False;
 341         if (IsXMLToken(sTempOperator, XML_MATCH))
 342         {
 343                 bUseRegularExpressions = sal_True;
 344                 aFilterOperator = sheet::FilterOperator_EQUAL;
 345         }
 346         else if (IsXMLToken(sTempOperator, XML_NOMATCH))
 347         {
 348                 bUseRegularExpressions = sal_True;
 349                 aFilterOperator = sheet::FilterOperator_NOT_EQUAL;
 350         }
 351         else if (sTempOperator.compareToAscii("=") == 0)
 352                 aFilterOperator = sheet::FilterOperator_EQUAL;
 353         else if (sTempOperator.compareToAscii("!=") == 0)
 354                 aFilterOperator = sheet::FilterOperator_NOT_EQUAL;
 355         else if (IsXMLToken(sTempOperator, XML_BOTTOM_PERCENT))
 356                 aFilterOperator = sheet::FilterOperator_BOTTOM_PERCENT;
 357         else if (IsXMLToken(sTempOperator, XML_BOTTOM_VALUES))
 358                 aFilterOperator = sheet::FilterOperator_BOTTOM_VALUES;
 359         else if (IsXMLToken(sTempOperator, XML_EMPTY))
 360                 aFilterOperator = sheet::FilterOperator_EMPTY;
 361         else if (sTempOperator.compareToAscii(">") == 0)
 362                 aFilterOperator = sheet::FilterOperator_GREATER;
 363         else if (sTempOperator.compareToAscii(">=") == 0)
 364                 aFilterOperator = sheet::FilterOperator_GREATER_EQUAL;
 365         else if (sTempOperator.compareToAscii("<") == 0)
 366                 aFilterOperator = sheet::FilterOperator_LESS;
 367         else if (sTempOperator.compareToAscii("<=") == 0)
 368                 aFilterOperator = sheet::FilterOperator_LESS_EQUAL;
 369         else if (IsXMLToken(sTempOperator, XML_NOEMPTY))
 370                 aFilterOperator = sheet::FilterOperator_NOT_EMPTY;
 371         else if (IsXMLToken(sTempOperator, XML_TOP_PERCENT))
 372                 aFilterOperator = sheet::FilterOperator_TOP_PERCENT;
 373         else if (IsXMLToken(sTempOperator, XML_TOP_VALUES))
 374                 aFilterOperator = sheet::FilterOperator_TOP_VALUES;
 375         else if (IsXMLToken(sTempOperator, XML_BEGINS))
 376                 aFilterOperator = (sheet::FilterOperator) (100+SC_BEGINS_WITH);
 377         else if (IsXMLToken(sTempOperator, XML_ENDS))
 378                 aFilterOperator = (sheet::FilterOperator) (100+SC_ENDS_WITH);
 379         else if (IsXMLToken(sTempOperator, XML_CONTAINS))
 380                 aFilterOperator = (sheet::FilterOperator) (100+SC_CONTAINS);
 381         else if (IsXMLToken(sTempOperator, XML_NOT_CONTAINS))
 382                 aFilterOperator = (sheet::FilterOperator) (100+SC_DOES_NOT_CONTAIN);
 383 }
 384
 385 void ScXMLConditionContext::EndElement()
 386 {
 387         sheet::TableFilterField aFilterField;
 388         if (pFilterContext->GetConnection())
 389                 aFilterField.Connection = sheet::FilterConnection_OR;
 390         else
 391                 aFilterField.Connection = sheet::FilterConnection_AND;
 392         pFilterContext->SetIsCaseSensitive(bIsCaseSensitive);
 393         sal_Bool bUseRegularExpressions;
 394         getOperatorXML(sOperator, aFilterField.Operator, bUseRegularExpressions);
 395         pFilterContext->SetUseRegularExpressions(bUseRegularExpressions);
 396         aFilterField.Field = nField;
 397         if (IsXMLToken(sDataType, XML_NUMBER))
 398         {
 399                 aFilterField.NumericValue = sConditionValue.toDouble();
 400                 aFilterField.IsNumeric = sal_True;
 401         }
 402         else
 403         {
 404                 aFilterField.StringValue = sConditionValue;
 405                 aFilterField.IsNumeric = sal_False;
 406         }
 407         pFilterContext->AddFilterField(aFilterField);
 408 }
 409
 410 //==========================================================================
 411
 412 ScXMLDPFilterContext::ScXMLDPFilterContext( ScXMLImport& rImport,
 413                                                                           USHORT nPrfx,
 414                                                                           const ::rtl::OUString& rLName,
 415                                                                           const ::com::sun::star::uno::Reference<
 416                                                                           ::com::sun::star::xml::sax::XAttributeList>& xAttrList,
 417                                                                                 ScXMLDataPilotTableContext* pTempDataPilotTableContext) :
 418         SvXMLImportContext( rImport, nPrfx, rLName ),
 419         pDataPilotTable(pTempDataPilotTableContext),
 420         aFilterFields(),
 421         nFilterFieldCount(0),
 422         bSkipDuplicates(sal_False),
 423         bCopyOutputData(sal_False),
 424         bUseRegularExpressions(sal_False),
 425         bConnectionOr(sal_True),
 426         bNextConnectionOr(sal_True),
 427         bConditionSourceRange(sal_False)
 428 {
 429         ScDocument* pDoc(GetScImport().GetDocument());
 430
 431         sal_Int16 nAttrCount(xAttrList.is() ? xAttrList->getLength() : 0);
 432         const SvXMLTokenMap& rAttrTokenMap(GetScImport().GetFilterAttrTokenMap());
 433         for( sal_Int16 i=0; i < nAttrCount; ++i )
 434         {
 435                 const rtl::OUString& sAttrName(xAttrList->getNameByIndex( i ));
 436                 rtl::OUString aLocalName;
 437                 USHORT nPrefix(GetScImport().GetNamespaceMap().GetKeyByAttrName(
 438                                                                                         sAttrName, &aLocalName ));
 439                 const rtl::OUString& sValue(xAttrList->getValueByIndex( i ));
 440
 441                 switch( rAttrTokenMap.Get( nPrefix, aLocalName ) )
 442                 {
 443                         case XML_TOK_FILTER_ATTR_TARGET_RANGE_ADDRESS :
 444                         {
 445                                 ScRange aScRange;
 446                                 sal_Int32 nOffset(0);
 447                                 if (ScRangeStringConverter::GetRangeFromString( aScRange, sValue, pDoc, ::formula::FormulaGrammar::CONV_OOO, nOffset ))
 448                                 {
 449                                         aOutputPosition = aScRange.aStart;
 450                                         bCopyOutputData = sal_True;
 451                                 }
 452                         }
 453                         break;
 454                         case XML_TOK_FILTER_ATTR_CONDITION_SOURCE_RANGE_ADDRESS :
 455                         {
 456                                 sal_Int32 nOffset(0);
 457                                 if(ScRangeStringConverter::GetRangeFromString( aConditionSourceRangeAddress, sValue, pDoc, ::formula::FormulaGrammar::CONV_OOO, nOffset ))
 458                                         bConditionSourceRange = sal_True;
 459                         }
 460                         break;
 461                         case XML_TOK_FILTER_ATTR_CONDITION_SOURCE :
 462                         {
 463                                 // not supported by StarOffice
 464                         }
 465                         break;
 466                         case XML_TOK_FILTER_ATTR_DISPLAY_DUPLICATES :
 467                         {
 468                                 bSkipDuplicates = !IsXMLToken(sValue, XML_TRUE);
 469                         }
 470                         break;
 471                 }
 472         }
 473 }
 474
 475 ScXMLDPFilterContext::~ScXMLDPFilterContext()
 476 {
 477 }
 478
 479 SvXMLImportContext *ScXMLDPFilterContext::CreateChildContext( USHORT nPrefix,
 480                                                                                         const ::rtl::OUString& rLName,
 481                                                                                         const ::com::sun::star::uno::Reference<
 482                                                                                 ::com::sun::star::xml::sax::XAttributeList>& xAttrList )
 483 {
 484         SvXMLImportContext *pContext(0);
 485
 486         const SvXMLTokenMap& rTokenMap(GetScImport().GetFilterElemTokenMap());
 487         switch( rTokenMap.Get( nPrefix, rLName ) )
 488         {
 489                 case XML_TOK_FILTER_AND:
 490                 {
 491                         pContext = new ScXMLDPAndContext( GetScImport(), nPrefix,
 492                                                                                                                 rLName, xAttrList, this);
 493                 }
 494                 break;
 495                 case XML_TOK_FILTER_OR:
 496                 {
 497                         pContext = new ScXMLDPOrContext( GetScImport(), nPrefix,
 498                                                                                                                 rLName, xAttrList, this);
 499                 }
 500                 break;
 501                 case XML_TOK_FILTER_CONDITION:
 502                 {
 503                         pContext = new ScXMLDPConditionContext( GetScImport(), nPrefix,
 504                                                                                                                 rLName, xAttrList, this);
 505                 }
 506                 break;
 507         }
 508
 509         if( !pContext )
 510                 pContext = new SvXMLImportContext( GetImport(), nPrefix, rLName );
 511
 512         return pContext;
 513 }
 514
 515 void ScXMLDPFilterContext::EndElement()
 516 {
 517         aFilterFields.bRegExp = bUseRegularExpressions;
 518         aFilterFields.bCaseSens = bIsCaseSensitive;
 519         aFilterFields.bDuplicate = !bSkipDuplicates;
 520 //      pDataPilotTable->SetFilterUseRegularExpressions(bUseRegularExpressions);
 521         if (bCopyOutputData)
 522         {
 523                 pDataPilotTable->SetFilterOutputPosition(aOutputPosition);
 524                 pDataPilotTable->SetFilterCopyOutputData(bCopyOutputData);
 525         }
 526         else
 527                 pDataPilotTable->SetFilterCopyOutputData(sal_False);
 528 //      pDataPilotTable->SetFilterIsCaseSensitive(bIsCaseSensitive);
 529 //      pDataPilotTable->SetFilterSkipDuplicates(bSkipDuplicates);
 530         pDataPilotTable->SetSourceQueryParam(aFilterFields);
 531         if (bConditionSourceRange)
 532                 pDataPilotTable->SetFilterSourceRange(aConditionSourceRangeAddress);
 533 }
 534
 535 void ScXMLDPFilterContext::AddFilterField (const ScQueryEntry& aFilterField)
 536 {
 537         aFilterFields.Resize(nFilterFieldCount + 1);
 538         ScQueryEntry& rEntry(aFilterFields.GetEntry(nFilterFieldCount));
 539         rEntry = aFilterField;
 540         rEntry.bDoQuery = sal_True;
 541         ++nFilterFieldCount;
 542 }
 543
 544 ScXMLDPAndContext::ScXMLDPAndContext( ScXMLImport& rImport,
 545                                                                           USHORT nPrfx,
 546                                                                           const ::rtl::OUString& rLName,
 547                                                                           const ::com::sun::star::uno::Reference<
 548                                       ::com::sun::star::xml::sax::XAttributeList>& /* xAttrList */,
 549                                                                                 ScXMLDPFilterContext* pTempFilterContext) :
 550         SvXMLImportContext( rImport, nPrfx, rLName )
 551 {
 552         pFilterContext = pTempFilterContext;
 553         pFilterContext->OpenConnection(sal_False);
 554 }
 555
 556 ScXMLDPAndContext::~ScXMLDPAndContext()
 557 {
 558 }
 559
 560 SvXMLImportContext *ScXMLDPAndContext::CreateChildContext( USHORT nPrefix,
 561                                                                                         const ::rtl::OUString& rLName,
 562                                                                                         const ::com::sun::star::uno::Reference<
 563                                                                                 ::com::sun::star::xml::sax::XAttributeList>& xAttrList )
 564 {
 565         SvXMLImportContext *pContext(0);
 566
 567         const SvXMLTokenMap& rTokenMap(GetScImport().GetFilterElemTokenMap());
 568         switch( rTokenMap.Get( nPrefix, rLName ) )
 569         {
 570                 case XML_TOK_FILTER_OR:
 571                 {
 572                         // not supported in StarOffice
 573                 }
 574                 break;
 575                 case XML_TOK_FILTER_CONDITION:
 576                 {
 577                         pContext = new ScXMLDPConditionContext( GetScImport(), nPrefix,
 578                                                                                                                 rLName, xAttrList, pFilterContext);
 579                 }
 580                 break;
 581         }
 582
 583         if( !pContext )
 584                 pContext = new SvXMLImportContext( GetImport(), nPrefix, rLName );
 585
 586         return pContext;
 587 }
 588
 589 void ScXMLDPAndContext::EndElement()
 590 {
 591         pFilterContext->CloseConnection();
 592 }
 593
 594 ScXMLDPOrContext::ScXMLDPOrContext( ScXMLImport& rImport,
 595                                                                           USHORT nPrfx,
 596                                                                           const ::rtl::OUString& rLName,
 597                                                                           const ::com::sun::star::uno::Reference<
 598                                       ::com::sun::star::xml::sax::XAttributeList>& /* xAttrList */,
 599                                                                                 ScXMLDPFilterContext* pTempFilterContext) :
 600         SvXMLImportContext( rImport, nPrfx, rLName ),
 601         pFilterContext(pTempFilterContext)
 602 {
 603         pFilterContext->OpenConnection(sal_True);
 604 }
 605
 606 ScXMLDPOrContext::~ScXMLDPOrContext()
 607 {
 608 }
 609
 610 SvXMLImportContext *ScXMLDPOrContext::CreateChildContext( USHORT nPrefix,
 611                                                                                         const ::rtl::OUString& rLName,
 612                                                                                         const ::com::sun::star::uno::Reference<
 613                                                                                 ::com::sun::star::xml::sax::XAttributeList>& xAttrList )
 614 {
 615         SvXMLImportContext *pContext(0);
 616
 617         const SvXMLTokenMap& rTokenMap(GetScImport().GetFilterElemTokenMap());
 618         switch( rTokenMap.Get( nPrefix, rLName ) )
 619         {
 620                 case XML_TOK_FILTER_AND:
 621                 {
 622                         pContext = new ScXMLDPAndContext( GetScImport(), nPrefix,
 623                                                                                                                 rLName, xAttrList, pFilterContext);
 624                 }
 625                 break;
 626                 case XML_TOK_FILTER_CONDITION:
 627                 {
 628                         pContext = new ScXMLDPConditionContext( GetScImport(), nPrefix,
 629                                                                                                                 rLName, xAttrList, pFilterContext);
 630                 }
 631                 break;
 632         }
 633
 634         if( !pContext )
 635                 pContext = new SvXMLImportContext( GetImport(), nPrefix, rLName );
 636
 637         return pContext;
 638 }
 639
 640 void ScXMLDPOrContext::EndElement()
 641 {
 642         pFilterContext->CloseConnection();
 643 }
 644
 645 ScXMLDPConditionContext::ScXMLDPConditionContext( ScXMLImport& rImport,
 646                                                                           USHORT nPrfx,
 647                                                                           const ::rtl::OUString& rLName,
 648                                                                           const ::com::sun::star::uno::Reference<
 649                                                                           ::com::sun::star::xml::sax::XAttributeList>& xAttrList,
 650                                                                                 ScXMLDPFilterContext* pTempFilterContext) :
 651         SvXMLImportContext( rImport, nPrfx, rLName ),
 652         pFilterContext(pTempFilterContext),
 653         sDataType(GetXMLToken(XML_TEXT)),
 654         bIsCaseSensitive(sal_False)
 655 {
 656
 657         sal_Int16 nAttrCount(xAttrList.is() ? xAttrList->getLength() : 0);
 658         const SvXMLTokenMap& rAttrTokenMap(GetScImport().GetFilterConditionAttrTokenMap());
 659         for( sal_Int16 i=0; i < nAttrCount; ++i )
 660         {
 661                 const rtl::OUString& sAttrName(xAttrList->getNameByIndex( i ));
 662                 rtl::OUString aLocalName;
 663                 USHORT nPrefix(GetScImport().GetNamespaceMap().GetKeyByAttrName(
 664                                                                                         sAttrName, &aLocalName ));
 665                 const rtl::OUString& sValue(xAttrList->getValueByIndex( i ));
 666
 667                 switch( rAttrTokenMap.Get( nPrefix, aLocalName ) )
 668                 {
 669                         case XML_TOK_CONDITION_ATTR_FIELD_NUMBER :
 670                         {
 671                                 nField = sValue.toInt32();
 672                         }
 673                         break;
 674                         case XML_TOK_CONDITION_ATTR_CASE_SENSITIVE :
 675                         {
 676                                 bIsCaseSensitive = IsXMLToken(sValue, XML_TRUE);
 677                         }
 678                         break;
 679                         case XML_TOK_CONDITION_ATTR_DATA_TYPE :
 680                         {
 681                                 sDataType = sValue;
 682                         }
 683                         break;
 684                         case XML_TOK_CONDITION_ATTR_VALUE :
 685                         {
 686                                 sConditionValue = sValue;
 687                         }
 688                         break;
 689                         case XML_TOK_CONDITION_ATTR_OPERATOR :
 690                         {
 691                                 sOperator = sValue;
 692                         }
 693                         break;
 694                 }
 695         }
 696 }
 697
 698 ScXMLDPConditionContext::~ScXMLDPConditionContext()
 699 {
 700 }
 701
 702 SvXMLImportContext *ScXMLDPConditionContext::CreateChildContext( USHORT nPrefix,
 703                                                                                         const ::rtl::OUString& rLName,
 704                                                                                         const ::com::sun::star::uno::Reference<
 705                                         ::com::sun::star::xml::sax::XAttributeList>& /* xAttrList */ )
 706 {
 707         return new SvXMLImportContext( GetImport(), nPrefix, rLName );
 708 }
 709
 710 void ScXMLDPConditionContext::getOperatorXML(const rtl::OUString sTempOperator, ScQueryOp& aFilterOperator, sal_Bool& bUseRegularExpressions,
 711                                                                                         double& dVal) const
 712 {
 713         bUseRegularExpressions = sal_False;
 714         if (IsXMLToken(sTempOperator, XML_MATCH))
 715         {
 716                 bUseRegularExpressions = sal_True;
 717                 aFilterOperator = SC_EQUAL;
 718         }
 719         else if (IsXMLToken(sTempOperator, XML_NOMATCH))
 720         {
 721                 bUseRegularExpressions = sal_True;
 722                 aFilterOperator = SC_NOT_EQUAL;
 723         }
 724         else if (sTempOperator.compareToAscii("=") == 0)
 725                 aFilterOperator = SC_EQUAL;
 726         else if (sTempOperator.compareToAscii("!=") == 0)
 727                 aFilterOperator = SC_NOT_EQUAL;
 728         else if (IsXMLToken(sTempOperator, XML_BOTTOM_PERCENT))
 729                 aFilterOperator = SC_BOTPERC;
 730         else if (IsXMLToken(sTempOperator, XML_BOTTOM_VALUES))
 731                 aFilterOperator = SC_BOTVAL;
 732         else if (IsXMLToken(sTempOperator, XML_EMPTY))
 733                 dVal = SC_EMPTYFIELDS;
 734         else if (sTempOperator.compareToAscii(">") == 0)
 735                 aFilterOperator = SC_GREATER;
 736         else if (sTempOperator.compareToAscii(">=") == 0)
 737                 aFilterOperator = SC_GREATER_EQUAL;
 738         else if (sTempOperator.compareToAscii("<") == 0)
 739                 aFilterOperator = SC_LESS;
 740         else if (sTempOperator.compareToAscii("<=") == 0)
 741                 aFilterOperator = SC_LESS_EQUAL;
 742         else if (IsXMLToken(sTempOperator, XML_NOEMPTY))
 743                 dVal = SC_NONEMPTYFIELDS;
 744         else if (IsXMLToken(sTempOperator, XML_TOP_PERCENT))
 745                 aFilterOperator = SC_TOPPERC;
 746         else if (IsXMLToken(sTempOperator, XML_TOP_VALUES))
 747                 aFilterOperator = SC_TOPVAL;
 748         else if (IsXMLToken(sTempOperator, XML_BEGINS))
 749                 aFilterOperator = SC_BEGINS_WITH;
 750         else if (IsXMLToken(sTempOperator, XML_ENDS))
 751                 aFilterOperator = SC_ENDS_WITH;
 752         else if (IsXMLToken(sTempOperator, XML_CONTAINS))
 753                 aFilterOperator = SC_CONTAINS;
 754         else if (IsXMLToken(sTempOperator, XML_NOT_CONTAINS))
 755                 aFilterOperator = SC_DOES_NOT_CONTAIN;
 756 }
 757
 758 void ScXMLDPConditionContext::EndElement()
 759 {
 760         ScQueryEntry aFilterField;
 761         if (pFilterContext->GetConnection())
 762                 aFilterField.eConnect = SC_OR;
 763         else
 764                 aFilterField.eConnect = SC_AND;
 765         pFilterContext->SetIsCaseSensitive(bIsCaseSensitive);
 766         sal_Bool bUseRegularExpressions;
 767         double dVal(0.0);
 768         getOperatorXML(sOperator, aFilterField.eOp, bUseRegularExpressions, dVal);
 769         pFilterContext->SetUseRegularExpressions(bUseRegularExpressions);
 770         aFilterField.nField = nField;
 771         if (IsXMLToken(sDataType, XML_NUMBER))
 772         {
 773                 aFilterField.nVal = sConditionValue.toDouble();
 774         *aFilterField.pStr = sConditionValue;
 775                 aFilterField.bQueryByString = sal_False;
 776         if (dVal != 0.0)
 777         {
 778                 aFilterField.nVal = dVal;
 779             *aFilterField.pStr = EMPTY_STRING;
 780         }
 781         }
 782         else
 783         {
 784                 aFilterField.pStr = new String(sConditionValue);
 785                 aFilterField.bQueryByString = sal_True;
 786                 aFilterField.nVal = 0;
 787         }
 788         pFilterContext->AddFilterField(aFilterField);
 789 }
 790
 791
 792