oox/source/docprop/docprophandler.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 "docprophandler.hxx"
  21
  22 #include <com/sun/star/beans/PropertyAttribute.hpp>
  23 #include <com/sun/star/beans/PropertyExistException.hpp>
  24 #include <com/sun/star/lang/IllegalArgumentException.hpp>
  25 #include <com/sun/star/lang/Locale.hpp>
  26 #include <com/sun/star/xml/sax/SAXException.hpp>
  27 #include <cppuhelper/exc_hlp.hxx>
  28
  29 #include <o3tl/safeint.hxx>
  30 #include <osl/time.h>
  31 #include <osl/diagnose.h>
  32 #include <sal/log.hxx>
  33 #include <i18nlangtag/languagetag.hxx>
  34
  35 #include <vector>
  36 #include <boost/algorithm/string.hpp>
  37
  38 #include <oox/helper/attributelist.hxx>
  39
  40 using namespace ::com::sun::star;
  41
  42 namespace oox {
  43 namespace docprop {
  44
  45 OOXMLDocPropHandler::OOXMLDocPropHandler( const uno::Reference< uno::XComponentContext >& xContext,
  46                                           const uno::Reference< document::XDocumentProperties >& rDocProp )
  47     : m_xDocProp( rDocProp )
  48     , m_nState( 0 )
  49     , m_nBlock( 0 )
  50     , m_nType( 0 )
  51     , m_nInBlock( 0 )
  52     , m_CustomStringPropertyState(NONE)
  53 {
  54     if ( !xContext.is() || !rDocProp.is() )
  55         throw uno::RuntimeException();
  56 }
  57
  58 OOXMLDocPropHandler::~OOXMLDocPropHandler()
  59 {
  60 }
  61
  62 void OOXMLDocPropHandler::InitNew()
  63 {
  64     m_nState = 0;
  65     m_nBlock = 0;
  66     m_aCustomPropertyName.clear();
  67     m_nType = 0;
  68     m_nInBlock = 0;
  69     m_CustomStringPropertyState = NONE;
  70 }
  71
  72 void OOXMLDocPropHandler::AddCustomProperty( const uno::Any& aAny )
  73 {
  74     if ( !m_aCustomPropertyName.isEmpty() )
  75     {
  76         const uno::Reference< beans::XPropertyContainer > xUserProps =
  77             m_xDocProp->getUserDefinedProperties();
  78         if ( !xUserProps.is() )
  79             throw uno::RuntimeException();
  80
  81         try
  82         {
  83             xUserProps->addProperty( m_aCustomPropertyName,
  84                     beans::PropertyAttribute::REMOVABLE, aAny );
  85         }
  86         catch( beans::PropertyExistException& )
  87         {
  88             // conflicts with core and extended properties are possible
  89         }
  90         catch( uno::Exception& )
  91         {
  92             OSL_FAIL( "Can not add custom property!" );
  93         }
  94     }
  95 }
  96
  97 util::DateTime OOXMLDocPropHandler::GetDateTimeFromW3CDTF( const OUString& aChars )
  98 {
  99     oslDateTime aOslDTime = { 0, 0, 0, 0, 0, 0, 0, 0 };
 100     const sal_Int32 nLen = aChars.getLength();
 101     if ( nLen >= 4 )
 102     {
 103         aOslDTime.Year = static_cast<sal_Int16>(aChars.copy( 0, 4 ).toInt32());
 104
 105         if ( nLen >= 7 && aChars[4] == '-' )
 106         {
 107             aOslDTime.Month = static_cast<sal_uInt16>(aChars.copy( 5, 2 ).toInt32());
 108
 109             if ( nLen >= 10 && aChars[7] == '-' )
 110             {
 111                 aOslDTime.Day = static_cast<sal_uInt16>(aChars.copy( 8, 2 ).toInt32());
 112
 113                 if ( nLen >= 16 && aChars[10] == 'T' && aChars[13] == ':' )
 114                 {
 115                     aOslDTime.Hours = static_cast<sal_uInt16>(aChars.copy( 11, 2 ).toInt32());
 116                     aOslDTime.Minutes = static_cast<sal_uInt16>(aChars.copy( 14, 2 ).toInt32());
 117
 118                     sal_Int32 nOptTime = 0;
 119                     if ( nLen >= 19 && aChars[16] == ':' )
 120                     {
 121                         aOslDTime.Seconds = static_cast<sal_uInt16>(aChars.copy( 17, 2 ).toInt32());
 122                         nOptTime += 3;
 123                         if ( nLen >= 20 && aChars[19] == '.' )
 124                         {
 125                             nOptTime += 1;
 126                             sal_Int32 digitPos = 20;
 127                             while (nLen > digitPos && digitPos < 29)
 128                             {
 129                                 sal_Unicode c = aChars[digitPos];
 130                                 if ( c < '0' || c > '9')
 131                                     break;
 132                                 aOslDTime.NanoSeconds *= 10;
 133                                 aOslDTime.NanoSeconds += c - '0';
 134                                 ++digitPos;
 135                             }
 136                             if ( digitPos < 29 )
 137                             {
 138                                 // read less digits than 9
 139                                 // add correct exponent of 10
 140                                 nOptTime += digitPos - 20;
 141                                 for(; digitPos<29; ++digitPos)
 142                                 {
 143                                     aOslDTime.NanoSeconds *= 10;
 144                                 }
 145                             }
 146                             else
 147                             {
 148                                 //skip digits with more precision than we can handle
 149                                 while(nLen > digitPos)
 150                                 {
 151                                     sal_Unicode c = aChars[digitPos];
 152                                     if ( c < '0' || c > '9')
 153                                         break;
 154                                     ++digitPos;
 155                                 }
 156                                 nOptTime += digitPos - 20;
 157                             }
 158                         }
 159                     }
 160
 161                     sal_Int32 nModif = 0;
 162                     if ( nLen >= 16 + nOptTime + 6 )
 163                     {
 164                         if ( ( aChars[16 + nOptTime] == '+' || aChars[16 + nOptTime] == '-' )
 165                           && aChars[16 + nOptTime + 3] == ':' )
 166                         {
 167                             nModif = aChars.copy( 16 + nOptTime + 1, 2 ).toInt32() * 3600;
 168                             nModif += aChars.copy( 16 + nOptTime + 4, 2 ).toInt32() * 60;
 169                             if ( aChars[16 + nOptTime] == '-' )
 170                                 nModif *= -1;
 171                         }
 172                     }
 173
 174                     if ( nModif )
 175                     {
 176                         // convert to UTC time
 177                         TimeValue aTmp;
 178                         if ( osl_getTimeValueFromDateTime( &aOslDTime, &aTmp ) )
 179                         {
 180                             aTmp.Seconds -= nModif;
 181                             osl_getDateTimeFromTimeValue( &aTmp, &aOslDTime );
 182                         }
 183                     }
 184                 }
 185             }
 186         }
 187     }
 188
 189     return util::DateTime( aOslDTime.NanoSeconds, aOslDTime.Seconds,
 190             aOslDTime.Minutes, aOslDTime.Hours,
 191             aOslDTime.Day, aOslDTime.Month, aOslDTime.Year, false);
 192 }
 193
 194 uno::Sequence< OUString > OOXMLDocPropHandler::GetKeywordsSet( const OUString& aChars )
 195 {
 196     if ( !aChars.isEmpty() )
 197     {
 198         std::string aUtf8Chars = OUStringToOString( aChars, RTL_TEXTENCODING_UTF8 ).getStr();
 199         std::vector<std::string> aUtf8Result;
 200         boost::split( aUtf8Result, aUtf8Chars, boost::is_any_of(" ,;:\t"), boost::token_compress_on );
 201
 202         if (!aUtf8Result.empty())
 203         {
 204             uno::Sequence< OUString > aResult( aUtf8Result.size() );
 205             OUString* pResultValues = aResult.getArray();
 206             for (auto const& elem : aUtf8Result)
 207             {
 208                 *pResultValues = OUString( elem.c_str(), static_cast< sal_Int32 >( elem.size() ),RTL_TEXTENCODING_UTF8 );
 209                 ++pResultValues;
 210             }
 211
 212             return aResult;
 213         }
 214     }
 215     return uno::Sequence< OUString >();
 216 }
 217
 218 void OOXMLDocPropHandler::UpdateDocStatistic( const OUString& aChars )
 219 {
 220     uno::Sequence< beans::NamedValue > aSet = m_xDocProp->getDocumentStatistics();
 221     OUString aName;
 222
 223     switch( m_nBlock )
 224     {
 225     case EXTPR_TOKEN( Characters ):
 226         aName = "NonWhitespaceCharacterCount";
 227         break;
 228
 229     case EXTPR_TOKEN( CharactersWithSpaces ):
 230         aName = "CharacterCount";
 231         break;
 232
 233     case EXTPR_TOKEN( Pages ):
 234         aName = "PageCount";
 235         break;
 236
 237     case EXTPR_TOKEN( Words ):
 238         aName = "WordCount";
 239         break;
 240
 241     case EXTPR_TOKEN( Paragraphs ):
 242         aName = "ParagraphCount";
 243         break;
 244
 245     default:
 246         OSL_FAIL( "Unexpected statistic!" );
 247         break;
 248     }
 249
 250     if ( !aName.isEmpty() )
 251     {
 252         sal_Int32 nInd = 0;
 253         for ( auto pProp = aSet.getConstArray(); nInd < aSet.getLength(); ++nInd )
 254             if ( pProp[nInd].Name == aName )
 255                 break;
 256
 257         if (nInd == aSet.getLength())
 258             aSet.realloc( nInd + 1 );
 259
 260         beans::NamedValue aProp;
 261         aProp.Name = aName;
 262         aProp.Value <<= aChars.toInt32();
 263
 264         aSet[nInd] = aProp;
 265
 266         m_xDocProp->setDocumentStatistics( aSet );
 267     }
 268 }
 269
 270 // com.sun.star.xml.sax.XFastDocumentHandler
 271
 272 void SAL_CALL OOXMLDocPropHandler::startDocument()
 273 {
 274 }
 275
 276 void SAL_CALL OOXMLDocPropHandler::endDocument()
 277 {
 278     InitNew();
 279 }
 280
 281 void OOXMLDocPropHandler::processingInstruction( const OUString& /*rTarget*/, const OUString& /*rData*/ )
 282 {
 283 }
 284
 285 void SAL_CALL OOXMLDocPropHandler::setDocumentLocator( const uno::Reference< xml::sax::XLocator >& )
 286 {
 287 }
 288
 289 // com.sun.star.xml.sax.XFastContextHandler
 290
 291 void SAL_CALL OOXMLDocPropHandler::startFastElement( ::sal_Int32 nElement, const uno::Reference< xml::sax::XFastAttributeList >& xAttribs )
 292 {
 293     if ( !m_nInBlock && !m_nState )
 294     {
 295         if ( nElement == COREPR_TOKEN( coreProperties )
 296           || nElement == EXTPR_TOKEN( Properties )
 297           || nElement == CUSTPR_TOKEN( Properties ) )
 298         {
 299             m_nState = nElement;
 300         }
 301         else
 302         {
 303                 OSL_FAIL( "Unexpected file format!" );
 304         }
 305     }
 306     else if ( m_nState && m_nInBlock == 1 ) // that tag should contain the property name
 307     {
 308         // Currently the attributes are ignored for the core properties since the only
 309         // known attribute is xsi:type that can only be used with dcterms:created and
 310         // dcterms:modified, and this element is allowed currently to have only one value dcterms:W3CDTF
 311         m_nBlock = nElement;
 312
 313         if ( xAttribs.is() && xAttribs->hasAttribute( XML_name ) )
 314             m_aCustomPropertyName = xAttribs->getValue( XML_name );
 315     }
 316     else if ( m_nState && m_nInBlock == 2 && getNamespace( nElement ) == NMSP_officeDocPropsVT )
 317     {
 318         m_nType = nElement;
 319     }
 320     else
 321     {
 322         SAL_WARN("oox", "OOXMLDocPropHandler::startFastElement: unknown element " << getBaseToken(nElement));
 323     }
 324
 325     if ( m_nInBlock == SAL_MAX_INT32 )
 326         throw uno::RuntimeException();
 327
 328     m_nInBlock++;
 329 }
 330
 331 void SAL_CALL OOXMLDocPropHandler::startUnknownElement( const OUString& aNamespace, const OUString& aName, const uno::Reference< xml::sax::XFastAttributeList >& )
 332 {
 333     SAL_WARN("oox", "Unknown element " << aNamespace << ":" << aName);
 334
 335     if ( m_nInBlock == SAL_MAX_INT32 )
 336         throw uno::RuntimeException();
 337
 338     m_nInBlock++;
 339 }
 340
 341 void SAL_CALL OOXMLDocPropHandler::endFastElement( ::sal_Int32 )
 342 {
 343     if ( m_nInBlock )
 344     {
 345         m_nInBlock--;
 346
 347         if ( !m_nInBlock )
 348             m_nState = 0;
 349         else if ( m_nInBlock == 1 )
 350         {
 351             m_nBlock = 0;
 352             m_aCustomPropertyName.clear();
 353         }
 354         else if ( m_nInBlock == 2 )
 355         {
 356             if (   m_nState == CUSTPR_TOKEN(Properties)
 357                 && m_nBlock == CUSTPR_TOKEN(property))
 358             {
 359                 switch (m_nType)
 360                 {
 361                     case VT_TOKEN(bstr):
 362                     case VT_TOKEN(lpstr):
 363                     case VT_TOKEN(lpwstr):
 364                         if (!m_aCustomPropertyName.isEmpty() &&
 365                             INSERTED != m_CustomStringPropertyState)
 366                         {
 367                             // the property has string type, so it is valid
 368                             // even with an empty value - characters() has
 369                             // not been called in that case
 370                             AddCustomProperty(uno::makeAny(OUString()));
 371                         }
 372                     break;
 373                 }
 374             }
 375             m_CustomStringPropertyState = NONE;
 376             m_nType = 0;
 377         }
 378     }
 379 }
 380
 381 void SAL_CALL OOXMLDocPropHandler::endUnknownElement( const OUString&, const OUString& )
 382 {
 383     if ( m_nInBlock )
 384         m_nInBlock--;
 385 }
 386
 387 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL OOXMLDocPropHandler::createFastChildContext( ::sal_Int32, const uno::Reference< xml::sax::XFastAttributeList >& )
 388 {
 389     // Should the arguments be parsed?
 390     return uno::Reference< xml::sax::XFastContextHandler >( static_cast< xml::sax::XFastContextHandler* >( this ) );
 391 }
 392
 393 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL OOXMLDocPropHandler::createUnknownChildContext( const OUString&, const OUString&, const uno::Reference< xml::sax::XFastAttributeList >& )
 394 {
 395     return uno::Reference< xml::sax::XFastContextHandler >( static_cast< xml::sax::XFastContextHandler* >( this ) );
 396 }
 397
 398 void SAL_CALL OOXMLDocPropHandler::characters( const OUString& aChars )
 399 {
 400     try
 401     {
 402         if ( (m_nInBlock == 2) || ((m_nInBlock == 3) && m_nType) )
 403         {
 404             if ( m_nState == COREPR_TOKEN( coreProperties ) )
 405             {
 406                 switch( m_nBlock )
 407                 {
 408                 case COREPR_TOKEN( category ):
 409                     m_aCustomPropertyName = "category";
 410                     AddCustomProperty( uno::makeAny( aChars ) ); // the property has string type
 411                     break;
 412
 413                 case COREPR_TOKEN( contentStatus ):
 414                     m_aCustomPropertyName = "contentStatus";
 415                     AddCustomProperty( uno::makeAny( aChars ) ); // the property has string type
 416                     break;
 417
 418                 case COREPR_TOKEN( contentType ):
 419                     m_aCustomPropertyName = "contentType";
 420                     AddCustomProperty( uno::makeAny( aChars ) ); // the property has string type
 421                     break;
 422
 423                 case COREPR_TOKEN( identifier ):
 424                     m_aCustomPropertyName = "identifier";
 425                     AddCustomProperty( uno::makeAny( aChars ) ); // the property has string type
 426                     break;
 427
 428                 case COREPR_TOKEN( version ):
 429                     m_aCustomPropertyName = "version";
 430                     AddCustomProperty( uno::makeAny( aChars ) ); // the property has string type
 431                     break;
 432
 433                 case DCT_TOKEN( created ):
 434                     if ( aChars.getLength() >= 4 )
 435                         m_xDocProp->setCreationDate( GetDateTimeFromW3CDTF( aChars ) );
 436                     break;
 437
 438                 case DC_TOKEN( creator ):
 439                     m_xDocProp->setAuthor( aChars );
 440                     break;
 441
 442                 case DC_TOKEN( description ):
 443                     m_xDocProp->setDescription( aChars );
 444                     break;
 445
 446                 case COREPR_TOKEN( keywords ):
 447                     m_xDocProp->setKeywords( GetKeywordsSet( aChars ) );
 448                     break;
 449
 450                 case DC_TOKEN( language ):
 451                     if ( aChars.getLength() >= 2 )
 452                         m_xDocProp->setLanguage( LanguageTag::convertToLocale( aChars) );
 453                     break;
 454
 455                 case COREPR_TOKEN( lastModifiedBy ):
 456                     m_xDocProp->setModifiedBy( aChars );
 457                     break;
 458
 459                 case COREPR_TOKEN( lastPrinted ):
 460                     if ( aChars.getLength() >= 4 )
 461                         m_xDocProp->setPrintDate( GetDateTimeFromW3CDTF( aChars ) );
 462                     break;
 463
 464                 case DCT_TOKEN( modified ):
 465                     if ( aChars.getLength() >= 4 )
 466                         m_xDocProp->setModificationDate( GetDateTimeFromW3CDTF( aChars ) );
 467                     break;
 468
 469                 case COREPR_TOKEN( revision ):
 470                     try
 471                     {
 472                         m_xDocProp->setEditingCycles(
 473                             static_cast<sal_Int16>(aChars.toInt32()) );
 474                     }
 475                     catch (lang::IllegalArgumentException &)
 476                     {
 477                         // ignore
 478                     }
 479                     break;
 480
 481                 case DC_TOKEN( subject ):
 482                     m_xDocProp->setSubject( m_xDocProp->getSubject() + aChars );
 483                     break;
 484
 485                 case DC_TOKEN( title ):
 486                     m_xDocProp->setTitle( m_xDocProp->getTitle() + aChars );
 487                     break;
 488
 489                 default:
 490                     OSL_FAIL( "Unexpected core property!" );
 491                 }
 492             }
 493             else if ( m_nState == EXTPR_TOKEN( Properties ) )
 494             {
 495                 switch( m_nBlock )
 496                 {
 497                 case EXTPR_TOKEN( Application ):
 498                     m_xDocProp->setGenerator( aChars );
 499                     break;
 500
 501                 case EXTPR_TOKEN( Template ):
 502                     m_xDocProp->setTemplateName( aChars );
 503                     break;
 504
 505                 case EXTPR_TOKEN( TotalTime ):
 506                 {
 507                     sal_Int32 nDuration;
 508                     if (!o3tl::checked_multiply<sal_Int32>(aChars.toInt32(), 60, nDuration))
 509                     {
 510                         try
 511                         {
 512                             // The TotalTime is in mins as per ECMA specification.
 513                             m_xDocProp->setEditingDuration(nDuration);
 514                         }
 515                         catch (const lang::IllegalArgumentException&)
 516                         {
 517                             // ignore
 518                         }
 519                     }
 520                     break;
 521                 }
 522                 case EXTPR_TOKEN( Characters ):
 523                 case EXTPR_TOKEN( CharactersWithSpaces ):
 524                 case EXTPR_TOKEN( Pages ):
 525                 case EXTPR_TOKEN( Words ):
 526                 case EXTPR_TOKEN( Paragraphs ):
 527                     UpdateDocStatistic( aChars );
 528                 break;
 529
 530                 case EXTPR_TOKEN( HyperlinksChanged ):
 531                     m_aCustomPropertyName = "HyperlinksChanged";
 532                     AddCustomProperty( uno::makeAny( aChars.toBoolean() ) ); // the property has boolean type
 533                     break;
 534
 535                 case EXTPR_TOKEN( LinksUpToDate ):
 536                     m_aCustomPropertyName = "LinksUpToDate";
 537                     AddCustomProperty( uno::makeAny( aChars.toBoolean() ) ); // the property has boolean type
 538                     break;
 539
 540                 case EXTPR_TOKEN( ScaleCrop ):
 541                     m_aCustomPropertyName = "ScaleCrop";
 542                     AddCustomProperty( uno::makeAny( aChars.toBoolean() ) ); // the property has boolean type
 543                     break;
 544
 545                 case EXTPR_TOKEN( SharedDoc ):
 546                     m_aCustomPropertyName = "ShareDoc";
 547                     AddCustomProperty( uno::makeAny( aChars.toBoolean() ) ); // the property has boolean type
 548                     break;
 549
 550                 case EXTPR_TOKEN( DocSecurity ):
 551                     m_aCustomPropertyName = "DocSecurity";
 552                     AddCustomProperty( uno::makeAny( aChars.toInt32() ) ); // the property has sal_Int32 type
 553                     break;
 554
 555                 case EXTPR_TOKEN( HiddenSlides ):
 556                     m_aCustomPropertyName = "HiddenSlides";
 557                     AddCustomProperty( uno::makeAny( aChars.toInt32() ) ); // the property has sal_Int32 type
 558                     break;
 559
 560                 case EXTPR_TOKEN( MMClips ):
 561                     m_aCustomPropertyName = "MMClips";
 562                     AddCustomProperty( uno::makeAny( aChars.toInt32() ) ); // the property has sal_Int32 type
 563                     break;
 564
 565                 case EXTPR_TOKEN( Notes ):
 566                     m_aCustomPropertyName = "Notes";
 567                     AddCustomProperty( uno::makeAny( aChars.toInt32() ) ); // the property has sal_Int32 type
 568                     break;
 569
 570                 case EXTPR_TOKEN( Slides ):
 571                     m_aCustomPropertyName = "Slides";
 572                     AddCustomProperty( uno::makeAny( aChars.toInt32() ) ); // the property has sal_Int32 type
 573                     break;
 574
 575                 case EXTPR_TOKEN( AppVersion ):
 576                     m_aCustomPropertyName = "AppVersion";
 577                     AddCustomProperty( uno::makeAny( aChars ) ); // the property has string type
 578                     break;
 579
 580                 case EXTPR_TOKEN( Company ):
 581                     m_aCustomPropertyName = "Company";
 582                     AddCustomProperty( uno::makeAny( aChars ) ); // the property has string type
 583                     break;
 584
 585                 case EXTPR_TOKEN( HyperlinkBase ):
 586                     m_aCustomPropertyName = "HyperlinkBase";
 587                     AddCustomProperty( uno::makeAny( aChars ) ); // the property has string type
 588                     break;
 589
 590                 case EXTPR_TOKEN( Manager ):
 591                     m_aCustomPropertyName = "Manager";
 592                     AddCustomProperty( uno::makeAny( aChars ) ); // the property has string type
 593                     break;
 594
 595                 case EXTPR_TOKEN( PresentationFormat ):
 596                     m_aCustomPropertyName = "PresentationFormat";
 597                     AddCustomProperty( uno::makeAny( aChars ) ); // the property has string type
 598                     break;
 599
 600                 case EXTPR_TOKEN( Lines ):
 601                 case EXTPR_TOKEN( DigSig ):
 602                 case EXTPR_TOKEN( HeadingPairs ):
 603                 case EXTPR_TOKEN( HLinks ):
 604                 case EXTPR_TOKEN( TitlesOfParts ):
 605                     // ignored during the import currently
 606                     break;
 607
 608                 default:
 609                     OSL_FAIL( "Unexpected extended property!" );
 610                 }
 611             }
 612             else if ( m_nState == CUSTPR_TOKEN( Properties ) )
 613             {
 614                 if ( m_nBlock == CUSTPR_TOKEN( property ) )
 615                 {
 616                     // this is a custom property
 617                     switch( m_nType )
 618                     {
 619                     case VT_TOKEN( bool ):
 620                         AddCustomProperty( uno::makeAny( aChars.toBoolean() ) );
 621                         break;
 622
 623                     case VT_TOKEN( bstr ):
 624                     case VT_TOKEN( lpstr ):
 625                     case VT_TOKEN( lpwstr ):
 626                         // the property has string type
 627                         AddCustomProperty( uno::makeAny( AttributeConversion::decodeXString( aChars ) ) );
 628                         m_CustomStringPropertyState = INSERTED;
 629                         break;
 630
 631                     case VT_TOKEN( date ):
 632                     case VT_TOKEN( filetime ):
 633                         AddCustomProperty( uno::makeAny( GetDateTimeFromW3CDTF( aChars ) ) );
 634                         break;
 635
 636                     case VT_TOKEN( i1 ):
 637                     case VT_TOKEN( i2 ):
 638                         AddCustomProperty( uno::makeAny( static_cast<sal_Int16>(aChars.toInt32()) ) );
 639                         break;
 640
 641                     case VT_TOKEN( i4 ):
 642                     case VT_TOKEN( int ):
 643                         AddCustomProperty( uno::makeAny( aChars.toInt32() ) );
 644                         break;
 645
 646                     case VT_TOKEN( i8 ):
 647                         AddCustomProperty( uno::makeAny( aChars.toInt64() ) );
 648                         break;
 649
 650                     case VT_TOKEN( r4 ):
 651                         AddCustomProperty( uno::makeAny( aChars.toFloat() ) );
 652                         break;
 653
 654                     case VT_TOKEN( r8 ):
 655                         AddCustomProperty( uno::makeAny( aChars.toDouble() ) );
 656                         break;
 657
 658                     default:
 659                         // all the other types are ignored;
 660                         break;
 661                     }
 662                 }
 663                 else
 664                 {
 665                     OSL_FAIL( "Unexpected tag in custom property!" );
 666                 }
 667             }
 668         }
 669     }
 670     catch( uno::RuntimeException& )
 671     {
 672         throw;
 673     }
 674     catch( xml::sax::SAXException& )
 675     {
 676         throw;
 677     }
 678     catch( uno::Exception& )
 679     {
 680         css::uno::Any anyEx = cppu::getCaughtException();
 681         throw xml::sax::SAXException(
 682             "Error while setting document property!",
 683             uno::Reference< uno::XInterface >(),
 684             anyEx );
 685     }
 686 }
 687
 688 } // namespace docprop
 689 } // namespace oox
 690
 691 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */