xmloff/source/forms/propertyexport.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: propertyexport.cxx,v $
  10  * $Revision: 1.37 $
  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
  34 #include <stdio.h>
  35 #include "propertyexport.hxx"
  36 #include <xmloff/xmlexp.hxx>
  37 #include "strings.hxx"
  38 #include "xmlnmspe.hxx"
  39 #include <xmloff/xmluconv.hxx>
  40 #include <xmloff/families.hxx>
  41 #include <osl/diagnose.h>
  42 #include <com/sun/star/beans/PropertyAttribute.hpp>
  43 #include <com/sun/star/beans/XPropertyState.hpp>
  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 <osl/diagnose.h>
  48 #include <comphelper/extract.hxx>
  49 #include <comphelper/sequence.hxx>
  50 #include <comphelper/types.hxx>
  51 #include "callbacks.hxx"
  52 #include <unotools/datetime.hxx>
  53 #include <tools/date.hxx>
  54 #include <tools/time.hxx>
  55 #include <tools/datetime.hxx>
  56
  57 //.........................................................................
  58 namespace xmloff
  59 {
  60 //.........................................................................
  61
  62     using namespace ::com::sun::star::uno;
  63     using namespace ::com::sun::star::lang;
  64     using namespace ::com::sun::star::beans;
  65
  66     // NO using namespace ...util !!!
  67     // need a tools Date/Time/DateTime below, which would conflict with the uno types then
  68
  69     using namespace ::comphelper;
  70
  71     //=====================================================================
  72     //= OPropertyExport
  73     //=====================================================================
  74     //---------------------------------------------------------------------
  75     OPropertyExport::OPropertyExport(IFormsExportContext& _rContext, const Reference< XPropertySet >& _rxProps)
  76         :m_rContext(_rContext)
  77         ,m_xProps(_rxProps)
  78     {
  79         // caching
  80         ::rtl::OUStringBuffer aBuffer;
  81         m_rContext.getGlobalContext().GetMM100UnitConverter().convertBool(aBuffer, sal_True);
  82         m_sValueTrue = aBuffer.makeStringAndClear();
  83         m_rContext.getGlobalContext().GetMM100UnitConverter().convertBool(aBuffer, sal_False);
  84         m_sValueFalse = aBuffer.makeStringAndClear();
  85
  86         m_xPropertyInfo = m_xProps->getPropertySetInfo();
  87         OSL_ENSURE(m_xPropertyInfo.is(), "OPropertyExport::OPropertyExport: need an XPropertySetInfo!");
  88
  89         // collect the properties which need to be exported
  90         examinePersistence();
  91     }
  92
  93     //---------------------------------------------------------------------
  94     void OPropertyExport::exportRemainingProperties()
  95     {
  96         // the properties tag (will be created if we have at least one no-default property)
  97         SvXMLElementExport* pPropertiesTag = NULL;
  98
  99         try
 100         {
 101             Reference< XPropertyState > xPropertyState( m_xProps, UNO_QUERY );
 102             Reference< XPropertySetInfo > xPSI( m_xProps->getPropertySetInfo() );
 103
 104             Any aValue;
 105             ::rtl::OUString sValue;
 106
 107             // loop through all the properties which are yet to be exported
 108             for (       ConstStringSetIterator  aProperty = m_aRemainingProps.begin();
 109                     aProperty != m_aRemainingProps.end();
 110                     ++aProperty
 111                 )
 112             {
 113                 DBG_CHECK_PROPERTY_NO_TYPE(*aProperty);
 114
 115     #if OSL_DEBUG_LEVEL > 0
 116                 const ::rtl::OUString sPropertyName = *aProperty; (void)sPropertyName;
 117     #endif
 118                 // if the property state is DEFAULT, it does not need to be written - at least
 119                 // if it's a built-in property, and not a dynamically-added one.
 120                 bool bIsDefaultValue =    xPropertyState.is()
 121                                     &&  ( PropertyState_DEFAULT_VALUE == xPropertyState->getPropertyState( *aProperty ) );
 122                 bool bIsDynamicProperty =  xPSI.is()
 123                                         && ( ( xPSI->getPropertyByName( *aProperty ).Attributes & PropertyAttribute::REMOVEABLE ) != 0 );
 124                 if ( bIsDefaultValue && !bIsDynamicProperty )
 125                     continue;
 126
 127                 // now that we have the first sub-tag we need the form:properties element
 128                 if (!pPropertiesTag)
 129                     pPropertiesTag = new SvXMLElementExport(m_rContext.getGlobalContext(), XML_NAMESPACE_FORM, token::XML_PROPERTIES, sal_True, sal_True);
 130
 131                 // add the name attribute
 132                 AddAttribute(XML_NAMESPACE_FORM, token::XML_PROPERTY_NAME, *aProperty);
 133
 134                 // get the value
 135                 aValue = m_xProps->getPropertyValue(*aProperty);
 136
 137                 // the type to export
 138                 Type aExportType;
 139
 140                 // is it a sequence
 141                 sal_Bool bIsSequence = TypeClass_SEQUENCE == aValue.getValueTypeClass();
 142                 // the type of the property, maybe reduced to the element type of a sequence
 143                 if (bIsSequence)
 144                     aExportType = getSequenceElementType( aValue.getValueType() );
 145                 else
 146                     aExportType = aValue.getValueType();
 147
 148                 // the type attribute
 149                 // modified by BerryJia for Bug102407
 150                 bool bIsEmptyValue = TypeClass_VOID == aValue.getValueType().getTypeClass();
 151                 if ( bIsEmptyValue )
 152                 {
 153                     com::sun::star::beans::Property aPropDesc;
 154                     aPropDesc = m_xPropertyInfo->getPropertyByName( *aProperty );
 155                     aExportType = aPropDesc.Type;
 156                 }
 157                 token::XMLTokenEnum eValueType = implGetPropertyXMLType( aExportType );
 158
 159                 if ( bIsEmptyValue )
 160                     AddAttribute( XML_NAMESPACE_OFFICE, token::XML_VALUE_TYPE, token::XML_VOID );
 161                 else
 162                     AddAttribute( XML_NAMESPACE_OFFICE, token::XML_VALUE_TYPE, eValueType );
 163
 164                 token::XMLTokenEnum eValueAttName( token::XML_VALUE );
 165                 switch ( eValueType )
 166                 {
 167                 case token::XML_BOOLEAN:    eValueAttName = token::XML_BOOLEAN_VALUE; break;
 168                 case token::XML_STRING:     eValueAttName = token::XML_STRING_VALUE;  break;
 169                 default:    break;
 170                 }
 171
 172                 if( !bIsSequence && !bIsEmptyValue )
 173                 {       // the simple case
 174                     //add by BerryJia for Bug102407
 175                     sValue = implConvertAny(aValue);
 176                     AddAttribute(XML_NAMESPACE_OFFICE, eValueAttName, sValue );
 177                 }
 178
 179
 180                 // start the property tag
 181                 SvXMLElementExport aValueTag1(m_rContext.getGlobalContext(),
 182                         XML_NAMESPACE_FORM,
 183                         bIsSequence ? token::XML_LIST_PROPERTY
 184                                     : token::XML_PROPERTY, sal_True, sal_True);
 185
 186                 if (!bIsSequence)
 187                     continue;
 188
 189                 // the not-that-simple case, we need to iterate through the sequence elements
 190                 IIterator* pSequenceIterator = NULL;
 191
 192                 switch ( aExportType.getTypeClass() )
 193                 {
 194                     case TypeClass_STRING:
 195                         pSequenceIterator = new OSequenceIterator< ::rtl::OUString >(aValue);
 196                         break;
 197                     case TypeClass_DOUBLE:
 198                         pSequenceIterator = new OSequenceIterator< double >(aValue);
 199                         break;
 200                     case TypeClass_BOOLEAN:
 201                         pSequenceIterator = new OSequenceIterator< sal_Bool >(aValue);
 202                         break;
 203                     case TypeClass_BYTE:
 204                         pSequenceIterator = new OSequenceIterator< sal_Int8 >(aValue);
 205                         break;
 206                     case TypeClass_SHORT:
 207                         pSequenceIterator = new OSequenceIterator< sal_Int16 >(aValue);
 208                         break;
 209                     case TypeClass_LONG:
 210                         pSequenceIterator = new OSequenceIterator< sal_Int32 >(aValue);
 211                         break;
 212                     case TypeClass_HYPER:
 213                         pSequenceIterator = new OSequenceIterator< sal_Int64 >(aValue);
 214                         break;
 215                     default:
 216                         OSL_ENSURE(sal_False, "OPropertyExport::exportRemainingProperties: unsupported sequence tyoe !");
 217                         break;
 218                 }
 219                 if (pSequenceIterator)
 220                 {
 221                     while (pSequenceIterator->hasMoreElements())
 222                     {
 223                         sValue =
 224                             implConvertAny(pSequenceIterator->nextElement());
 225                         AddAttribute(XML_NAMESPACE_OFFICE, eValueAttName, sValue );
 226                         SvXMLElementExport aValueTag(
 227                                 m_rContext.getGlobalContext(),
 228                                 XML_NAMESPACE_FORM, token::XML_LIST_VALUE,
 229                                 sal_True, sal_False);
 230                     }
 231                 }
 232                 delete pSequenceIterator;
 233             }
 234         }
 235         catch(...)
 236         {
 237             delete pPropertiesTag;
 238             throw;
 239         }
 240         delete pPropertiesTag;
 241     }
 242
 243     //---------------------------------------------------------------------
 244     void OPropertyExport::examinePersistence()
 245     {
 246         m_aRemainingProps.clear();
 247         Sequence< Property > aProperties = m_xPropertyInfo->getProperties();
 248         const Property* pProperties = aProperties.getConstArray();
 249         for (sal_Int32 i=0; i<aProperties.getLength(); ++i, ++pProperties)
 250         {
 251             // no transient props
 252             if ( pProperties->Attributes & PropertyAttribute::TRANSIENT )
 253                 continue;
 254             // no read-only props
 255             if ( ( pProperties->Attributes & PropertyAttribute::READONLY ) != 0 )
 256                 // except they're dynamically added
 257                 if ( ( pProperties->Attributes & PropertyAttribute::REMOVEABLE ) == 0 )
 258                     continue;
 259             m_aRemainingProps.insert(pProperties->Name);
 260         }
 261     }
 262
 263     //---------------------------------------------------------------------
 264     void OPropertyExport::exportStringPropertyAttribute( const sal_uInt16 _nNamespaceKey, const sal_Char* _pAttributeName,
 265             const ::rtl::OUString& _rPropertyName )
 266     {
 267         DBG_CHECK_PROPERTY( _rPropertyName, ::rtl::OUString );
 268
 269         // no try-catch here, this would be to expensive. The outer scope has to handle exceptions (which should not
 270         // happen if we're used correctly :)
 271
 272         // this is way simple, as we don't need to convert anything (the property already is a string)
 273
 274         // get the string
 275         ::rtl::OUString sPropValue;
 276         m_xProps->getPropertyValue( _rPropertyName ) >>= sPropValue;
 277
 278         // add the attribute
 279         if ( sPropValue.getLength() )
 280             AddAttribute( _nNamespaceKey, _pAttributeName, sPropValue );
 281
 282         // the property does not need to be handled anymore
 283         exportedProperty( _rPropertyName );
 284     }
 285
 286     //---------------------------------------------------------------------
 287     void OPropertyExport::exportBooleanPropertyAttribute(const sal_uInt16 _nNamespaceKey, const sal_Char* _pAttributeName,
 288             const ::rtl::OUString& _rPropertyName, const sal_Int8 _nBooleanAttributeFlags)
 289     {
 290         DBG_CHECK_PROPERTY_NO_TYPE( _rPropertyName );
 291         // no check of the property value type: this method is allowed to be called with any interger properties
 292         // (e.g. sal_Int32, sal_uInt16 etc)
 293
 294         sal_Bool bDefault = (BOOLATTR_DEFAULT_TRUE == (BOOLATTR_DEFAULT_MASK & _nBooleanAttributeFlags));
 295         sal_Bool bDefaultVoid = (BOOLATTR_DEFAULT_VOID == (BOOLATTR_DEFAULT_MASK & _nBooleanAttributeFlags));
 296
 297         // get the value
 298         sal_Bool bCurrentValue = bDefault;
 299         Any aCurrentValue = m_xProps->getPropertyValue( _rPropertyName );
 300         if (aCurrentValue.hasValue())
 301         {
 302             bCurrentValue = ::cppu::any2bool(aCurrentValue);
 303             // this will extract a boolean value even if the Any contains a int or short or something like that ...
 304
 305             if (_nBooleanAttributeFlags & BOOLATTR_INVERSE_SEMANTICS)
 306                 bCurrentValue = !bCurrentValue;
 307
 308             // we have a non-void current value
 309             if (bDefaultVoid || (bDefault != bCurrentValue))
 310                 // and (the default is void, or the non-void default does not equal the current value)
 311                 // -> write the attribute
 312                 AddAttribute(_nNamespaceKey, _pAttributeName, bCurrentValue ? m_sValueTrue : m_sValueFalse);
 313         }
 314         else
 315             // we have a void current value
 316             if (!bDefaultVoid)
 317                 // and we have a non-void default
 318                 // -> write the attribute
 319                 AddAttribute(_nNamespaceKey, _pAttributeName, bCurrentValue ? m_sValueTrue : m_sValueFalse);
 320
 321         // the property does not need to be handled anymore
 322         exportedProperty( _rPropertyName );
 323     }
 324
 325     //---------------------------------------------------------------------
 326     void OPropertyExport::exportInt16PropertyAttribute(const sal_uInt16 _nNamespaceKey, const sal_Char* _pAttributeName,
 327         const ::rtl::OUString& _rPropertyName, const sal_Int16 _nDefault)
 328     {
 329         DBG_CHECK_PROPERTY( _rPropertyName, sal_Int16 );
 330
 331         // get the value
 332         sal_Int16 nCurrentValue(_nDefault);
 333         m_xProps->getPropertyValue( _rPropertyName ) >>= nCurrentValue;
 334
 335         // add the attribute
 336         if (_nDefault != nCurrentValue)
 337         {
 338             // let the formatter of the export context build a string
 339             ::rtl::OUStringBuffer sBuffer;
 340             m_rContext.getGlobalContext().GetMM100UnitConverter().convertNumber(sBuffer, (sal_Int32)nCurrentValue);
 341
 342             AddAttribute(_nNamespaceKey, _pAttributeName, sBuffer.makeStringAndClear());
 343         }
 344
 345         // the property does not need to be handled anymore
 346         exportedProperty( _rPropertyName );
 347     }
 348
 349     //---------------------------------------------------------------------
 350     void OPropertyExport::exportInt32PropertyAttribute( const sal_uInt16 _nNamespaceKey, const sal_Char* _pAttributeName,
 351         const ::rtl::OUString& _rPropertyName, const sal_Int32 _nDefault )
 352     {
 353         DBG_CHECK_PROPERTY( _rPropertyName, sal_Int32 );
 354
 355         // get the value
 356         sal_Int32 nCurrentValue( _nDefault );
 357         m_xProps->getPropertyValue( _rPropertyName ) >>= nCurrentValue;
 358
 359         // add the attribute
 360         if ( _nDefault != nCurrentValue )
 361         {
 362             // let the formatter of the export context build a string
 363             ::rtl::OUStringBuffer sBuffer;
 364             m_rContext.getGlobalContext().GetMM100UnitConverter().convertNumber( sBuffer, nCurrentValue );
 365
 366             AddAttribute( _nNamespaceKey, _pAttributeName, sBuffer.makeStringAndClear() );
 367         }
 368
 369         // the property does not need to be handled anymore
 370         exportedProperty( _rPropertyName );
 371     }
 372
 373     //---------------------------------------------------------------------
 374     void OPropertyExport::exportEnumPropertyAttribute(
 375             const sal_uInt16 _nNamespaceKey, const sal_Char* _pAttributeName,
 376             const sal_Char* _pPropertyName, const SvXMLEnumMapEntry* _pValueMap,
 377             const sal_Int32 _nDefault, const sal_Bool _bVoidDefault)
 378     {
 379         // get the value
 380         sal_Int32 nCurrentValue(_nDefault);
 381         ::rtl::OUString sPropertyName(::rtl::OUString::createFromAscii(_pPropertyName));
 382         Any aValue = m_xProps->getPropertyValue(sPropertyName);
 383
 384         if (aValue.hasValue())
 385         {       // we have a non-void current value
 386             ::cppu::enum2int(nCurrentValue, aValue);
 387
 388             // add the attribute
 389             if ((_nDefault != nCurrentValue) || _bVoidDefault)
 390             {   // the default does not equal the value, or the default is void and the value isn't
 391
 392                 // let the formatter of the export context build a string
 393                 ::rtl::OUStringBuffer sBuffer;
 394                 m_rContext.getGlobalContext().GetMM100UnitConverter().convertEnum(sBuffer, (sal_uInt16)nCurrentValue, _pValueMap);
 395
 396                 AddAttribute(_nNamespaceKey, _pAttributeName, sBuffer.makeStringAndClear());
 397             }
 398         }
 399         else
 400         {
 401             if (!_bVoidDefault)
 402                 AddAttributeASCII(_nNamespaceKey, _pAttributeName, "");
 403         }
 404
 405         // the property does not need to be handled anymore
 406         exportedProperty(sPropertyName);
 407     }
 408
 409     //---------------------------------------------------------------------
 410     void OPropertyExport::exportTargetFrameAttribute()
 411     {
 412         DBG_CHECK_PROPERTY( PROPERTY_TARGETFRAME, ::rtl::OUString );
 413
 414         ::rtl::OUString sTargetFrame = comphelper::getString(m_xProps->getPropertyValue(PROPERTY_TARGETFRAME));
 415         if (0 != sTargetFrame.compareToAscii("_blank"))
 416         {       // an empty string and "_blank" have the same meaning and don't have to be written
 417             AddAttribute(OAttributeMetaData::getCommonControlAttributeNamespace(CCA_TARGET_FRAME)
 418                         ,OAttributeMetaData::getCommonControlAttributeName(CCA_TARGET_FRAME)
 419                         ,sTargetFrame);
 420         }
 421
 422         exportedProperty(PROPERTY_TARGETFRAME);
 423     }
 424
 425     //---------------------------------------------------------------------
 426     void OPropertyExport::exportRelativeTargetLocation(const ConstAsciiString& _sPropertyName,sal_Int32 _nProperty)
 427     {
 428         DBG_CHECK_PROPERTY( _sPropertyName, ::rtl::OUString );
 429
 430         ::rtl::OUString sTargetLocation = comphelper::getString(m_xProps->getPropertyValue(_sPropertyName));
 431         if ( sTargetLocation.getLength() )
 432                     // If this isn't a GraphicObject then GetRelativeReference
 433                     // will be called anyway ( in AddEmbeddedGraphic )
 434             sTargetLocation = m_rContext.getGlobalContext().AddEmbeddedGraphicObject(sTargetLocation);
 435         AddAttribute(OAttributeMetaData::getCommonControlAttributeNamespace(_nProperty)
 436                     ,OAttributeMetaData::getCommonControlAttributeName(_nProperty)
 437                     , sTargetLocation);
 438
 439         exportedProperty(_sPropertyName);
 440     }
 441     //---------------------------------------------------------------------
 442     void OPropertyExport::flagStyleProperties()
 443     {
 444         // flag all the properties which are part of the style as "handled"
 445         UniReference< XMLPropertySetMapper > xStylePropertiesSupplier = m_rContext.getStylePropertyMapper()->getPropertySetMapper();
 446         for (sal_Int32 i=0; i<xStylePropertiesSupplier->GetEntryCount(); ++i)
 447             exportedProperty(xStylePropertiesSupplier->GetEntryAPIName(i));
 448
 449         // the font properties are exported as single properties, but there is a FontDescriptor property which
 450         // collects them all-in-one, this has been exported implicitly
 451         exportedProperty(PROPERTY_FONT);
 452
 453         // for the DateFormat and TimeFormat, there exist wrapper properties which has been exported as
 454         // style, too
 455         exportedProperty(PROPERTY_DATEFORMAT);
 456         exportedProperty(PROPERTY_TIMEFORMAT);
 457
 458         // the following properties should have been exported at the shape already:
 459         exportedProperty( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "VerticalAlign" ) ) );
 460         exportedProperty( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "WritingMode" ) ) );
 461         exportedProperty( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ScaleMode" ) ) );
 462         // ditto the TextWritingMode
 463         exportedProperty( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "WritingMode" ) ) );
 464     }
 465
 466     //---------------------------------------------------------------------
 467     void OPropertyExport::exportGenericPropertyAttribute(
 468             const sal_uInt16 _nAttributeNamespaceKey, const sal_Char* _pAttributeName, const sal_Char* _pPropertyName)
 469     {
 470         DBG_CHECK_PROPERTY_ASCII_NO_TYPE( _pPropertyName );
 471
 472         ::rtl::OUString sPropertyName = ::rtl::OUString::createFromAscii(_pPropertyName);
 473         exportedProperty(sPropertyName);
 474
 475         Any aCurrentValue = m_xProps->getPropertyValue(sPropertyName);
 476         if (!aCurrentValue.hasValue())
 477             // nothing to do without a concrete value
 478             return;
 479
 480         ::rtl::OUString sValue = implConvertAny(aCurrentValue);
 481         if (!sValue.getLength() && (TypeClass_STRING == aCurrentValue.getValueTypeClass()))
 482         {
 483             // check whether or not the property is allowed to be VOID
 484             Property aProperty = m_xPropertyInfo->getPropertyByName(sPropertyName);
 485             if ((aProperty.Attributes & PropertyAttribute::MAYBEVOID) == 0)
 486                 // the string is empty, and the property is not allowed to be void
 487                 // -> don't need to write the attibute, 'cause missing it is unambiguous
 488                 return;
 489         }
 490
 491         // finally add the attribuite to the context
 492         AddAttribute(_nAttributeNamespaceKey, _pAttributeName, sValue);
 493     }
 494
 495     //---------------------------------------------------------------------
 496     void OPropertyExport::exportStringSequenceAttribute(const sal_uInt16 _nAttributeNamespaceKey, const sal_Char* _pAttributeName,
 497         const ::rtl::OUString& _rPropertyName,
 498         const sal_Unicode _aQuoteCharacter, const sal_Unicode _aListSeparator)
 499     {
 500         DBG_CHECK_PROPERTY( _rPropertyName, Sequence< ::rtl::OUString > );
 501         OSL_ENSURE(_aListSeparator != 0, "OPropertyExport::exportStringSequenceAttribute: invalid separator character!");
 502
 503         Sequence< ::rtl::OUString > aItems;
 504         m_xProps->getPropertyValue( _rPropertyName ) >>= aItems;
 505
 506         ::rtl::OUString sFinalList;
 507
 508         // unfortunately the OUString can't append single sal_Unicode characters ...
 509         const ::rtl::OUString sQuote(&_aQuoteCharacter, 1);
 510         const ::rtl::OUString sSeparator(&_aListSeparator, 1);
 511         const sal_Bool bQuote = 0 != sQuote.getLength();
 512
 513         // concatenate the string items
 514         const ::rtl::OUString* pItems = aItems.getConstArray();
 515         const ::rtl::OUString* pEnd = pItems + aItems.getLength();
 516         const ::rtl::OUString* pLastElement = pEnd - 1;
 517         for     (       ;
 518                 pItems != pEnd;
 519                 ++pItems
 520             )
 521         {
 522             OSL_ENSURE(!_aQuoteCharacter || (-1 == pItems->indexOf(_aQuoteCharacter)),
 523                 "OPropertyExport::exportStringSequenceAttribute: there is an item which contains the quote character!");
 524             OSL_ENSURE(_aQuoteCharacter || (-1 == pItems->indexOf(_aListSeparator)),
 525                 "OPropertyExport::exportStringSequenceAttribute: no quote character, but there is an item containing the separator character!");
 526
 527             if (bQuote)
 528                 sFinalList += sQuote;
 529             sFinalList += *pItems;
 530             if (bQuote)
 531                 sFinalList += sQuote;
 532
 533             if (pItems != pLastElement)
 534                 sFinalList += sSeparator;
 535         }
 536
 537         if (sFinalList.getLength())
 538             AddAttribute(_nAttributeNamespaceKey, _pAttributeName, sFinalList);
 539
 540         exportedProperty( _rPropertyName );
 541     }
 542
 543     //---------------------------------------------------------------------
 544     ::rtl::OUString OPropertyExport::implConvertAny(const Any& _rValue)
 545     {
 546         ::rtl::OUStringBuffer aBuffer;
 547         switch (_rValue.getValueTypeClass())
 548         {
 549             case TypeClass_STRING:
 550             {   // extract the string
 551                 ::rtl::OUString sCurrentValue;
 552                 _rValue >>= sCurrentValue;
 553                 aBuffer.append(sCurrentValue);
 554             }
 555             break;
 556             case TypeClass_DOUBLE:
 557                 // let the unit converter format is as string
 558                 m_rContext.getGlobalContext().GetMM100UnitConverter().convertDouble(aBuffer, getDouble(_rValue));
 559                 break;
 560             case TypeClass_BOOLEAN:
 561                 aBuffer = getBOOL(_rValue) ? m_sValueTrue : m_sValueFalse;
 562                 break;
 563             case TypeClass_BYTE:
 564             case TypeClass_SHORT:
 565             case TypeClass_LONG:
 566                 // let the unit converter format is as string
 567                 m_rContext.getGlobalContext().GetMM100UnitConverter().convertNumber(aBuffer, getINT32(_rValue));
 568                 break;
 569             case TypeClass_HYPER:
 570                 // TODO
 571                 OSL_ENSURE(sal_False, "OPropertyExport::implConvertAny: missing implementation for sal_Int64!");
 572                 break;
 573             case TypeClass_ENUM:
 574             {
 575                 // convert it into an int32
 576                 sal_Int32 nValue = 0;
 577                 ::cppu::enum2int(nValue, _rValue);
 578                 m_rContext.getGlobalContext().GetMM100UnitConverter().convertNumber(aBuffer, nValue);
 579             }
 580             break;
 581             default:
 582             {   // hmmm .... what else do we know?
 583                 double fValue = 0;
 584                 ::com::sun::star::util::Date aDate;
 585                 ::com::sun::star::util::Time aTime;
 586                 ::com::sun::star::util::DateTime aDateTime;
 587                 if (_rValue >>= aDate)
 588                 {
 589                     Date aToolsDate;
 590                     ::utl::typeConvert(aDate, aToolsDate);
 591                     fValue = aToolsDate.GetDate();
 592                 }
 593                 else if (_rValue >>= aTime)
 594                 {
 595                     fValue = ((aTime.Hours * 60 + aTime.Minutes) * 60 + aTime.Seconds) * 100 + aTime.HundredthSeconds;
 596                     fValue = fValue / 8640000.0;
 597                 }
 598                 else if (_rValue >>= aDateTime)
 599                 {
 600                     DateTime aToolsDateTime;
 601                     ::utl::typeConvert(aDateTime, aToolsDateTime);
 602                     // the time part (the digits behind the comma)
 603                     fValue = ((aDateTime.Hours * 60 + aDateTime.Minutes) * 60 + aDateTime.Seconds) * 100 + aDateTime.HundredthSeconds;
 604                     fValue = fValue / 8640000.0;
 605                     // plus the data part (the digits in front of the comma)
 606                     fValue += aToolsDateTime.GetDate();
 607                 }
 608                 else
 609                 {
 610                     // if any other types are added here, please remember to adjust implGetPropertyXMLType accordingly
 611
 612                     // no more options ...
 613                     OSL_ENSURE(sal_False, "OPropertyExport::implConvertAny: unsupported value type!");
 614                     break;
 615                 }
 616                 // let the unit converter format is as string
 617                 m_rContext.getGlobalContext().GetMM100UnitConverter().convertDouble(aBuffer, fValue);
 618             }
 619             break;
 620         }
 621
 622         return aBuffer.makeStringAndClear();
 623     }
 624
 625
 626     //---------------------------------------------------------------------
 627     token::XMLTokenEnum OPropertyExport::implGetPropertyXMLType(const ::com::sun::star::uno::Type& _rType)
 628     {
 629         // handle the type description
 630         switch (_rType.getTypeClass())
 631         {
 632             case TypeClass_STRING:
 633                 return token::XML_STRING;
 634             case TypeClass_DOUBLE:
 635             case TypeClass_BYTE:
 636             case TypeClass_SHORT:
 637             case TypeClass_LONG:
 638             case TypeClass_HYPER:
 639             case TypeClass_ENUM:
 640                 return token::XML_FLOAT;
 641             case TypeClass_BOOLEAN:
 642                 return token::XML_BOOLEAN;
 643
 644             default:
 645                 return token::XML_FLOAT;
 646         }
 647     }
 648
 649 #ifdef DBG_UTIL
 650     //---------------------------------------------------------------------
 651     void OPropertyExport::AddAttribute(sal_uInt16 _nPrefix, const sal_Char* _pName, const ::rtl::OUString& _rValue)
 652     {
 653         OSL_ENSURE(0 == m_rContext.getGlobalContext().GetXAttrList()->getValueByName(::rtl::OUString::createFromAscii(_pName)).getLength(),
 654             "OPropertyExport::AddAttribute: already have such an attribute");
 655
 656         m_rContext.getGlobalContext().AddAttribute(_nPrefix, _pName, _rValue);
 657     }
 658
 659     //---------------------------------------------------------------------
 660     void OPropertyExport::AddAttribute( sal_uInt16 _nPrefix, const ::rtl::OUString& _rName, const ::rtl::OUString& _rValue )
 661     {
 662         OSL_ENSURE(0 == m_rContext.getGlobalContext().GetXAttrList()->getValueByName( _rName ).getLength(),
 663             "OPropertyExport::AddAttribute: already have such an attribute");
 664
 665         m_rContext.getGlobalContext().AddAttribute( _nPrefix, _rName, _rValue );
 666     }
 667
 668     //---------------------------------------------------------------------
 669     void OPropertyExport::AddAttributeASCII(sal_uInt16 _nPrefix, const sal_Char* _pName, const sal_Char *pValue)
 670     {
 671         OSL_ENSURE(0 == m_rContext.getGlobalContext().GetXAttrList()->getValueByName(::rtl::OUString::createFromAscii(_pName)).getLength(),
 672             "OPropertyExport::AddAttributeASCII: already have such an attribute");
 673
 674         m_rContext.getGlobalContext().AddAttributeASCII(_nPrefix, _pName, pValue);
 675     }
 676
 677     //---------------------------------------------------------------------
 678     void OPropertyExport::AddAttribute(sal_uInt16 _nPrefix, ::xmloff::token::XMLTokenEnum _eName, const ::rtl::OUString& _rValue)
 679     {
 680         OSL_ENSURE(0 == m_rContext.getGlobalContext().GetXAttrList()->getValueByName(::xmloff::token::GetXMLToken(_eName)).getLength(),
 681             "OPropertyExport::AddAttribute: already have such an attribute");
 682
 683         m_rContext.getGlobalContext().AddAttribute(_nPrefix, _eName, _rValue);
 684     }
 685
 686     //---------------------------------------------------------------------
 687     void OPropertyExport::AddAttribute(sal_uInt16 _nPrefix, ::xmloff::token::XMLTokenEnum _eName, ::xmloff::token::XMLTokenEnum _eValue )
 688     {
 689         OSL_ENSURE(0 == m_rContext.getGlobalContext().GetXAttrList()->getValueByName(::xmloff::token::GetXMLToken(_eName)).getLength(),
 690             "OPropertyExport::AddAttribute: already have such an attribute");
 691
 692         m_rContext.getGlobalContext().AddAttribute(_nPrefix, _eName, _eValue);
 693     }
 694
 695     //---------------------------------------------------------------------
 696     void OPropertyExport::dbg_implCheckProperty(const ::rtl::OUString& _rPropertyName, const Type* _pType)
 697     {
 698         try
 699         {
 700             // the property must exist
 701             if (!m_xPropertyInfo->hasPropertyByName(_rPropertyName))
 702             {
 703                 OSL_ENSURE(sal_False,
 704                     ::rtl::OString("OPropertyExport::dbg_implCheckProperty: no property with the name ") +=
 705                     ::rtl::OString(_rPropertyName.getStr(), _rPropertyName.getLength(), RTL_TEXTENCODING_ASCII_US) +=
 706                     ::rtl::OString("!"));
 707                 return;
 708             }
 709
 710             if (_pType)
 711             {
 712                 // and it must have the correct type
 713                 Property aPropertyDescription = m_xPropertyInfo->getPropertyByName(_rPropertyName);
 714                 OSL_ENSURE(aPropertyDescription.Type.equals(*_pType), "OPropertyExport::dbg_implCheckProperty: invalid property type!");
 715             }
 716         }
 717         catch(Exception&)
 718         {
 719             OSL_ENSURE(sal_False, "OPropertyExport::dbg_implCheckProperty: caught an exception, could not check the property!");
 720         }
 721     }
 722 #endif // DBG_UTIL - dbg_implCheckProperty
 723
 724 //.........................................................................
 725 }       // namespace xmloff
 726 //.........................................................................
 727
 728