diff options
Diffstat (limited to 'xmloff/source/style/xmlimppr.cxx')
| -rw-r--r-- | xmloff/source/style/xmlimppr.cxx | 784 |
1 files changed, 784 insertions, 0 deletions
diff --git a/xmloff/source/style/xmlimppr.cxx b/xmloff/source/style/xmlimppr.cxx new file mode 100644 index 000000000000..79b2974706e5 --- /dev/null +++ b/xmloff/source/style/xmlimppr.cxx @@ -0,0 +1,784 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_xmloff.hxx" +#include <com/sun/star/xml/AttributeData.hpp> +#include <com/sun/star/beans/XMultiPropertySet.hpp> +#include <com/sun/star/lang/IllegalArgumentException.hpp> +#include <com/sun/star/lang/WrappedTargetException.hpp> +#include <com/sun/star/beans/UnknownPropertyException.hpp> +#include <com/sun/star/beans/PropertyVetoException.hpp> +#include <com/sun/star/beans/TolerantPropertySetResultType.hpp> +#include <rtl/ustrbuf.hxx> +#include <xmloff/xmlprmap.hxx> +#include <xmloff/nmspmap.hxx> +#include <xmloff/xmlimppr.hxx> +#include <xmloff/xmlimp.hxx> + +#include "xmloff/unoatrcn.hxx" +#include "xmloff/xmlnmspe.hxx" +#include <xmloff/xmltoken.hxx> +#include "xmloff/xmlerror.hxx" +#include <tools/debug.hxx> + +#include "xmloff/contextid.hxx" + +// STL includes +#include <algorithm> +#include <functional> +#include <utility> +#include <vector> + +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::container; +using namespace ::com::sun::star::xml; +using namespace ::com::sun::star::xml::sax; +using ::rtl::OUString; +using ::rtl::OUStringBuffer; + +using namespace ::std; +using namespace ::xmloff::token; +using ::com::sun::star::lang::IllegalArgumentException; +using ::com::sun::star::lang::WrappedTargetException; +using ::com::sun::star::beans::UnknownPropertyException; +using ::com::sun::star::beans::PropertyVetoException; + + +SvXMLImportPropertyMapper::SvXMLImportPropertyMapper( + const UniReference< XMLPropertySetMapper >& rMapper, + SvXMLImport& rImp ): + rImport(rImp), + maPropMapper ( rMapper ) +{ +} + +SvXMLImportPropertyMapper::~SvXMLImportPropertyMapper() +{ + mxNextMapper = 0; +} + +void SvXMLImportPropertyMapper::ChainImportMapper( + const UniReference< SvXMLImportPropertyMapper>& rMapper ) +{ + // add map entries from rMapper to current map + maPropMapper->AddMapperEntry( rMapper->getPropertySetMapper() ); + // rMapper uses the same map as 'this' + rMapper->maPropMapper = maPropMapper; + + // set rMapper as last mapper in current chain + UniReference< SvXMLImportPropertyMapper > xNext = mxNextMapper; + if( xNext.is()) + { + while( xNext->mxNextMapper.is()) + xNext = xNext->mxNextMapper; + xNext->mxNextMapper = rMapper; + } + else + mxNextMapper = rMapper; + + // if rMapper was already chained, correct + // map pointer of successors + xNext = rMapper; + + while( xNext->mxNextMapper.is()) + { + xNext = xNext->mxNextMapper; + xNext->maPropMapper = maPropMapper; + } +} + +void SvXMLImportPropertyMapper::importXML( + vector< XMLPropertyState >& rProperties, + Reference< XAttributeList > xAttrList, + const SvXMLUnitConverter& rUnitConverter, + const SvXMLNamespaceMap& rNamespaceMap, + sal_uInt32 nPropType ) const +{ + importXML( rProperties, xAttrList, rUnitConverter, rNamespaceMap, + nPropType,-1, -1 ); +} + +/** fills the given itemset with the attributes in the given list */ +void SvXMLImportPropertyMapper::importXML( + vector< XMLPropertyState >& rProperties, + Reference< XAttributeList > xAttrList, + const SvXMLUnitConverter& rUnitConverter, + const SvXMLNamespaceMap& rNamespaceMap, + sal_uInt32 nPropType, + sal_Int32 nStartIdx, + sal_Int32 nEndIdx ) const +{ + sal_Int16 nAttr = xAttrList->getLength(); + + Reference< XNameContainer > xAttrContainer; + + if( -1 == nStartIdx ) + nStartIdx = 0; + if( -1 == nEndIdx ) + nEndIdx = maPropMapper->GetEntryCount(); + for( sal_Int16 i=0; i < nAttr; i++ ) + { + const OUString& rAttrName = xAttrList->getNameByIndex( i ); + OUString aLocalName, aPrefix, aNamespace; + sal_uInt16 nPrefix = rNamespaceMap.GetKeyByAttrName( rAttrName, &aPrefix, + &aLocalName, &aNamespace ); + + if( XML_NAMESPACE_XMLNS == nPrefix ) + continue; + + const OUString& rValue = xAttrList->getValueByIndex( i ); + + // index of actual property map entry + // This looks very strange, but it works well: + // If the start index is 0, the new value will become -1, and + // GetEntryIndex will start searching with position 0. + // Otherwise GetEntryIndex will start with the next position specified. + sal_Int32 nIndex = nStartIdx - 1; + sal_uInt32 nFlags = 0; // flags of actual property map entry + sal_Bool bFound = sal_False; + + // for better error reporting: this should be set true if no + // warning is needed + sal_Bool bNoWarning = sal_False; + bool bAlienImport = false; + + do + { + // find an entry for this attribute + nIndex = maPropMapper->GetEntryIndex( nPrefix, aLocalName, + nPropType, nIndex ); + + if( nIndex > -1 && nIndex < nEndIdx ) + { + // create a XMLPropertyState with an empty value + + nFlags = maPropMapper->GetEntryFlags( nIndex ); + if( (( nFlags & MID_FLAG_NO_PROPERTY ) == MID_FLAG_NO_PROPERTY) && (maPropMapper->GetEntryContextId( nIndex ) == CTF_ALIEN_ATTRIBUTE_IMPORT) ) + { + bAlienImport = true; + nIndex = -1; + } + else + { + if( ( nFlags & MID_FLAG_ELEMENT_ITEM_IMPORT ) == 0 ) + { + XMLPropertyState aNewProperty( nIndex ); + sal_Int32 nReference = -1; + + // if this is a multi attribute check if another attribute already set + // this any. If so use this as a initial value + if( ( nFlags & MID_FLAG_MERGE_PROPERTY ) != 0 ) + { + const OUString aAPIName( maPropMapper->GetEntryAPIName( nIndex ) ); + const sal_Int32 nSize = rProperties.size(); + for( nReference = 0; nReference < nSize; nReference++ ) + { + sal_Int32 nRefIdx = rProperties[nReference].mnIndex; + if( (nRefIdx != -1) && (nIndex != nRefIdx) && + (maPropMapper->GetEntryAPIName( nRefIdx ) == aAPIName )) + { + aNewProperty = rProperties[nReference]; + aNewProperty.mnIndex = nIndex; + break; + } + } + + if( nReference == nSize ) + nReference = -1; + } + + sal_Bool bSet = sal_False; + if( ( nFlags & MID_FLAG_SPECIAL_ITEM_IMPORT ) == 0 ) + { + // let the XMLPropertySetMapper decide how to import the value + bSet = maPropMapper->importXML( rValue, aNewProperty, + rUnitConverter ); + } + else + { + sal_uInt32 nOldSize = rProperties.size(); + + bSet = handleSpecialItem( aNewProperty, rProperties, + rValue, rUnitConverter, + rNamespaceMap ); + + // no warning if handleSpecialItem added properties + bNoWarning |= ( nOldSize != rProperties.size() ); + } + + // no warning if we found could set the item. This + // 'remembers' bSet across multi properties. + bNoWarning |= bSet; + + // store the property in the given vector + if( bSet ) + { + if( nReference == -1 ) + rProperties.push_back( aNewProperty ); + else + rProperties[nReference] = aNewProperty; + } + else + { + // warn about unknown value. Unless it's a + // multi property: Then we get another chance + // to set the value. + if( !bNoWarning && + ((nFlags & MID_FLAG_MULTI_PROPERTY) == 0) ) + { + Sequence<OUString> aSeq(2); + aSeq[0] = rAttrName; + aSeq[1] = rValue; + rImport.SetError( XMLERROR_FLAG_WARNING | + XMLERROR_STYLE_ATTR_VALUE, + aSeq ); + } + } + } + bFound = sal_True; + continue; + } + } + + if( !bFound ) + { + if( (XML_NAMESPACE_UNKNOWN_FLAG & nPrefix) || (XML_NAMESPACE_NONE == nPrefix) || bAlienImport ) + { + OSL_ENSURE( XML_NAMESPACE_NONE == nPrefix || + (XML_NAMESPACE_UNKNOWN_FLAG & nPrefix) || + bAlienImport, + "unknown attribute - might be a new feature?" ); + if( !xAttrContainer.is() ) + { + // add an unknown attribute container to the properties + Reference< XNameContainer > xNew( SvUnoAttributeContainer_CreateInstance(), UNO_QUERY ); + xAttrContainer = xNew; + + // find map entry and create new property state + if( -1 == nIndex ) + { + switch( nPropType ) + { + case XML_TYPE_PROP_CHART: + nIndex = maPropMapper->FindEntryIndex( "ChartUserDefinedAttributes", XML_NAMESPACE_TEXT, GetXMLToken(XML_XMLNS) ); + break; + case XML_TYPE_PROP_PARAGRAPH: + nIndex = maPropMapper->FindEntryIndex( "ParaUserDefinedAttributes", XML_NAMESPACE_TEXT, GetXMLToken(XML_XMLNS) ); + break; + case XML_TYPE_PROP_TEXT: + nIndex = maPropMapper->FindEntryIndex( "TextUserDefinedAttributes", XML_NAMESPACE_TEXT, GetXMLToken(XML_XMLNS) ); + break; + default: + break; + } + // other property type or property not found + if( -1 == nIndex ) + nIndex = maPropMapper->FindEntryIndex( "UserDefinedAttributes", XML_NAMESPACE_TEXT, GetXMLToken(XML_XMLNS) ); + } + + // #106963#; use userdefined attribute only if it is in the specified property range + if( nIndex != -1 && nIndex >= nStartIdx && nIndex < nEndIdx) + { + Any aAny; + aAny <<= xAttrContainer; + XMLPropertyState aNewProperty( nIndex, aAny ); + + // push it on our stack so we export it later + rProperties.push_back( aNewProperty ); + } + } + + if( xAttrContainer.is() ) + { + AttributeData aData; + aData.Type = GetXMLToken( XML_CDATA ); + aData.Value = rValue; + + OUStringBuffer sName; + if( XML_NAMESPACE_NONE != nPrefix ) + { + sName.append( aPrefix ); + sName.append( sal_Unicode(':') ); + aData.Namespace = aNamespace; + } + + sName.append( aLocalName ); + + Any aAny; + aAny <<= aData; + xAttrContainer->insertByName( sName.makeStringAndClear(), aAny ); + } + } + } + } + while( ( nIndex >= 0 ) && (( nFlags & MID_FLAG_MULTI_PROPERTY ) != 0 ) ); + } + + finished( rProperties, nStartIdx, nEndIdx ); + + // Have to do if we change from a vector to a list or something like that + /*std::vector <XMLPropertyState>::iterator aItr = rProperties.begin(); + while (aItr != rProperties.end()) + { + if (aItr->mnIndex == -1) + aItr = rProperties.erase(aItr); + else + aItr++; + }*/ +} + +/** this method is called for every item that has the MID_FLAG_SPECIAL_ITEM_IMPORT flag set */ +sal_Bool SvXMLImportPropertyMapper::handleSpecialItem( + XMLPropertyState& rProperty, + vector< XMLPropertyState >& rProperties, + const OUString& rValue, + const SvXMLUnitConverter& rUnitConverter, + const SvXMLNamespaceMap& rNamespaceMap ) const +{ + OSL_ENSURE( mxNextMapper.is(), "unsuported special item in xml import" ); + if( mxNextMapper.is() ) + return mxNextMapper->handleSpecialItem( rProperty, rProperties, rValue, + rUnitConverter, rNamespaceMap ); + else + return sal_False; +} + +void SvXMLImportPropertyMapper::FillPropertySequence( + const ::std::vector< XMLPropertyState >& rProperties, + ::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue >& rValues ) + const +{ + sal_Int32 nCount = rProperties.size(); + sal_Int32 nValueCount = 0; + rValues.realloc( nCount ); + PropertyValue *pProps = rValues.getArray(); + for( sal_Int32 i=0; i < nCount; i++ ) + { + const XMLPropertyState& rProp = rProperties[i]; + sal_Int32 nIdx = rProp.mnIndex; + if( nIdx == -1 ) + continue; + pProps->Name = maPropMapper->GetEntryAPIName( nIdx ); + if( pProps->Name.getLength() ) + { + pProps->Value <<= rProp.maValue; + ++pProps; + ++nValueCount; + } + } + if( nValueCount < nCount ) + rValues.realloc( nValueCount ); +} + +void SvXMLImportPropertyMapper::CheckSpecialContext( + const ::std::vector< XMLPropertyState >& aProperties, + const ::com::sun::star::uno::Reference< + ::com::sun::star::beans::XPropertySet > rPropSet, + _ContextID_Index_Pair* pSpecialContextIds ) const +{ + OSL_ENSURE( rPropSet.is(), "need an XPropertySet" ); + sal_Int32 nCount = aProperties.size(); + + Reference< XPropertySetInfo > xInfo(rPropSet->getPropertySetInfo()); + + for( sal_Int32 i=0; i < nCount; i++ ) + { + const XMLPropertyState& rProp = aProperties[i]; + sal_Int32 nIdx = rProp.mnIndex; + + // disregard property state if it has an invalid index + if( -1 == nIdx ) + continue; + + const sal_Int32 nPropFlags = maPropMapper->GetEntryFlags( nIdx ); + + // handle no-property and special items + if( ( pSpecialContextIds != NULL ) && + ( ( 0 != ( nPropFlags & MID_FLAG_NO_PROPERTY_IMPORT ) ) || + ( 0 != ( nPropFlags & MID_FLAG_SPECIAL_ITEM_IMPORT ) ) ) ) + { + // maybe it's one of our special context ids? + sal_Int16 nContextId = maPropMapper->GetEntryContextId(nIdx); + + for ( sal_Int32 n = 0; + pSpecialContextIds[n].nContextID != -1; + n++ ) + { + // found: set index in pSpecialContextIds array + if ( pSpecialContextIds[n].nContextID == nContextId ) + { + pSpecialContextIds[n].nIndex = i; + break; // early out + } + } + } + } + +} + +sal_Bool SvXMLImportPropertyMapper::FillPropertySet( + const vector< XMLPropertyState >& aProperties, + const Reference< XPropertySet > rPropSet, + _ContextID_Index_Pair* pSpecialContextIds ) const +{ + sal_Bool bSet = sal_False; + + Reference< XTolerantMultiPropertySet > xTolPropSet( rPropSet, UNO_QUERY ); + if (xTolPropSet.is()) + bSet = _FillTolerantMultiPropertySet( aProperties, xTolPropSet, maPropMapper, rImport, + pSpecialContextIds ); + + if (!bSet) + { + // get property set info + Reference< XPropertySetInfo > xInfo(rPropSet->getPropertySetInfo()); + + // check for multi-property set + Reference<XMultiPropertySet> xMultiPropSet( rPropSet, UNO_QUERY ); + if ( xMultiPropSet.is() ) + { + // Try XMultiPropertySet. If that fails, try the regular route. + bSet = _FillMultiPropertySet( aProperties, xMultiPropSet, + xInfo, maPropMapper, + pSpecialContextIds ); + if ( !bSet ) + bSet = _FillPropertySet( aProperties, rPropSet, + xInfo, maPropMapper, rImport, + pSpecialContextIds); + } + else + bSet = _FillPropertySet( aProperties, rPropSet, xInfo, + maPropMapper, rImport, + pSpecialContextIds ); + } + + return bSet; +} + +sal_Bool SvXMLImportPropertyMapper::_FillPropertySet( + const vector<XMLPropertyState> & rProperties, + const Reference<XPropertySet> & rPropSet, + const Reference<XPropertySetInfo> & rPropSetInfo, + const UniReference<XMLPropertySetMapper> & rPropMapper, + SvXMLImport& rImport, + _ContextID_Index_Pair* pSpecialContextIds ) +{ + OSL_ENSURE( rPropSet.is(), "need an XPropertySet" ); + OSL_ENSURE( rPropSetInfo.is(), "need an XPropertySetInfo" ); + + // preliminaries + sal_Bool bSet = sal_False; + sal_Int32 nCount = rProperties.size(); + + // iterate over property states that we want to set + for( sal_Int32 i=0; i < nCount; i++ ) + { + const XMLPropertyState& rProp = rProperties[i]; + sal_Int32 nIdx = rProp.mnIndex; + + // disregard property state if it has an invalid index + if( -1 == nIdx ) + continue; + + const OUString& rPropName = rPropMapper->GetEntryAPIName( nIdx ); + const sal_Int32 nPropFlags = rPropMapper->GetEntryFlags( nIdx ); + + if ( ( 0 == ( nPropFlags & MID_FLAG_NO_PROPERTY ) ) && + ( ( 0 != ( nPropFlags & MID_FLAG_MUST_EXIST ) ) || + rPropSetInfo->hasPropertyByName( rPropName ) ) ) + { + // try setting the property + try + { + rPropSet->setPropertyValue( rPropName, rProp.maValue ); + bSet = sal_True; + } + catch ( IllegalArgumentException& e ) + { + // illegal value: check whether this property is + // allowed to throw this exception + if ( 0 == ( nPropFlags & MID_FLAG_PROPERTY_MAY_EXCEPT ) ) + { + Sequence<OUString> aSeq(1); + aSeq[0] = rPropName; + rImport.SetError( + XMLERROR_STYLE_PROP_VALUE | XMLERROR_FLAG_ERROR, + aSeq, e.Message, NULL ); + } + } + catch ( UnknownPropertyException& e ) + { + // unknown property: This is always an error! + Sequence<OUString> aSeq(1); + aSeq[0] = rPropName; + rImport.SetError( + XMLERROR_STYLE_PROP_UNKNOWN | XMLERROR_FLAG_ERROR, + aSeq, e.Message, NULL ); + } + catch ( PropertyVetoException& e ) + { + // property veto: this shouldn't happen + Sequence<OUString> aSeq(1); + aSeq[0] = rPropName; + rImport.SetError( + XMLERROR_STYLE_PROP_OTHER | XMLERROR_FLAG_ERROR, + aSeq, e.Message, NULL ); + } + catch ( WrappedTargetException& e ) + { + // wrapped target: this shouldn't happen either + Sequence<OUString> aSeq(1); + aSeq[0] = rPropName; + rImport.SetError( + XMLERROR_STYLE_PROP_OTHER | XMLERROR_FLAG_ERROR, + aSeq, e.Message, NULL ); + } + } + + // handle no-property and special items + if( ( pSpecialContextIds != NULL ) && + ( ( 0 != ( nPropFlags & MID_FLAG_NO_PROPERTY_IMPORT ) ) || + ( 0 != ( nPropFlags & MID_FLAG_SPECIAL_ITEM_IMPORT ) ) ) ) + { + // maybe it's one of our special context ids? + sal_Int16 nContextId = rPropMapper->GetEntryContextId(nIdx); + + for ( sal_Int32 n = 0; + pSpecialContextIds[n].nContextID != -1; + n++ ) + { + // found: set index in pSpecialContextIds array + if ( pSpecialContextIds[n].nContextID == nContextId ) + { + pSpecialContextIds[n].nIndex = i; + break; // early out + } + } + } + } + + return bSet; +} + + + +typedef pair<const OUString*, const Any* > PropertyPair; +typedef vector<PropertyPair> PropertyPairs; + +struct PropertyPairLessFunctor : + public binary_function<PropertyPair, PropertyPair, bool> +{ + bool operator()( const PropertyPair& a, const PropertyPair& b ) const + { + return (*a.first < *b.first ? true : false); + } +}; + +void SvXMLImportPropertyMapper::_PrepareForMultiPropertySet( + const vector<XMLPropertyState> & rProperties, + const Reference<XPropertySetInfo> & rPropSetInfo, + const UniReference<XMLPropertySetMapper> & rPropMapper, + _ContextID_Index_Pair* pSpecialContextIds, + Sequence<OUString>& rNames, + Sequence<Any>& rValues) +{ + sal_Int32 nCount = rProperties.size(); + + // property pairs structure stores names + values of properties to be set. + PropertyPairs aPropertyPairs; + aPropertyPairs.reserve( nCount ); + + // iterate over property states that we want to set + sal_Int32 i; + for( i = 0; i < nCount; i++ ) + { + const XMLPropertyState& rProp = rProperties[i]; + sal_Int32 nIdx = rProp.mnIndex; + + // disregard property state if it has an invalid index + if( -1 == nIdx ) + continue; + + const OUString& rPropName = rPropMapper->GetEntryAPIName( nIdx ); + const sal_Int32 nPropFlags = rPropMapper->GetEntryFlags( nIdx ); + + if ( ( 0 == ( nPropFlags & MID_FLAG_NO_PROPERTY ) ) && + ( ( 0 != ( nPropFlags & MID_FLAG_MUST_EXIST ) ) || + !rPropSetInfo.is() || + (rPropSetInfo.is() && rPropSetInfo->hasPropertyByName( rPropName )) ) ) + { + // save property into property pair structure + aPropertyPairs.push_back( PropertyPair( &rPropName, &rProp.maValue ) ); + } + + // handle no-property and special items + if( ( pSpecialContextIds != NULL ) && + ( ( 0 != ( nPropFlags & MID_FLAG_NO_PROPERTY_IMPORT ) ) || + ( 0 != ( nPropFlags & MID_FLAG_SPECIAL_ITEM_IMPORT ) ) ) ) + { + // maybe it's one of our special context ids? + sal_Int16 nContextId = rPropMapper->GetEntryContextId(nIdx); + for ( sal_Int32 n = 0; + pSpecialContextIds[n].nContextID != -1; + n++ ) + { + // found: set index in pSpecialContextIds array + if ( pSpecialContextIds[n].nContextID == nContextId ) + { + pSpecialContextIds[n].nIndex = i; + break; // early out + } + } + } + } + + // We now need to construct the sequences and actually the set + // values. + + // sort the property pairs + sort( aPropertyPairs.begin(), aPropertyPairs.end(), + PropertyPairLessFunctor()); + + // create sequences + rNames.realloc( aPropertyPairs.size() ); + OUString* pNamesArray = rNames.getArray(); + rValues.realloc( aPropertyPairs.size() ); + Any* pValuesArray = rValues.getArray(); + + // copy values into sequences + i = 0; + for( PropertyPairs::iterator aIter = aPropertyPairs.begin(); + aIter != aPropertyPairs.end(); + ++aIter ) + { + pNamesArray[i] = *(aIter->first); + pValuesArray[i++] = *(aIter->second); + } +} + +sal_Bool SvXMLImportPropertyMapper::_FillMultiPropertySet( + const vector<XMLPropertyState> & rProperties, + const Reference<XMultiPropertySet> & rMultiPropSet, + const Reference<XPropertySetInfo> & rPropSetInfo, + const UniReference<XMLPropertySetMapper> & rPropMapper, + _ContextID_Index_Pair* pSpecialContextIds ) +{ + OSL_ENSURE( rMultiPropSet.is(), "Need multi property set. "); + OSL_ENSURE( rPropSetInfo.is(), "Need property set info." ); + + sal_Bool bSuccessful = sal_False; + + Sequence<OUString> aNames; + Sequence<Any> aValues; + + _PrepareForMultiPropertySet(rProperties, rPropSetInfo, rPropMapper, pSpecialContextIds, + aNames, aValues); + + // and, finally, try to set the values + try + { + rMultiPropSet->setPropertyValues( aNames, aValues ); + bSuccessful = sal_True; + } + catch ( ... ) + { + OSL_ENSURE(bSuccessful, "Exception caught; style may not be imported correctly."); + } + + return bSuccessful; +} + +sal_Bool SvXMLImportPropertyMapper::_FillTolerantMultiPropertySet( + const vector<XMLPropertyState> & rProperties, + const Reference<XTolerantMultiPropertySet> & rTolMultiPropSet, + const UniReference<XMLPropertySetMapper> & rPropMapper, + SvXMLImport& rImport, + _ContextID_Index_Pair* pSpecialContextIds ) +{ + OSL_ENSURE( rTolMultiPropSet.is(), "Need tolerant multi property set. "); + + sal_Bool bSuccessful = sal_False; + + Sequence<OUString> aNames; + Sequence<Any> aValues; + + _PrepareForMultiPropertySet(rProperties, Reference<XPropertySetInfo>(NULL), rPropMapper, pSpecialContextIds, + aNames, aValues); + + // and, finally, try to set the values + try + { + Sequence< SetPropertyTolerantFailed > aResults(rTolMultiPropSet->setPropertyValuesTolerant( aNames, aValues )); + if (aResults.getLength() == 0) + bSuccessful = sal_True; + else + { + sal_Int32 nCount(aResults.getLength()); + for( sal_Int32 i = 0; i < nCount; ++i) + { + Sequence<OUString> aSeq(1); + aSeq[0] = aResults[i].Name; + rtl::OUString sMessage; + switch (aResults[i].Result) + { + case TolerantPropertySetResultType::UNKNOWN_PROPERTY : + sMessage = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("UNKNOWN_PROPERTY")); + break; + case TolerantPropertySetResultType::ILLEGAL_ARGUMENT : + sMessage = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ILLEGAL_ARGUMENT")); + break; + case TolerantPropertySetResultType::PROPERTY_VETO : + sMessage = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("PROPERTY_VETO")); + break; + case TolerantPropertySetResultType::WRAPPED_TARGET : + sMessage = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("WRAPPED_TARGET")); + break; + }; + rImport.SetError( + XMLERROR_STYLE_PROP_OTHER | XMLERROR_FLAG_ERROR, + aSeq, sMessage, NULL ); + } + } + } + catch ( ... ) + { + OSL_ENSURE(bSuccessful, "Exception caught; style may not be imported correctly."); + } + + return bSuccessful; +} + +void SvXMLImportPropertyMapper::finished( + vector< XMLPropertyState >& rProperties, + sal_Int32 nStartIndex, sal_Int32 nEndIndex ) const +{ + // nothing to do here + if( mxNextMapper.is() ) + mxNextMapper->finished( rProperties, nStartIndex, nEndIndex ); +} |