xmloff/source/forms/propertyimport.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: propertyimport.cxx,v $
  10  * $Revision: 1.27 $
  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_xmloff.hxx"
  33 #include "propertyimport.hxx"
  34 #include <xmloff/xmlimp.hxx>
  35 #include <xmloff/xmluconv.hxx>
  36 #include <xmloff/nmspmap.hxx>
  37 #include <osl/diagnose.h>
  38 #include <comphelper/extract.hxx>
  39 #include "callbacks.hxx"
  40 #include "xmlnmspe.hxx"
  41 #include <tools/date.hxx>
  42 #include <tools/time.hxx>
  43 #include <tools/datetime.hxx>
  44 #include <com/sun/star/util/Date.hpp>
  45 #include <com/sun/star/util/Time.hpp>
  46 #include <com/sun/star/util/DateTime.hpp>
  47 #include <unotools/datetime.hxx>
  48 #include <rtl/logfile.hxx>
  49
  50 #if OSL_DEBUG_LEVEL > 0
  51     #ifndef _OSL_THREAD_H_
  52     #include <osl/thread.h>
  53     #endif
  54 #endif
  55
  56 //.........................................................................
  57 namespace xmloff
  58 {
  59 //.........................................................................
  60
  61     using namespace ::com::sun::star::uno;
  62     using namespace ::com::sun::star::beans;
  63     using namespace ::com::sun::star::xml;
  64
  65     // NO using namespace ...util !!!
  66     // need a tools Date/Time/DateTime below, which would conflict with the uno types then
  67
  68 #define TYPE_DATE               1
  69 #define TYPE_TIME               2
  70 #define TYPE_DATETIME   3
  71
  72 //=====================================================================
  73 //= PropertyConversion
  74 //=====================================================================
  75 namespace
  76 {
  77     //---------------------------------------------------------------------
  78     ::com::sun::star::util::Time lcl_getTime(double _nValue)
  79     {
  80         ::com::sun::star::util::Time aTime;
  81         sal_uInt32 nIntValue = sal_Int32(_nValue * 8640000);
  82         nIntValue *= 8640000;
  83         aTime.HundredthSeconds = (sal_uInt16)( nIntValue % 100 );
  84         nIntValue /= 100;
  85         aTime.Seconds = (sal_uInt16)( nIntValue % 60 );
  86         nIntValue /= 60;
  87         aTime.Minutes = (sal_uInt16)( nIntValue % 60 );
  88         nIntValue /= 60;
  89         OSL_ENSURE(nIntValue < 24, "lcl_getTime: more than a day?");
  90         aTime.Hours = static_cast< sal_uInt16 >( nIntValue );
  91
  92         return aTime;
  93     }
  94
  95     //---------------------------------------------------------------------
  96     static ::com::sun::star::util::Date lcl_getDate( double _nValue )
  97     {
  98         Date aToolsDate((sal_uInt32)_nValue);
  99         ::com::sun::star::util::Date aDate;
 100         ::utl::typeConvert(aToolsDate, aDate);
 101         return aDate;
 102     }
 103 }
 104
 105 //---------------------------------------------------------------------
 106 Any PropertyConversion::convertString( SvXMLImport& _rImporter, const ::com::sun::star::uno::Type& _rExpectedType,
 107     const ::rtl::OUString& _rReadCharacters, const SvXMLEnumMapEntry* _pEnumMap, const sal_Bool _bInvertBoolean )
 108 {
 109     Any aReturn;
 110     sal_Bool bEnumAsInt = sal_False;
 111     switch (_rExpectedType.getTypeClass())
 112     {
 113         case TypeClass_BOOLEAN:         // sal_Bool
 114         {
 115             sal_Bool bValue;
 116         #if OSL_DEBUG_LEVEL > 0
 117             sal_Bool bSuccess =
 118         #endif
 119             _rImporter.GetMM100UnitConverter().convertBool(bValue, _rReadCharacters);
 120             OSL_ENSURE(bSuccess,
 121                     ::rtl::OString("PropertyConversion::convertString: could not convert \"")
 122                 +=      ::rtl::OString(_rReadCharacters.getStr(), _rReadCharacters.getLength(), RTL_TEXTENCODING_ASCII_US)
 123                 +=      ::rtl::OString("\" into a boolean!"));
 124             aReturn = ::cppu::bool2any(_bInvertBoolean ? !bValue : bValue);
 125         }
 126         break;
 127         case TypeClass_SHORT:           // sal_Int16
 128         case TypeClass_LONG:            // sal_Int32
 129             if (!_pEnumMap)
 130             {   // it's a real int32/16 property
 131                 sal_Int32 nValue(0);
 132         #if OSL_DEBUG_LEVEL > 0
 133                 sal_Bool bSuccess =
 134         #endif
 135                 _rImporter.GetMM100UnitConverter().convertNumber(nValue, _rReadCharacters);
 136                 OSL_ENSURE(bSuccess,
 137                         ::rtl::OString("PropertyConversion::convertString: could not convert \"")
 138                     +=  ::rtl::OString(_rReadCharacters.getStr(), _rReadCharacters.getLength(), RTL_TEXTENCODING_ASCII_US)
 139                     +=  ::rtl::OString("\" into an integer!"));
 140                 if (TypeClass_SHORT == _rExpectedType.getTypeClass())
 141                     aReturn <<= (sal_Int16)nValue;
 142                 else
 143                     aReturn <<= (sal_Int32)nValue;
 144                 break;
 145             }
 146             bEnumAsInt = sal_True;
 147             // NO BREAK! handle it as enum
 148         case TypeClass_ENUM:
 149         {
 150             sal_uInt16 nEnumValue(0);
 151         #if OSL_DEBUG_LEVEL > 0
 152             sal_Bool bSuccess =
 153         #endif
 154             _rImporter.GetMM100UnitConverter().convertEnum(nEnumValue, _rReadCharacters, _pEnumMap);
 155             OSL_ENSURE(bSuccess, "PropertyConversion::convertString: could not convert to an enum value!");
 156             if (bEnumAsInt)
 157                 if (TypeClass_SHORT == _rExpectedType.getTypeClass())
 158                     aReturn <<= (sal_Int16)nEnumValue;
 159                 else
 160                     aReturn <<= (sal_Int32)nEnumValue;
 161             else
 162                 aReturn = ::cppu::int2enum((sal_Int32)nEnumValue, _rExpectedType);
 163         }
 164         break;
 165         case TypeClass_HYPER:
 166         {
 167             OSL_ENSURE(sal_False, "PropertyConversion::convertString: 64-bit integers not implemented yet!");
 168         }
 169         break;
 170         case TypeClass_DOUBLE:
 171         {
 172             double nValue;
 173         #if OSL_DEBUG_LEVEL > 0
 174             sal_Bool bSuccess =
 175         #endif
 176             _rImporter.GetMM100UnitConverter().convertDouble(nValue, _rReadCharacters);
 177             OSL_ENSURE(bSuccess,
 178                     ::rtl::OString("PropertyConversion::convertString: could not convert \"")
 179                 +=      ::rtl::OString(_rReadCharacters.getStr(), _rReadCharacters.getLength(), RTL_TEXTENCODING_ASCII_US)
 180                 +=      ::rtl::OString("\" into a double!"));
 181             aReturn <<= (double)nValue;
 182         }
 183         break;
 184         case TypeClass_STRING:
 185             aReturn <<= _rReadCharacters;
 186             break;
 187         case TypeClass_STRUCT:
 188         {
 189             sal_Int32 nType = 0;
 190             if ( _rExpectedType.equals( ::cppu::UnoType< ::com::sun::star::util::Date >::get() ) )
 191                 nType = TYPE_DATE;
 192             else if ( _rExpectedType.equals( ::cppu::UnoType< ::com::sun::star::util::Time >::get() ) )
 193                 nType = TYPE_TIME;
 194             else  if ( _rExpectedType.equals( ::cppu::UnoType< ::com::sun::star::util::DateTime >::get() ) )
 195                 nType = TYPE_DATETIME;
 196
 197             if ( nType )
 198             {
 199                 // first extract the double
 200                 double nValue = 0;
 201             #if OSL_DEBUG_LEVEL > 0
 202                 sal_Bool bSuccess =
 203             #endif
 204                 _rImporter.GetMM100UnitConverter().convertDouble(nValue, _rReadCharacters);
 205                 OSL_ENSURE(bSuccess,
 206                         ::rtl::OString("PropertyConversion::convertString: could not convert \"")
 207                     +=  ::rtl::OString(_rReadCharacters.getStr(), _rReadCharacters.getLength(), RTL_TEXTENCODING_ASCII_US)
 208                     +=  ::rtl::OString("\" into a double!"));
 209
 210                 // then convert it into the target type
 211                 switch (nType)
 212                 {
 213                     case TYPE_DATE:
 214                     {
 215                         OSL_ENSURE(((sal_uInt32)nValue) - nValue == 0,
 216                             "PropertyConversion::convertString: a Date value with a fractional part?");
 217                         aReturn <<= lcl_getDate(nValue);
 218                     }
 219                     break;
 220                     case TYPE_TIME:
 221                     {
 222                         OSL_ENSURE(((sal_uInt32)nValue) == 0,
 223                             "PropertyConversion::convertString: a Time value with more than a fractional part?");
 224                         aReturn <<= lcl_getTime(nValue);
 225                     }
 226                     break;
 227                     case TYPE_DATETIME:
 228                     {
 229                         ::com::sun::star::util::Time aTime = lcl_getTime(nValue);
 230                         ::com::sun::star::util::Date aDate = lcl_getDate(nValue);
 231
 232                         ::com::sun::star::util::DateTime aDateTime;
 233                         aDateTime.HundredthSeconds = aTime.HundredthSeconds;
 234                         aDateTime.Seconds = aTime.Seconds;
 235                         aDateTime.Minutes = aTime.Minutes;
 236                         aDateTime.Hours = aTime.Hours;
 237                         aDateTime.Day = aDate.Day;
 238                         aDateTime.Month = aDate.Month;
 239                         aDateTime.Year = aDate.Year;
 240                         aReturn <<= aDateTime;
 241                     }
 242                     break;
 243                 }
 244             }
 245             else
 246                 OSL_ENSURE(sal_False, "PropertyConversion::convertString: unsupported property type!");
 247         }
 248         break;
 249         default:
 250             OSL_ENSURE(sal_False, "PropertyConversion::convertString: invalid type class!");
 251     }
 252
 253     return aReturn;
 254 }
 255
 256 //---------------------------------------------------------------------
 257 Type PropertyConversion::xmlTypeToUnoType( const ::rtl::OUString& _rType )
 258 {
 259     Type aUnoType( ::getVoidCppuType() );
 260
 261     DECLARE_STL_USTRINGACCESS_MAP( ::com::sun::star::uno::Type, MapString2Type );
 262     static MapString2Type s_aTypeNameMap;
 263     if ( s_aTypeNameMap.empty() )
 264     {
 265         s_aTypeNameMap[ token::GetXMLToken( token::XML_BOOLEAN ) ] = ::getBooleanCppuType();
 266         s_aTypeNameMap[ token::GetXMLToken( token::XML_FLOAT )   ] = ::getCppuType( static_cast< double* >(NULL) );
 267         s_aTypeNameMap[ token::GetXMLToken( token::XML_STRING )  ] = ::getCppuType( static_cast< ::rtl::OUString* >(NULL) );
 268         s_aTypeNameMap[ token::GetXMLToken( token::XML_VOID )    ] = ::getVoidCppuType();
 269     }
 270
 271     const ConstMapString2TypeIterator aTypePos = s_aTypeNameMap.find( _rType );
 272     OSL_ENSURE( s_aTypeNameMap.end() != aTypePos, "PropertyConversion::xmlTypeToUnoType: invalid property name!" );
 273     if ( s_aTypeNameMap.end() != aTypePos )
 274         aUnoType = aTypePos->second;
 275
 276     return aUnoType;
 277 }
 278
 279 //=====================================================================
 280 //= OPropertyImport
 281 //=====================================================================
 282 //---------------------------------------------------------------------
 283 OPropertyImport::OPropertyImport(OFormLayerXMLImport_Impl& _rImport, sal_uInt16 _nPrefix, const ::rtl::OUString& _rName)
 284     :SvXMLImportContext(_rImport.getGlobalContext(), _nPrefix, _rName)
 285     ,m_rContext(_rImport)
 286     ,m_bTrackAttributes(sal_False)
 287 {
 288 }
 289
 290 //---------------------------------------------------------------------
 291 SvXMLImportContext* OPropertyImport::CreateChildContext(sal_uInt16 _nPrefix, const ::rtl::OUString& _rLocalName,
 292     const Reference< sax::XAttributeList >& _rxAttrList)
 293 {
 294     if( token::IsXMLToken( _rLocalName, token::XML_PROPERTIES) )
 295     {
 296         return new OPropertyElementsContext( m_rContext.getGlobalContext(),
 297                                              _nPrefix, _rLocalName, this);
 298     }
 299     else
 300     {
 301         OSL_ENSURE(sal_False,
 302                 ::rtl::OString("OPropertyImport::CreateChildContext: unknown sub element (only \"properties\" is recognized, but it is ")
 303             +=  ::rtl::OString(_rLocalName.getStr(), _rLocalName.getLength(), RTL_TEXTENCODING_ASCII_US)
 304             +=  ::rtl::OString(")!"));
 305         return SvXMLImportContext::CreateChildContext(_nPrefix, _rLocalName, _rxAttrList);
 306     }
 307 }
 308
 309 //---------------------------------------------------------------------
 310 void OPropertyImport::StartElement(const Reference< sax::XAttributeList >& _rxAttrList)
 311 {
 312     OSL_ENSURE(_rxAttrList.is(), "OPropertyImport::StartElement: invalid attribute list!");
 313     const sal_Int32 nAttributeCount = _rxAttrList->getLength();
 314
 315     // assume the 'worst' case: all attributes describe properties. This should save our property array
 316     // some reallocs
 317     m_aValues.reserve(nAttributeCount);
 318
 319     const SvXMLNamespaceMap& rMap = m_rContext.getGlobalContext().GetNamespaceMap();
 320     sal_uInt16 nNamespace;
 321     ::rtl::OUString sLocalName;
 322     for (sal_Int16 i=0; i<nAttributeCount; ++i)
 323     {
 324         nNamespace = rMap.GetKeyByAttrName(_rxAttrList->getNameByIndex(i), &sLocalName);
 325         handleAttribute(nNamespace, sLocalName, _rxAttrList->getValueByIndex(i));
 326
 327         if (m_bTrackAttributes)
 328             m_aEncounteredAttributes.insert(sLocalName);
 329     }
 330
 331     // TODO: create PropertyValues for all the attributes which were not present, because they were implied
 332     // this is necessary as soon as we have properties where the XML default is different from the property
 333     // default
 334 }
 335
 336 //---------------------------------------------------------------------
 337 sal_Bool OPropertyImport::encounteredAttribute(const ::rtl::OUString& _rAttributeName) const
 338 {
 339     OSL_ENSURE(m_bTrackAttributes, "OPropertyImport::encounteredAttribute: attribute tracking not enabled!");
 340     return m_aEncounteredAttributes.end() != m_aEncounteredAttributes.find(_rAttributeName);
 341 }
 342
 343 //---------------------------------------------------------------------
 344 void OPropertyImport::Characters(const ::rtl::OUString&
 345 #if OSL_DEBUG_LEVEL > 0
 346 _rChars
 347 #endif
 348 )
 349 {
 350     // ignore them (should be whitespaces only)
 351     OSL_ENSURE(0 == _rChars.trim().getLength(), "OPropertyImport::Characters: non-whitespace characters!");
 352 }
 353
 354 //---------------------------------------------------------------------
 355 void OPropertyImport::handleAttribute(sal_uInt16 /*_nNamespaceKey*/, const ::rtl::OUString& _rLocalName, const ::rtl::OUString& _rValue)
 356 {
 357     const OAttribute2Property::AttributeAssignment* pProperty = m_rContext.getAttributeMap().getAttributeTranslation(_rLocalName);
 358     if (pProperty)
 359     {
 360         // create and store a new PropertyValue
 361         PropertyValue aNewValue;
 362         aNewValue.Name = pProperty->sPropertyName;
 363
 364         // convert the value string into the target type
 365         aNewValue.Value = PropertyConversion::convertString(m_rContext.getGlobalContext(), pProperty->aPropertyType, _rValue, pProperty->pEnumMap, pProperty->bInverseSemantics);
 366         implPushBackPropertyValue( aNewValue );
 367     }
 368 #if OSL_DEBUG_LEVEL > 0
 369     else
 370     {
 371         ::rtl::OString sMessage( "OPropertyImport::handleAttribute: Can't handle the following:\n" );
 372         sMessage += ::rtl::OString( "  Attribute name: " );
 373         sMessage += ::rtl::OString( _rLocalName.getStr(), _rLocalName.getLength(), osl_getThreadTextEncoding() );
 374         sMessage += ::rtl::OString( "\n  value: " );
 375         sMessage += ::rtl::OString( _rValue.getStr(), _rValue.getLength(), osl_getThreadTextEncoding() );
 376         OSL_ENSURE( sal_False, sMessage.getStr() );
 377     }
 378 #endif
 379 }
 380
 381 //=====================================================================
 382 //= OPropertyElementsContext
 383 //=====================================================================
 384 //---------------------------------------------------------------------
 385 OPropertyElementsContext::OPropertyElementsContext(SvXMLImport& _rImport, sal_uInt16 _nPrefix, const ::rtl::OUString& _rName,
 386         const OPropertyImportRef& _rPropertyImporter)
 387     :SvXMLImportContext(_rImport, _nPrefix, _rName)
 388     ,m_xPropertyImporter(_rPropertyImporter)
 389 {
 390 }
 391
 392 //---------------------------------------------------------------------
 393 SvXMLImportContext* OPropertyElementsContext::CreateChildContext(sal_uInt16 _nPrefix, const ::rtl::OUString& _rLocalName,
 394     const Reference< sax::XAttributeList >&)
 395 {
 396     if( token::IsXMLToken( _rLocalName, token::XML_PROPERTY ) )
 397     {
 398         return new OSinglePropertyContext(GetImport(), _nPrefix, _rLocalName, m_xPropertyImporter);
 399     }
 400     else if( token::IsXMLToken( _rLocalName, token::XML_LIST_PROPERTY ) )
 401     {
 402         return new OListPropertyContext( GetImport(), _nPrefix, _rLocalName, m_xPropertyImporter );
 403     }
 404     else
 405     {
 406         OSL_ENSURE(sal_False,
 407                 ::rtl::OString("OPropertyElementsContext::CreateChildContext: unknown child element (\"")
 408             +=  ::rtl::OString(_rLocalName.getStr(), _rLocalName.getLength(), RTL_TEXTENCODING_ASCII_US)
 409             +=  ::rtl::OString("\")!"));
 410         return new SvXMLImportContext(GetImport(), _nPrefix, _rLocalName);
 411     }
 412 }
 413
 414 #if OSL_DEBUG_LEVEL > 0
 415     //---------------------------------------------------------------------
 416     void OPropertyElementsContext::StartElement(const Reference< sax::XAttributeList >& _rxAttrList)
 417     {
 418         OSL_ENSURE(0 == _rxAttrList->getLength(), "OPropertyElementsContext::StartElement: the form:properties element should not have attributes!");
 419         SvXMLImportContext::StartElement(_rxAttrList);
 420     }
 421
 422     //---------------------------------------------------------------------
 423     void OPropertyElementsContext::Characters(const ::rtl::OUString& _rChars)
 424     {
 425         OSL_ENSURE(0 == _rChars.trim(), "OPropertyElementsContext::Characters: non-whitespace characters detected!");
 426         SvXMLImportContext::Characters(_rChars);
 427     }
 428
 429 #endif
 430
 431 //=====================================================================
 432 //= OSinglePropertyContext
 433 //=====================================================================
 434 //---------------------------------------------------------------------
 435 OSinglePropertyContext::OSinglePropertyContext(SvXMLImport& _rImport, sal_uInt16 _nPrefix, const ::rtl::OUString& _rName,
 436         const OPropertyImportRef& _rPropertyImporter)
 437     :SvXMLImportContext(_rImport, _nPrefix, _rName)
 438     ,m_xPropertyImporter(_rPropertyImporter)
 439 {
 440 }
 441
 442 //---------------------------------------------------------------------
 443 SvXMLImportContext* OSinglePropertyContext::CreateChildContext(sal_uInt16 _nPrefix, const ::rtl::OUString& _rLocalName,
 444         const Reference< sax::XAttributeList >&)
 445 {
 446     OSL_ENSURE(sal_False,
 447             ::rtl::OString("OSinglePropertyContext::CreateChildContext: unknown child element (\"")
 448         +=      ::rtl::OString(_rLocalName.getStr(), _rLocalName.getLength(), RTL_TEXTENCODING_ASCII_US)
 449         +=      ::rtl::OString("\")!"));
 450     return new SvXMLImportContext(GetImport(), _nPrefix, _rLocalName);
 451 }
 452
 453 //---------------------------------------------------------------------
 454 void OSinglePropertyContext::StartElement(const Reference< sax::XAttributeList >& _rxAttrList)
 455 {
 456     ::com::sun::star::beans::PropertyValue aPropValue;          // the property the instance imports currently
 457     ::com::sun::star::uno::Type aPropType;                      // the type of the property the instance imports currently
 458
 459     ::rtl::OUString sType, sValue;
 460     const SvXMLNamespaceMap& rMap = GetImport().GetNamespaceMap();
 461     const sal_Int16 nAttrCount = _rxAttrList.is() ? _rxAttrList->getLength() : 0;
 462     for( sal_Int16 i=0; i < nAttrCount; i++ )
 463     {
 464         const ::rtl::OUString& rAttrName = _rxAttrList->getNameByIndex( i );
 465         //const ::rtl::OUString& rValue = _rxAttrList->getValueByIndex( i );
 466
 467         ::rtl::OUString aLocalName;
 468         sal_uInt16 nPrefix =
 469             rMap.GetKeyByAttrName( rAttrName,
 470                                                             &aLocalName );
 471         if( XML_NAMESPACE_FORM == nPrefix )
 472         {
 473             if( token::IsXMLToken( aLocalName, token::XML_PROPERTY_NAME ) )
 474                 aPropValue.Name = _rxAttrList->getValueByIndex( i );
 475
 476         }
 477         else if( XML_NAMESPACE_OFFICE == nPrefix )
 478         {
 479             if( token::IsXMLToken( aLocalName, token::XML_VALUE_TYPE ) )
 480                 sType = _rxAttrList->getValueByIndex( i );
 481             else if( token::IsXMLToken( aLocalName,
 482                                         token::XML_VALUE ) ||
 483                         token::IsXMLToken( aLocalName,
 484                                         token::XML_BOOLEAN_VALUE ) ||
 485                      token::IsXMLToken( aLocalName,
 486                                         token::XML_STRING_VALUE ) )
 487                 sValue = _rxAttrList->getValueByIndex( i );
 488         }
 489     }
 490
 491     // the name of the property
 492     OSL_ENSURE(aPropValue.Name.getLength(), "OSinglePropertyContext::StartElement: invalid property name!");
 493
 494     // needs to be translated into a ::com::sun::star::uno::Type
 495     aPropType = PropertyConversion::xmlTypeToUnoType( sType );
 496     if( TypeClass_VOID == aPropType.getTypeClass() )
 497     {
 498         aPropValue.Value = Any();
 499     }
 500     else
 501     {
 502         aPropValue.Value =
 503             PropertyConversion::convertString(GetImport(), aPropType,
 504                                            sValue);
 505     }
 506
 507     // now that we finally have our property value, add it to our parent object
 508     if( aPropValue.Name.getLength() )
 509         m_xPropertyImporter->implPushBackGenericPropertyValue(aPropValue);
 510 }
 511
 512 //=====================================================================
 513 //= OListPropertyContext
 514 //=====================================================================
 515 //---------------------------------------------------------------------
 516 OListPropertyContext::OListPropertyContext( SvXMLImport& _rImport, sal_uInt16 _nPrefix, const ::rtl::OUString& _rName,
 517     const OPropertyImportRef& _rPropertyImporter )
 518     :SvXMLImportContext( _rImport, _nPrefix, _rName )
 519     ,m_xPropertyImporter( _rPropertyImporter )
 520 {
 521 }
 522
 523 //---------------------------------------------------------------------
 524 void OListPropertyContext::StartElement( const Reference< sax::XAttributeList >& _rxAttrList )
 525 {
 526     sal_Int32 nAttributeCount = _rxAttrList->getLength();
 527
 528     sal_uInt16 nNamespace;
 529     ::rtl::OUString sAttributeName;
 530     const SvXMLNamespaceMap& rMap = GetImport().GetNamespaceMap();
 531     for ( sal_Int16 i = 0; i < nAttributeCount; ++i )
 532     {
 533         nNamespace = rMap.GetKeyByAttrName( _rxAttrList->getNameByIndex( i ), &sAttributeName );
 534         if  (   ( XML_NAMESPACE_FORM == nNamespace )
 535             &&  ( token::IsXMLToken( sAttributeName, token::XML_PROPERTY_NAME ) )
 536             )
 537         {
 538             m_sPropertyName = _rxAttrList->getValueByIndex( i );
 539         }
 540         else if (   ( XML_NAMESPACE_OFFICE == nNamespace )
 541                 &&  ( token::IsXMLToken( sAttributeName, token::XML_VALUE_TYPE ) )
 542                 )
 543         {
 544             m_sPropertyType = _rxAttrList->getValueByIndex( i );
 545         }
 546         else
 547         {
 548             OSL_ENSURE( false,
 549                     ::rtl::OString( "OListPropertyContext::StartElement: unknown child element (\"")
 550                 +=      ::rtl::OString( sAttributeName.getStr(), sAttributeName.getLength(), RTL_TEXTENCODING_ASCII_US )
 551                 +=      ::rtl::OString( "\")!" ) );
 552         }
 553     }
 554 }
 555
 556 //---------------------------------------------------------------------
 557 void OListPropertyContext::EndElement()
 558 {
 559     OSL_ENSURE( m_sPropertyName.getLength() && m_sPropertyType.getLength(),
 560         "OListPropertyContext::EndElement: no property name or type!" );
 561
 562     if ( !m_sPropertyName.getLength() || !m_sPropertyType.getLength() )
 563         return;
 564
 565     Sequence< Any > aListElements( m_aListValues.size() );
 566     Any* pListElement = aListElements.getArray();
 567     com::sun::star::uno::Type aType = PropertyConversion::xmlTypeToUnoType( m_sPropertyType );
 568     for (   ::std::vector< ::rtl::OUString >::const_iterator values = m_aListValues.begin();
 569             values != m_aListValues.end();
 570             ++values, ++pListElement
 571         )
 572     {
 573         *pListElement = PropertyConversion::convertString( GetImport(), aType, *values );
 574     }
 575
 576     PropertyValue aSequenceValue;
 577     aSequenceValue.Name = m_sPropertyName;
 578     aSequenceValue.Value <<= aListElements;
 579
 580     m_xPropertyImporter->implPushBackGenericPropertyValue( aSequenceValue );
 581 }
 582
 583 //---------------------------------------------------------------------
 584 SvXMLImportContext* OListPropertyContext::CreateChildContext( sal_uInt16 _nPrefix, const ::rtl::OUString& _rLocalName, const Reference< sax::XAttributeList >& /*_rxAttrList*/ )
 585 {
 586     if ( token::IsXMLToken( _rLocalName, token::XML_LIST_VALUE ) )
 587     {
 588         m_aListValues.resize( m_aListValues.size() + 1 );
 589         return new OListValueContext( GetImport(), _nPrefix, _rLocalName, *m_aListValues.rbegin() );
 590     }
 591     else
 592     {
 593         OSL_ENSURE( sal_False,
 594                 ::rtl::OString("OListPropertyContext::CreateChildContext: unknown child element (\"")
 595             +=  ::rtl::OString(_rLocalName.getStr(), _rLocalName.getLength(), RTL_TEXTENCODING_ASCII_US)
 596             +=  ::rtl::OString("\")!"));
 597         return new SvXMLImportContext( GetImport(), _nPrefix, _rLocalName );
 598     }
 599 }
 600
 601 //=====================================================================
 602 //= OListValueContext
 603 //=====================================================================
 604 //---------------------------------------------------------------------
 605 OListValueContext::OListValueContext( SvXMLImport& _rImport, sal_uInt16 _nPrefix, const ::rtl::OUString& _rName, ::rtl::OUString& _rListValueHolder )
 606     :SvXMLImportContext( _rImport, _nPrefix, _rName )
 607     ,m_rListValueHolder( _rListValueHolder )
 608 {
 609 }
 610
 611 //---------------------------------------------------------------------
 612 void OListValueContext::StartElement( const Reference< sax::XAttributeList >& _rxAttrList )
 613 {
 614     const sal_Int32 nAttributeCount = _rxAttrList->getLength();
 615
 616     sal_uInt16 nNamespace;
 617     ::rtl::OUString sAttributeName;
 618     const SvXMLNamespaceMap& rMap = GetImport().GetNamespaceMap();
 619     for ( sal_Int16 i = 0; i < nAttributeCount; ++i )
 620     {
 621         nNamespace = rMap.GetKeyByAttrName( _rxAttrList->getNameByIndex( i ), &sAttributeName );
 622         if ( XML_NAMESPACE_OFFICE == nNamespace )
 623         {
 624             if  (   token::IsXMLToken( sAttributeName, token::XML_VALUE )
 625                ||   token::IsXMLToken( sAttributeName, token::XML_STRING_VALUE )
 626                ||   token::IsXMLToken( sAttributeName, token::XML_BOOLEAN_VALUE )
 627                 )
 628             {
 629                 m_rListValueHolder = _rxAttrList->getValueByIndex( i );
 630                 continue;
 631             }
 632         }
 633
 634         OSL_ENSURE( false,
 635                 ::rtl::OString( "OListValueContext::StartElement: unknown child element (\"")
 636             +=  ::rtl::OString( sAttributeName.getStr(), sAttributeName.getLength(), RTL_TEXTENCODING_ASCII_US )
 637             +=  ::rtl::OString( "\")!" ) );
 638     }
 639 }
 640
 641 //.........................................................................
 642 }       // namespace xmloff
 643 //.........................................................................
 644