xmloff/source/style/xmlexppr.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 <com/sun/star/container/XNameContainer.hpp>
  21 #include <com/sun/star/xml/AttributeData.hpp>
  22 #include <com/sun/star/beans/XPropertyState.hpp>
  23 #include <com/sun/star/beans/XMultiPropertySet.hpp>
  24 #include <com/sun/star/beans/XTolerantMultiPropertySet.hpp>
  25 #include <com/sun/star/beans/TolerantPropertySetResultType.hpp>
  26 #include <rtl/ustrbuf.hxx>
  27 #include <list>
  28 #include <map>
  29
  30 #include <xmloff/xmlexppr.hxx>
  31 #include <xmloff/xmltoken.hxx>
  32 #include <xmloff/attrlist.hxx>
  33 #include <xmloff/nmspmap.hxx>
  34 #include <xmloff/xmlnmspe.hxx>
  35 #include <xmloff/xmlexp.hxx>
  36 #include <xmloff/xmlprmap.hxx>
  37 #include <xmloff/maptype.hxx>
  38 #include <xmloff/xmltypes.hxx>
  39 #include <xmloff/xmlprhdl.hxx>
  40
  41 using namespace ::std;
  42 using namespace ::com::sun::star;
  43 using namespace ::com::sun::star::beans;
  44 using namespace ::com::sun::star::uno;
  45 using namespace ::com::sun::star::lang;
  46 using namespace ::xmloff::token;
  47
  48 #define GET_PROP_TYPE( f ) static_cast<sal_uInt16>((f & XML_TYPE_PROP_MASK) >> XML_TYPE_PROP_SHIFT)
  49 #define ENTRY(t) { GET_PROP_TYPE(XML_TYPE_PROP_##t), XML_##t##_PROPERTIES }
  50
  51 namespace {
  52
  53 struct XMLPropTokens_Impl
  54 {
  55     sal_uInt16 nType;
  56     XMLTokenEnum eToken;
  57 };
  58
  59 const sal_uInt16 MAX_PROP_TYPES =
  60     (XML_TYPE_PROP_END >> XML_TYPE_PROP_SHIFT) -
  61     (XML_TYPE_PROP_START >> XML_TYPE_PROP_SHIFT);
  62
  63 XMLPropTokens_Impl aPropTokens[MAX_PROP_TYPES] =
  64 {
  65     ENTRY(CHART),
  66     ENTRY(GRAPHIC),
  67     ENTRY(TABLE),
  68     ENTRY(TABLE_COLUMN),
  69     ENTRY(TABLE_ROW),
  70     ENTRY(TABLE_CELL),
  71     ENTRY(LIST_LEVEL),
  72     ENTRY(PARAGRAPH),
  73     ENTRY(TEXT),
  74     ENTRY(DRAWING_PAGE),
  75     ENTRY(PAGE_LAYOUT),
  76     ENTRY(HEADER_FOOTER),
  77     ENTRY(RUBY),
  78     ENTRY(SECTION)
  79 };
  80
  81 // public methods
  82
  83 // Take all properties of the XPropertySet which are also found in the
  84 // XMLPropertyMapEntry-array and which are not set to their default-value,
  85 // if a state is available.
  86 // After that I call the method 'ContextFilter'.
  87
  88 typedef std::list<XMLPropertyState> XMLPropertyStateList_Impl;
  89
  90 class XMLPropertyStates_Impl
  91 {
  92     XMLPropertyStateList_Impl           aPropStates;
  93     XMLPropertyStateList_Impl::iterator aLastItr;
  94     sal_uInt32                          nCount;
  95 public:
  96     XMLPropertyStates_Impl();
  97     void AddPropertyState(const XMLPropertyState& rPropState);
  98     void FillPropertyStateVector(std::vector<XMLPropertyState>& rVector);
  99 };
 100
 101 XMLPropertyStates_Impl::XMLPropertyStates_Impl() :
 102     aPropStates(),
 103     nCount(0)
 104 {
 105     aLastItr = aPropStates.begin();
 106 }
 107
 108 void XMLPropertyStates_Impl::AddPropertyState(
 109         const XMLPropertyState& rPropState)
 110 {
 111     XMLPropertyStateList_Impl::iterator aItr = aPropStates.begin();
 112     bool bInserted(false);
 113     if (nCount)
 114     {
 115         if (aLastItr->mnIndex < rPropState.mnIndex)
 116             aItr = ++aLastItr;
 117     }
 118     do
 119     {
 120         // TODO: one path required only
 121         if (aItr == aPropStates.end())
 122         {
 123             aLastItr = aPropStates.insert(aPropStates.end(), rPropState);
 124             bInserted = true;
 125             nCount++;
 126         }
 127         else if (aItr->mnIndex > rPropState.mnIndex)
 128         {
 129             aLastItr = aPropStates.insert(aItr, rPropState);
 130             bInserted = true;
 131             nCount++;
 132         }
 133     }
 134     while(!bInserted && (aItr++ != aPropStates.end()));
 135 }
 136
 137 void XMLPropertyStates_Impl::FillPropertyStateVector(
 138         std::vector<XMLPropertyState>& rVector)
 139 {
 140     if (nCount)
 141     {
 142         rVector.resize(nCount, XMLPropertyState(-1));
 143         ::std::copy( aPropStates.begin(), aPropStates.end(), rVector.begin() );
 144     }
 145 }
 146
 147 class FilterPropertyInfo_Impl
 148 {
 149     const OUString     sApiName;
 150     std::list<sal_uInt32>   aIndexes;
 151
 152 public:
 153
 154     FilterPropertyInfo_Impl( const OUString& rApiName,
 155                              const sal_uInt32 nIndex);
 156
 157     const OUString& GetApiName() const { return sApiName; }
 158     std::list<sal_uInt32>& GetIndexes() { return aIndexes; }
 159
 160     // for sort
 161     bool operator< ( const FilterPropertyInfo_Impl& rArg ) const
 162     {
 163         return (GetApiName() < rArg.GetApiName());
 164     }
 165 };
 166
 167 FilterPropertyInfo_Impl::FilterPropertyInfo_Impl(
 168         const OUString& rApiName,
 169         const sal_uInt32 nIndex ) :
 170     sApiName( rApiName )
 171 {
 172     aIndexes.push_back(nIndex);
 173 }
 174
 175 typedef std::list<FilterPropertyInfo_Impl> FilterPropertyInfoList_Impl;
 176
 177 class FilterPropertiesInfo_Impl
 178 {
 179     sal_uInt32                              nCount;
 180     FilterPropertyInfoList_Impl             aPropInfos;
 181     FilterPropertyInfoList_Impl::iterator   aLastItr;
 182
 183     Sequence <OUString>                     *pApiNames;
 184
 185 public:
 186     FilterPropertiesInfo_Impl();
 187     ~FilterPropertiesInfo_Impl();
 188
 189     void AddProperty(const OUString& rApiName, const sal_uInt32 nIndex);
 190     const uno::Sequence<OUString>& GetApiNames();
 191     void FillPropertyStateArray(
 192             vector< XMLPropertyState >& rPropStates,
 193             const Reference< XPropertySet >& xPropSet,
 194             const rtl::Reference< XMLPropertySetMapper >& maPropMapper,
 195             const bool bDefault = false);
 196     sal_uInt32 GetPropertyCount() const { return nCount; }
 197 };
 198
 199 FilterPropertiesInfo_Impl::FilterPropertiesInfo_Impl() :
 200     nCount(0),
 201     aPropInfos(),
 202     pApiNames( 0 )
 203 {
 204     aLastItr = aPropInfos.begin();
 205 }
 206
 207 FilterPropertiesInfo_Impl::~FilterPropertiesInfo_Impl()
 208 {
 209     delete pApiNames;
 210 }
 211
 212 void FilterPropertiesInfo_Impl::AddProperty(
 213         const OUString& rApiName, const sal_uInt32 nIndex)
 214 {
 215     aPropInfos.push_back(FilterPropertyInfo_Impl(rApiName, nIndex));
 216     nCount++;
 217
 218     OSL_ENSURE( !pApiNames, "performance warning: API names already retrieved" );
 219     if( pApiNames )
 220     {
 221         delete pApiNames;
 222         pApiNames = NULL;
 223     }
 224 }
 225
 226 const uno::Sequence<OUString>& FilterPropertiesInfo_Impl::GetApiNames()
 227 {
 228     OSL_ENSURE(nCount == aPropInfos.size(), "wrong property count");
 229     if( !pApiNames )
 230     {
 231         // we have to do three things:
 232         // 1) sort API names,
 233         // 2) merge duplicates,
 234         // 3) construct sequence
 235
 236         // sort names
 237         aPropInfos.sort();
 238
 239         // merge duplicates
 240         if ( nCount > 1 )
 241         {
 242             FilterPropertyInfoList_Impl::iterator aOld = aPropInfos.begin();
 243             FilterPropertyInfoList_Impl::iterator aEnd = aPropInfos.end();
 244             FilterPropertyInfoList_Impl::iterator aCurrent = aOld;
 245             ++aCurrent;
 246
 247             while ( aCurrent != aEnd )
 248             {
 249                 // equal to next element?
 250                 if ( aOld->GetApiName().equals( aCurrent->GetApiName() ) )
 251                 {
 252                     // if equal: merge index lists
 253                     aOld->GetIndexes().merge( aCurrent->GetIndexes() );
 254                     // erase element, and continue with next
 255                     aCurrent = aPropInfos.erase( aCurrent );
 256                     nCount--;
 257                 }
 258                 else
 259                 {
 260                     // remember old element and continue with next
 261                     aOld = aCurrent;
 262                     ++aCurrent;
 263                 }
 264             }
 265         }
 266
 267         // construct sequence
 268         pApiNames = new Sequence < OUString >( nCount );
 269         OUString *pNames = pApiNames->getArray();
 270         FilterPropertyInfoList_Impl::iterator aItr = aPropInfos.begin();
 271         FilterPropertyInfoList_Impl::iterator aEnd = aPropInfos.end();
 272         for ( ; aItr != aEnd; ++aItr, ++pNames)
 273             *pNames = aItr->GetApiName();
 274     }
 275
 276     return *pApiNames;
 277 }
 278
 279 void FilterPropertiesInfo_Impl::FillPropertyStateArray(
 280         vector< XMLPropertyState >& rPropStates,
 281         const Reference< XPropertySet >& rPropSet,
 282         const rtl::Reference< XMLPropertySetMapper >& rPropMapper,
 283         const bool bDefault )
 284 {
 285     XMLPropertyStates_Impl aPropStates;
 286
 287     const uno::Sequence<OUString>& rApiNames = GetApiNames();
 288
 289     Reference < XTolerantMultiPropertySet > xTolPropSet( rPropSet, UNO_QUERY );
 290     if (xTolPropSet.is())
 291     {
 292         if (!bDefault)
 293         {
 294             Sequence < beans::GetDirectPropertyTolerantResult > aResults(xTolPropSet->getDirectPropertyValuesTolerant(rApiNames));
 295             sal_Int32 nResultCount(aResults.getLength());
 296             if (nResultCount > 0)
 297             {
 298                 const beans::GetDirectPropertyTolerantResult *pResults = aResults.getConstArray();
 299                 FilterPropertyInfoList_Impl::iterator aPropIter(aPropInfos.begin());
 300                 XMLPropertyState aNewProperty( -1 );
 301                 sal_uInt32 i = 0;
 302                 while (nResultCount > 0 && i < nCount)
 303                 {
 304                     if (pResults->Name == aPropIter->GetApiName())
 305                     {
 306                         aNewProperty.mnIndex = -1;
 307                         aNewProperty.maValue = pResults->Value;
 308
 309                         for( std::list<sal_uInt32>::iterator aIndexItr(aPropIter->GetIndexes().begin());
 310                             aIndexItr != aPropIter->GetIndexes().end();
 311                             ++aIndexItr )
 312                         {
 313                             aNewProperty.mnIndex = *aIndexItr;
 314                             aPropStates.AddPropertyState( aNewProperty );
 315                         }
 316                         ++pResults;
 317                         --nResultCount;
 318                     }
 319                     ++aPropIter;
 320                     ++i;
 321                 }
 322             }
 323         }
 324         else
 325         {
 326             Sequence < beans::GetPropertyTolerantResult > aResults(xTolPropSet->getPropertyValuesTolerant(rApiNames));
 327             OSL_ENSURE( rApiNames.getLength() == aResults.getLength(), "wrong implemented XTolerantMultiPropertySet" );
 328             const beans::GetPropertyTolerantResult *pResults = aResults.getConstArray();
 329             FilterPropertyInfoList_Impl::iterator aPropIter(aPropInfos.begin());
 330             XMLPropertyState aNewProperty( -1 );
 331             sal_uInt32 nResultCount(aResults.getLength());
 332             OSL_ENSURE( nCount == nResultCount, "wrong implemented XTolerantMultiPropertySet??" );
 333             for( sal_uInt32 i = 0; i < nResultCount; ++i )
 334             {
 335                 if ((pResults->Result == beans::TolerantPropertySetResultType::SUCCESS) &&
 336                     ((pResults->State == PropertyState_DIRECT_VALUE) || (pResults->State == PropertyState_DEFAULT_VALUE)))
 337                 {
 338                     aNewProperty.mnIndex = -1;
 339                     aNewProperty.maValue = pResults->Value;
 340
 341                     for( std::list<sal_uInt32>::iterator aIndexItr(aPropIter->GetIndexes().begin());
 342                         aIndexItr != aPropIter->GetIndexes().end();
 343                         ++aIndexItr )
 344                     {
 345                         aNewProperty.mnIndex = *aIndexItr;
 346                         aPropStates.AddPropertyState( aNewProperty );
 347                     }
 348                 }
 349                 ++pResults;
 350                 ++aPropIter;
 351             }
 352         }
 353     }
 354     else
 355     {
 356         Sequence < PropertyState > aStates;
 357         const PropertyState *pStates = 0;
 358         Reference< XPropertyState > xPropState( rPropSet, UNO_QUERY );
 359         if( xPropState.is() )
 360         {
 361             aStates = xPropState->getPropertyStates( rApiNames );
 362             pStates = aStates.getConstArray();
 363         }
 364
 365         Reference < XMultiPropertySet > xMultiPropSet( rPropSet, UNO_QUERY );
 366         if( xMultiPropSet.is() && !bDefault )
 367         {
 368             Sequence < Any > aValues;
 369             if( pStates )
 370             {
 371                 // step 1: get value count
 372                 sal_uInt32 nValueCount = 0;
 373                 sal_uInt32 i;
 374
 375                 for( i = 0; i < nCount; ++i, ++pStates )
 376                 {
 377                     if( (*pStates == PropertyState_DIRECT_VALUE)/* || (bDefault && (*pStates == PropertyState_DEFAULT_VALUE))*/ )
 378                         nValueCount++;
 379                 }
 380
 381                 if( nValueCount )
 382                 {
 383                     // step 2: collect property names
 384                     Sequence < OUString > aAPINames( nValueCount );
 385                     OUString *pAPINames = aAPINames.getArray();
 386
 387                     ::std::vector< FilterPropertyInfoList_Impl::iterator > aPropIters;
 388                     aPropIters.reserve( nValueCount );
 389
 390                     FilterPropertyInfoList_Impl::iterator aItr = aPropInfos.begin();
 391                     OSL_ENSURE(aItr != aPropInfos.end(),"Invalid iterator!");
 392
 393                     pStates = aStates.getConstArray();
 394                     i = 0;
 395                     while( i < nValueCount )
 396                     {
 397                         if( (*pStates == PropertyState_DIRECT_VALUE)/* || (bDefault && (*pStates == PropertyState_DEFAULT_VALUE))*/ )
 398                         {
 399                             *pAPINames++ = aItr->GetApiName();
 400                             aPropIters.push_back( aItr );
 401                             ++i;
 402                         }
 403                         ++aItr;
 404                         ++pStates;
 405                     }
 406
 407                     aValues = xMultiPropSet->getPropertyValues( aAPINames );
 408                     const Any *pValues = aValues.getConstArray();
 409
 410                     ::std::vector< FilterPropertyInfoList_Impl::iterator >::const_iterator
 411                         pPropIter = aPropIters.begin();
 412
 413                     XMLPropertyState aNewProperty( -1 );
 414                     for( i = 0; i < nValueCount; ++i )
 415                     {
 416                         aNewProperty.mnIndex = -1;
 417                         aNewProperty.maValue = *pValues;
 418
 419                         const ::std::list< sal_uInt32 >& rIndexes( (*pPropIter)->GetIndexes() );
 420                         for (   std::list<sal_uInt32>::const_iterator aIndexItr = rIndexes.begin();
 421                                 aIndexItr != rIndexes.end();
 422                                 ++aIndexItr
 423                             )
 424                         {
 425                             aNewProperty.mnIndex = *aIndexItr;
 426                             aPropStates.AddPropertyState( aNewProperty );
 427                         }
 428
 429                         ++pPropIter;
 430                         ++pValues;
 431                     }
 432                 }
 433             }
 434             else
 435             {
 436                 aValues = xMultiPropSet->getPropertyValues( rApiNames );
 437                 const Any *pValues = aValues.getConstArray();
 438
 439                 FilterPropertyInfoList_Impl::iterator aItr = aPropInfos.begin();
 440                 for(sal_uInt32 i = 0; i < nCount; ++i)
 441                 {
 442                     // The value is stored in the PropertySet itself, add to list.
 443                     XMLPropertyState aNewProperty( -1 );
 444                     aNewProperty.maValue = *pValues;
 445                     ++pValues;
 446                     for( std::list<sal_uInt32>::iterator aIndexItr =
 447                             aItr->GetIndexes().begin();
 448                         aIndexItr != aItr->GetIndexes().end();
 449                         ++aIndexItr )
 450                     {
 451                         aNewProperty.mnIndex = *aIndexItr;
 452                         aPropStates.AddPropertyState( aNewProperty );
 453                     }
 454                     ++aItr;
 455                 }
 456             }
 457         }
 458         else
 459         {
 460             FilterPropertyInfoList_Impl::iterator aItr = aPropInfos.begin();
 461             for(sal_uInt32 i = 0; i < nCount; ++i)
 462             {
 463                 bool bDirectValue =
 464                     !pStates || *pStates == PropertyState_DIRECT_VALUE;
 465                 if( bDirectValue || bDefault )
 466                 {
 467                     // The value is stored in the PropertySet itself, add to list.
 468                     bool bGotValue = false;
 469                     XMLPropertyState aNewProperty( -1 );
 470                     for( std::list<sal_uInt32>::const_iterator aIndexItr =
 471                             aItr->GetIndexes().begin();
 472                         aIndexItr != aItr->GetIndexes().end();
 473                         ++aIndexItr )
 474                     {
 475                         if( bDirectValue ||
 476                             (rPropMapper->GetEntryFlags( *aIndexItr ) &
 477                                             MID_FLAG_DEFAULT_ITEM_EXPORT) != 0 )
 478                         {
 479                             try
 480                             {
 481                                 if( !bGotValue )
 482                                 {
 483                                     aNewProperty.maValue =
 484                                         rPropSet->getPropertyValue( aItr->GetApiName() );
 485                                     bGotValue = true;
 486                                 }
 487                                 aNewProperty.mnIndex = *aIndexItr;
 488                                 aPropStates.AddPropertyState( aNewProperty );
 489                             }
 490                             catch( UnknownPropertyException& )
 491                             {
 492                                 // might be a problem of getImplemenetationId
 493                                 OSL_ENSURE( false, "unknown property in getPropertyValue" );
 494                             }
 495
 496                         }
 497                     }
 498                 }
 499
 500                 ++aItr;
 501                 if( pStates )
 502                     ++pStates;
 503             }
 504         }
 505     }
 506     aPropStates.FillPropertyStateVector(rPropStates);
 507 }
 508
 509 }
 510
 511 struct SvXMLExportPropertyMapper::Impl
 512 {
 513     typedef std::map<css::uno::Reference<css::beans::XPropertySetInfo>, FilterPropertiesInfo_Impl*> CacheType;
 514     CacheType maCache;
 515
 516     rtl::Reference<SvXMLExportPropertyMapper> mxNextMapper;
 517     rtl::Reference<XMLPropertySetMapper> mxPropMapper;
 518
 519     OUString maStyleName;
 520
 521     ~Impl()
 522     {
 523         CacheType::iterator it = maCache.begin(), itEnd = maCache.end();
 524         for (; it != itEnd; ++it)
 525             delete it->second;
 526     }
 527 };
 528
 529 // ctor/dtor , class SvXMLExportPropertyMapper
 530
 531 SvXMLExportPropertyMapper::SvXMLExportPropertyMapper(
 532         const rtl::Reference< XMLPropertySetMapper >& rMapper ) :
 533     mpImpl(new Impl)
 534 {
 535     mpImpl->mxPropMapper = rMapper;
 536 }
 537
 538 SvXMLExportPropertyMapper::~SvXMLExportPropertyMapper()
 539 {
 540     delete mpImpl;
 541 }
 542
 543 void SvXMLExportPropertyMapper::ChainExportMapper(
 544         const rtl::Reference< SvXMLExportPropertyMapper>& rMapper )
 545 {
 546     // add map entries from rMapper to current map
 547     mpImpl->mxPropMapper->AddMapperEntry( rMapper->getPropertySetMapper() );
 548     // rMapper uses the same map as 'this'
 549     rMapper->mpImpl->mxPropMapper = mpImpl->mxPropMapper;
 550
 551     // set rMapper as last mapper in current chain
 552     rtl::Reference< SvXMLExportPropertyMapper > xNext = mpImpl->mxNextMapper;
 553     if( xNext.is())
 554     {
 555         while (xNext->mpImpl->mxNextMapper.is())
 556             xNext = xNext->mpImpl->mxNextMapper;
 557         xNext->mpImpl->mxNextMapper = rMapper;
 558     }
 559     else
 560         mpImpl->mxNextMapper = rMapper;
 561
 562     // if rMapper was already chained, correct
 563     // map pointer of successors
 564     xNext = rMapper;
 565
 566     while (xNext->mpImpl->mxNextMapper.is())
 567     {
 568         xNext = xNext->mpImpl->mxNextMapper;
 569         xNext->mpImpl->mxPropMapper = mpImpl->mxPropMapper;
 570     }
 571 }
 572
 573 std::vector<XMLPropertyState> SvXMLExportPropertyMapper::Filter(
 574     const uno::Reference<beans::XPropertySet>& rPropSet, bool bEnableFoFontFamily ) const
 575 {
 576     return _Filter(rPropSet, false, bEnableFoFontFamily);
 577 }
 578
 579 std::vector<XMLPropertyState> SvXMLExportPropertyMapper::FilterDefaults(
 580     const uno::Reference<beans::XPropertySet>& rPropSet, bool bEnableFoFontFamily ) const
 581 {
 582     return _Filter(rPropSet, true, bEnableFoFontFamily);
 583 }
 584
 585 vector<XMLPropertyState> SvXMLExportPropertyMapper::_Filter(
 586     const Reference<XPropertySet>& xPropSet, bool bDefault, bool bEnableFoFontFamily ) const
 587 {
 588     vector< XMLPropertyState > aPropStateArray;
 589
 590     // Retrieve XPropertySetInfo and XPropertyState
 591     Reference< XPropertySetInfo > xInfo( xPropSet->getPropertySetInfo() );
 592     if( !xInfo.is() )
 593         return aPropStateArray;
 594
 595     sal_Int32 nProps = mpImpl->mxPropMapper->GetEntryCount();
 596
 597     FilterPropertiesInfo_Impl *pFilterInfo = 0;
 598
 599     Impl::CacheType::iterator aIter = mpImpl->maCache.find(xInfo);
 600     if (aIter != mpImpl->maCache.end())
 601         pFilterInfo = (*aIter).second;
 602
 603     bool bDelInfo = false;
 604     if( !pFilterInfo )
 605     {
 606         const SvtSaveOptions::ODFDefaultVersion nCurrentVersion( SvtSaveOptions().GetODFDefaultVersion() );
 607         pFilterInfo = new FilterPropertiesInfo_Impl;
 608         for( sal_Int32 i=0; i < nProps; i++ )
 609         {
 610             // Are we allowed to ask for the property? (MID_FLAG_NO_PROP..)
 611             // Does the PropertySet contain name of mpEntries-array ?
 612             const OUString& rAPIName = mpImpl->mxPropMapper->GetEntryAPIName( i );
 613             const sal_Int32 nFlags = mpImpl->mxPropMapper->GetEntryFlags( i );
 614             if( (0 == (nFlags & MID_FLAG_NO_PROPERTY_EXPORT)) &&
 615                 ( (0 != (nFlags & MID_FLAG_MUST_EXIST)) ||
 616                   xInfo->hasPropertyByName( rAPIName ) ) )
 617             {
 618                 const SvtSaveOptions::ODFDefaultVersion nEarliestODFVersionForExport(
 619                         mpImpl->mxPropMapper->GetEarliestODFVersionForExport(i));
 620                 if( nCurrentVersion >= nEarliestODFVersionForExport
 621                         || nCurrentVersion == SvtSaveOptions::ODFVER_UNKNOWN
 622                         || nEarliestODFVersionForExport == SvtSaveOptions::ODFVER_UNKNOWN )
 623                     pFilterInfo->AddProperty(rAPIName, i);
 624             }
 625         }
 626
 627         // Check whether the property set info is destroyed if it is assigned to
 628         // a weak reference only; If it is destroyed, then every instance of
 629         // getPropertySetInfo returns a new object; such property set infos must
 630         // not be cached:
 631         WeakReference < XPropertySetInfo > xWeakInfo( xInfo );
 632         xInfo = 0;
 633         xInfo = xWeakInfo;
 634         if( xInfo.is() )
 635         {
 636             mpImpl->maCache.insert(Impl::CacheType::value_type(xInfo, pFilterInfo));
 637         }
 638         else
 639             bDelInfo = true;
 640     }
 641
 642     if( pFilterInfo->GetPropertyCount() )
 643     {
 644         try
 645         {
 646             pFilterInfo->FillPropertyStateArray(
 647                 aPropStateArray, xPropSet, mpImpl->mxPropMapper, bDefault);
 648         }
 649         catch( UnknownPropertyException& )
 650         {
 651             // might be a problem of getImplemenetationId
 652             OSL_ENSURE( false, "unknown property in getPropertyStates" );
 653         }
 654     }
 655
 656     // Call centext-filter
 657     if( !aPropStateArray.empty() )
 658         ContextFilter(bEnableFoFontFamily, aPropStateArray, xPropSet);
 659
 660     // Have to do if we change from a vector to a list or something like that
 661
 662     if( bDelInfo )
 663         delete pFilterInfo;
 664
 665     return aPropStateArray;
 666 }
 667
 668 void SvXMLExportPropertyMapper::ContextFilter(
 669         bool bEnableFoFontFamily,
 670         vector< XMLPropertyState >& rProperties,
 671         Reference< XPropertySet > rPropSet ) const
 672 {
 673     // Derived class could implement this.
 674     if (mpImpl->mxNextMapper.is())
 675         mpImpl->mxNextMapper->ContextFilter(bEnableFoFontFamily, rProperties, rPropSet);
 676 }
 677
 678 // Compares two Sequences of XMLPropertyState:
 679 //  1.Number of elements equal ?
 680 //  2.Index of each element equal ? (So I know whether the propertynames are the same)
 681 //  3.Value of each element equal ?
 682 bool SvXMLExportPropertyMapper::Equals(
 683         const vector< XMLPropertyState >& aProperties1,
 684         const vector< XMLPropertyState >& aProperties2 ) const
 685 {
 686     bool bRet = true;
 687     sal_uInt32 nCount = aProperties1.size();
 688
 689     if( nCount == aProperties2.size() )
 690     {
 691         sal_uInt32 nIndex = 0;
 692         while( bRet && nIndex < nCount )
 693         {
 694             const XMLPropertyState& rProp1 = aProperties1[ nIndex ];
 695             const XMLPropertyState& rProp2 = aProperties2[ nIndex ];
 696
 697             // Compare index. If equal, compare value
 698             if( rProp1.mnIndex == rProp2.mnIndex )
 699             {
 700                 if( rProp1.mnIndex != -1 )
 701                 {
 702                     // Now compare values
 703                     if ( (mpImpl->mxPropMapper->GetEntryType( rProp1.mnIndex ) &
 704                           XML_TYPE_BUILDIN_CMP ) != 0 )
 705                         // simple type ( binary compare )
 706                         bRet = ( rProp1.maValue == rProp2.maValue );
 707                     else
 708                         // complex type ( ask for compare-function )
 709                         bRet = mpImpl->mxPropMapper->GetPropertyHandler(
 710                                     rProp1.mnIndex )->equals( rProp1.maValue,
 711                                                               rProp2.maValue );
 712                 }
 713             }
 714             else
 715                 bRet = false;
 716
 717             nIndex++;
 718         }
 719     }
 720     else
 721         bRet = false;
 722
 723     return bRet;
 724 }
 725
 726 /** fills the given attribute list with the items in the given set
 727 void SvXMLExportPropertyMapper::exportXML( SvXMLAttributeList& rAttrList,
 728         const ::std::vector< XMLPropertyState >& rProperties,
 729         const SvXMLUnitConverter& rUnitConverter,
 730         const SvXMLNamespaceMap& rNamespaceMap,
 731         sal_uInt16 nFlags ) const
 732 {
 733     _exportXML( rAttrList, rProperties, rUnitConverter, rNamespaceMap,
 734                 nFlags, 0, -1, -1 );
 735 }
 736
 737 void SvXMLExportPropertyMapper::exportXML( SvXMLAttributeList& rAttrList,
 738         const ::std::vector< XMLPropertyState >& rProperties,
 739         const SvXMLUnitConverter& rUnitConverter,
 740         const SvXMLNamespaceMap& rNamespaceMap,
 741         sal_Int32 nPropMapStartIdx, sal_Int32 nPropMapEndIdx,
 742         sal_uInt16 nFlags ) const
 743 {
 744     _exportXML( rAttrList, rProperties, rUnitConverter, rNamespaceMap,
 745                 nFlags, 0, nPropMapStartIdx, nPropMapEndIdx );
 746 }
 747 */
 748
 749 void SvXMLExportPropertyMapper::exportXML(
 750         SvXMLExport& rExport,
 751         const ::std::vector< XMLPropertyState >& rProperties,
 752         SvXmlExportFlags nFlags ) const
 753 {
 754     exportXML( rExport, rProperties, -1, -1,  nFlags );
 755 }
 756
 757 void SvXMLExportPropertyMapper::exportXML(
 758         SvXMLExport& rExport,
 759         const ::std::vector< XMLPropertyState >& rProperties,
 760         sal_Int32 nPropMapStartIdx, sal_Int32 nPropMapEndIdx,
 761         SvXmlExportFlags nFlags, bool bExtensionNamespace ) const
 762 {
 763     sal_uInt16 nPropTypeFlags = 0;
 764     for( sal_uInt16 i=0; i<MAX_PROP_TYPES; ++i )
 765     {
 766         sal_uInt16 nPropType = aPropTokens[i].nType;
 767         if( 0==i || (nPropTypeFlags & (1 << nPropType)) != 0 )
 768         {
 769             std::vector<sal_uInt16> aIndexArray;
 770
 771             _exportXML( nPropType, nPropTypeFlags,
 772                         rExport.GetAttrList(), rProperties,
 773                         rExport.GetMM100UnitConverter(),
 774                         rExport.GetNamespaceMap(),
 775                         nFlags, &aIndexArray,
 776                         nPropMapStartIdx, nPropMapEndIdx );
 777
 778             if( rExport.GetAttrList().getLength() > 0L ||
 779                 (nFlags & SvXmlExportFlags::EMPTY) ||
 780                 !aIndexArray.empty() )
 781             {
 782                 sal_uInt16 nNamespace = XML_NAMESPACE_STYLE;
 783                 if(bExtensionNamespace && aPropTokens[i].eToken ==
 784                         xmloff::token::XML_GRAPHIC_PROPERTIES)
 785                     nNamespace = XML_NAMESPACE_LO_EXT;
 786                 SvXMLElementExport aElem( rExport, nNamespace,
 787                                   aPropTokens[i].eToken,
 788                                   bool(nFlags & SvXmlExportFlags::IGN_WS),
 789                                   false );
 790
 791                 exportElementItems( rExport, rProperties, nFlags, aIndexArray );
 792             }
 793         }
 794     }
 795 }
 796
 797 /** this method is called for every item that has the
 798     MID_FLAG_SPECIAL_ITEM_EXPORT flag set */
 799 void SvXMLExportPropertyMapper::handleSpecialItem(
 800         SvXMLAttributeList& rAttrList,
 801         const XMLPropertyState& rProperty,
 802         const SvXMLUnitConverter& rUnitConverter,
 803         const SvXMLNamespaceMap& rNamespaceMap,
 804         const ::std::vector< XMLPropertyState > *pProperties,
 805         sal_uInt32 nIdx ) const
 806 {
 807     OSL_ENSURE(mpImpl->mxNextMapper.is(), "special item not handled in xml export");
 808     if (mpImpl->mxNextMapper.is())
 809         mpImpl->mxNextMapper->handleSpecialItem(
 810             rAttrList, rProperty, rUnitConverter, rNamespaceMap, pProperties, nIdx);
 811 }
 812
 813 /** this method is called for every item that has the
 814     MID_FLAG_ELEMENT_EXPORT flag set */
 815 void SvXMLExportPropertyMapper::handleElementItem(
 816         SvXMLExport& rExport,
 817         const XMLPropertyState& rProperty,
 818         SvXmlExportFlags nFlags,
 819         const ::std::vector< XMLPropertyState > *pProperties,
 820         sal_uInt32 nIdx ) const
 821 {
 822     OSL_ENSURE(mpImpl->mxNextMapper.is(), "element item not handled in xml export");
 823     if (mpImpl->mxNextMapper.is())
 824         mpImpl->mxNextMapper->handleElementItem(rExport, rProperty, nFlags, pProperties, nIdx);
 825 }
 826
 827 // protected methods
 828
 829 /** fills the given attribute list with the items in the given set */
 830 void SvXMLExportPropertyMapper::_exportXML(
 831         sal_uInt16 nPropType, sal_uInt16& rPropTypeFlags,
 832         SvXMLAttributeList& rAttrList,
 833         const ::std::vector< XMLPropertyState >& rProperties,
 834         const SvXMLUnitConverter& rUnitConverter,
 835         const SvXMLNamespaceMap& rNamespaceMap,
 836         SvXmlExportFlags nFlags,
 837         std::vector<sal_uInt16>* pIndexArray,
 838         sal_Int32 nPropMapStartIdx, sal_Int32 nPropMapEndIdx ) const
 839 {
 840     const sal_uInt32 nCount = rProperties.size();
 841     sal_uInt32 nIndex = 0;
 842
 843     if( -1 == nPropMapStartIdx )
 844         nPropMapStartIdx = 0;
 845     if( -1 == nPropMapEndIdx )
 846         nPropMapEndIdx = mpImpl->mxPropMapper->GetEntryCount();
 847
 848     while( nIndex < nCount )
 849     {
 850         sal_Int32 nPropMapIdx = rProperties[nIndex].mnIndex;
 851         if( nPropMapIdx >= nPropMapStartIdx &&
 852             nPropMapIdx < nPropMapEndIdx  )// valid entry?
 853         {
 854             sal_uInt32 nEFlags = mpImpl->mxPropMapper->GetEntryFlags(nPropMapIdx);
 855             sal_uInt16 nEPType = GET_PROP_TYPE(nEFlags);
 856             OSL_ENSURE(nEPType >= (XML_TYPE_PROP_START >> XML_TYPE_PROP_SHIFT),
 857                        "no prop type specified");
 858             rPropTypeFlags |= (1 << nEPType);
 859             if( nEPType == nPropType )
 860             {
 861                 // we have a valid map entry here, so lets use it...
 862                 if( ( nEFlags & MID_FLAG_ELEMENT_ITEM_EXPORT ) != 0 )
 863                 {
 864                     // element items do not add any properties,
 865                     // we export it later
 866                     if( pIndexArray )
 867                     {
 868                         pIndexArray->push_back( (sal_uInt16)nIndex );
 869                     }
 870                 }
 871                 else
 872                 {
 873                     _exportXML( rAttrList, rProperties[nIndex], rUnitConverter,
 874                                 rNamespaceMap, nFlags, &rProperties, nIndex );
 875                 }
 876             }
 877         }
 878
 879         nIndex++;
 880     }
 881 }
 882
 883 void SvXMLExportPropertyMapper::_exportXML(
 884         SvXMLAttributeList& rAttrList,
 885         const XMLPropertyState& rProperty,
 886         const SvXMLUnitConverter& rUnitConverter,
 887         const SvXMLNamespaceMap& rNamespaceMap,
 888         SvXmlExportFlags /*nFlags*/,
 889         const ::std::vector< XMLPropertyState > *pProperties,
 890         sal_uInt32 nIdx ) const
 891 {
 892     if ((mpImpl->mxPropMapper->GetEntryFlags(rProperty.mnIndex) & MID_FLAG_SPECIAL_ITEM_EXPORT) != 0)
 893     {
 894         uno::Reference< container::XNameContainer > xAttrContainer;
 895         if( (rProperty.maValue >>= xAttrContainer) && xAttrContainer.is() )
 896         {
 897             SvXMLNamespaceMap *pNewNamespaceMap = 0;
 898             const SvXMLNamespaceMap *pNamespaceMap = &rNamespaceMap;
 899
 900             uno::Sequence< OUString > aAttribNames( xAttrContainer->getElementNames() );
 901             const OUString* pAttribName = aAttribNames.getConstArray();
 902
 903             const sal_Int32 nCount = aAttribNames.getLength();
 904
 905             OUStringBuffer sNameBuffer;
 906             xml::AttributeData aData;
 907             for( sal_Int32 i=0; i < nCount; i++, pAttribName++ )
 908             {
 909                 xAttrContainer->getByName( *pAttribName ) >>= aData;
 910                 OUString sAttribName( *pAttribName );
 911
 912                 // extract namespace prefix from attribute name if it exists
 913                 OUString sPrefix;
 914                 const sal_Int32 nColonPos =
 915                     pAttribName->indexOf( ':' );
 916                 if( nColonPos != -1 )
 917                     sPrefix = pAttribName->copy( 0, nColonPos );
 918
 919                 if( !sPrefix.isEmpty() )
 920                 {
 921                     OUString sNamespace( aData.Namespace );
 922
 923                     // if the prefix isn't defined yet or has another meaning,
 924                     // we have to redefine it now.
 925                     sal_uInt16 nKey = pNamespaceMap->GetKeyByPrefix( sPrefix );
 926                     if( USHRT_MAX == nKey || pNamespaceMap->GetNameByKey( nKey ) != sNamespace )
 927                     {
 928                         bool bAddNamespace = false;
 929                         if( USHRT_MAX == nKey )
 930                         {
 931                             // The prefix is unused, so it is sufficient
 932                             // to add it to the namespace map.
 933                             bAddNamespace = true;
 934                         }
 935                         else
 936                         {
 937                             // check if there is a prefix registered for the
 938                             // namepsace URI
 939                             nKey = pNamespaceMap->GetKeyByName( sNamespace );
 940                             if( XML_NAMESPACE_UNKNOWN == nKey )
 941                             {
 942                                 // There is no prefix for the namespace, so
 943                                 // we have to generate one and have to add it.
 944                                 sal_Int32 n=0;
 945                                 OUString sOrigPrefix( sPrefix );
 946                                 do
 947                                 {
 948                                     sNameBuffer.append( sOrigPrefix );
 949                                     sNameBuffer.append( ++n );
 950                                     sPrefix = sNameBuffer.makeStringAndClear();
 951                                     nKey = pNamespaceMap->GetKeyByPrefix( sPrefix );
 952                                 }
 953                                 while( nKey != USHRT_MAX );
 954
 955                                 bAddNamespace = true;
 956                             }
 957                             else
 958                             {
 959                                 // If there is a prefix for the namespace,
 960                                 // we reuse that.
 961                                 sPrefix = pNamespaceMap->GetPrefixByKey( nKey );
 962                             }
 963                             // In any case, the attribute name has to be adapted.
 964                             sNameBuffer.append( sPrefix + ":" + pAttribName->copy( nColonPos+1 ) );
 965                             sAttribName = sNameBuffer.makeStringAndClear();
 966                         }
 967
 968                         if( bAddNamespace )
 969                         {
 970                             if( !pNewNamespaceMap )
 971                             {
 972                                 pNewNamespaceMap = new SvXMLNamespaceMap( rNamespaceMap );
 973                                 pNamespaceMap = pNewNamespaceMap;
 974                             }
 975                             pNewNamespaceMap->Add( sPrefix, sNamespace );
 976                             sNameBuffer.append( GetXMLToken(XML_XMLNS) + ":" + sPrefix );
 977                             rAttrList.AddAttribute( sNameBuffer.makeStringAndClear(),
 978                                                     sNamespace );
 979                         }
 980                     }
 981                 }
 982                 OUString sOldValue( rAttrList.getValueByName( sAttribName ) );
 983                 OSL_ENSURE( sOldValue.isEmpty(), "alien attribute exists already" );
 984                 OSL_ENSURE(aData.Type == GetXMLToken(XML_CDATA), "different type to our default type which should be written out");
 985                 if( sOldValue.isEmpty() )
 986                     rAttrList.AddAttribute( sAttribName, aData.Value );
 987             }
 988
 989             delete pNewNamespaceMap;
 990         }
 991         else
 992         {
 993             handleSpecialItem( rAttrList, rProperty, rUnitConverter,
 994                                rNamespaceMap, pProperties, nIdx );
 995         }
 996     }
 997     else if ((mpImpl->mxPropMapper->GetEntryFlags(rProperty.mnIndex) & MID_FLAG_ELEMENT_ITEM_EXPORT ) == 0)
 998     {
 999         OUString aValue;
1000         const OUString sName = rNamespaceMap.GetQNameByKey(
1001             mpImpl->mxPropMapper->GetEntryNameSpace(rProperty.mnIndex),
1002             mpImpl->mxPropMapper->GetEntryXMLName(rProperty.mnIndex));
1003
1004         bool bRemove = false;
1005         if ((mpImpl->mxPropMapper->GetEntryFlags( rProperty.mnIndex ) & MID_FLAG_MERGE_ATTRIBUTE) != 0)
1006         {
1007             aValue = rAttrList.getValueByName( sName );
1008             bRemove = true;
1009         }
1010
1011         if (mpImpl->mxPropMapper->exportXML(aValue, rProperty, rUnitConverter))
1012         {
1013             if( bRemove )
1014                 rAttrList.RemoveAttribute( sName );
1015             rAttrList.AddAttribute( sName, aValue );
1016         }
1017     }
1018 }
1019
1020 void SvXMLExportPropertyMapper::exportElementItems(
1021         SvXMLExport& rExport,
1022         const ::std::vector< XMLPropertyState >& rProperties,
1023         SvXmlExportFlags nFlags,
1024         const std::vector<sal_uInt16>& rIndexArray ) const
1025 {
1026     const sal_uInt16 nCount = rIndexArray.size();
1027
1028     bool bItemsExported = false;
1029     for( sal_uInt16 nIndex = 0; nIndex < nCount; nIndex++ )
1030     {
1031         const sal_uInt16 nElement = rIndexArray[nIndex];
1032
1033         OSL_ENSURE( 0 != (mpImpl->mxPropMapper->GetEntryFlags(
1034                 rProperties[nElement].mnIndex ) & MID_FLAG_ELEMENT_ITEM_EXPORT),
1035                 "wrong mid flag!" );
1036
1037         rExport.IgnorableWhitespace();
1038         handleElementItem( rExport, rProperties[nElement],
1039                            nFlags, &rProperties, nElement );
1040         bItemsExported = true;
1041     }
1042
1043     if( bItemsExported )
1044         rExport.IgnorableWhitespace();
1045 }
1046
1047 const rtl::Reference<XMLPropertySetMapper>& SvXMLExportPropertyMapper::getPropertySetMapper() const
1048 {
1049     return mpImpl->mxPropMapper;
1050 }
1051
1052 void SvXMLExportPropertyMapper::SetStyleName( const OUString& rStyleName )
1053 {
1054     mpImpl->maStyleName = rStyleName;
1055 }
1056
1057 const OUString& SvXMLExportPropertyMapper::GetStyleName() const
1058 {
1059     return mpImpl->maStyleName;
1060 }
1061
1062 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */