| /************************************************************** | |
| * | |
| * Licensed to the Apache Software Foundation (ASF) under one | |
| * or more contributor license agreements. See the NOTICE file | |
| * distributed with this work for additional information | |
| * regarding copyright ownership. The ASF licenses this file | |
| * to you under the Apache License, Version 2.0 (the | |
| * "License"); you may not use this file except in compliance | |
| * with the License. You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| * | |
| *************************************************************/ | |
| // MARKER(update_precomp.py): autogen include statement, do not remove | |
| #include "precompiled_xmloff.hxx" | |
| #include "propertyimport.hxx" | |
| #include <xmloff/xmlimp.hxx> | |
| #include <xmloff/xmluconv.hxx> | |
| #include <xmloff/nmspmap.hxx> | |
| #include <osl/diagnose.h> | |
| #include <comphelper/extract.hxx> | |
| #include "callbacks.hxx" | |
| #include "xmloff/xmlnmspe.hxx" | |
| #include <tools/date.hxx> | |
| #include <tools/time.hxx> | |
| #include <tools/datetime.hxx> | |
| #include <com/sun/star/util/Date.hpp> | |
| #include <com/sun/star/util/Time.hpp> | |
| #include <com/sun/star/util/DateTime.hpp> | |
| #include <unotools/datetime.hxx> | |
| #include <rtl/logfile.hxx> | |
| #if OSL_DEBUG_LEVEL > 0 | |
| #ifndef _OSL_THREAD_H_ | |
| #include <osl/thread.h> | |
| #endif | |
| #endif | |
| //......................................................................... | |
| namespace xmloff | |
| { | |
| //......................................................................... | |
| using namespace ::com::sun::star::uno; | |
| using namespace ::com::sun::star::beans; | |
| using namespace ::com::sun::star::xml; | |
| // NO using namespace ...util !!! | |
| // need a tools Date/Time/DateTime below, which would conflict with the uno types then | |
| #define TYPE_DATE 1 | |
| #define TYPE_TIME 2 | |
| #define TYPE_DATETIME 3 | |
| //===================================================================== | |
| //= PropertyConversion | |
| //===================================================================== | |
| namespace | |
| { | |
| //--------------------------------------------------------------------- | |
| ::com::sun::star::util::Time lcl_getTime(double _nValue) | |
| { | |
| ::com::sun::star::util::Time aTime; | |
| sal_uInt32 nIntValue = sal_Int32(_nValue * 8640000); | |
| nIntValue *= 8640000; | |
| aTime.HundredthSeconds = (sal_uInt16)( nIntValue % 100 ); | |
| nIntValue /= 100; | |
| aTime.Seconds = (sal_uInt16)( nIntValue % 60 ); | |
| nIntValue /= 60; | |
| aTime.Minutes = (sal_uInt16)( nIntValue % 60 ); | |
| nIntValue /= 60; | |
| OSL_ENSURE(nIntValue < 24, "lcl_getTime: more than a day?"); | |
| aTime.Hours = static_cast< sal_uInt16 >( nIntValue ); | |
| return aTime; | |
| } | |
| //--------------------------------------------------------------------- | |
| static ::com::sun::star::util::Date lcl_getDate( double _nValue ) | |
| { | |
| Date aToolsDate((sal_uInt32)_nValue); | |
| ::com::sun::star::util::Date aDate; | |
| ::utl::typeConvert(aToolsDate, aDate); | |
| return aDate; | |
| } | |
| } | |
| //--------------------------------------------------------------------- | |
| Any PropertyConversion::convertString( SvXMLImport& _rImporter, const ::com::sun::star::uno::Type& _rExpectedType, | |
| const ::rtl::OUString& _rReadCharacters, const SvXMLEnumMapEntry* _pEnumMap, const sal_Bool _bInvertBoolean ) | |
| { | |
| Any aReturn; | |
| sal_Bool bEnumAsInt = sal_False; | |
| switch (_rExpectedType.getTypeClass()) | |
| { | |
| case TypeClass_BOOLEAN: // sal_Bool | |
| { | |
| sal_Bool bValue; | |
| #if OSL_DEBUG_LEVEL > 0 | |
| sal_Bool bSuccess = | |
| #endif | |
| _rImporter.GetMM100UnitConverter().convertBool(bValue, _rReadCharacters); | |
| OSL_ENSURE(bSuccess, | |
| ::rtl::OString("PropertyConversion::convertString: could not convert \"") | |
| += ::rtl::OString(_rReadCharacters.getStr(), _rReadCharacters.getLength(), RTL_TEXTENCODING_ASCII_US) | |
| += ::rtl::OString("\" into a boolean!")); | |
| aReturn = ::cppu::bool2any(_bInvertBoolean ? !bValue : bValue); | |
| } | |
| break; | |
| case TypeClass_SHORT: // sal_Int16 | |
| case TypeClass_LONG: // sal_Int32 | |
| if (!_pEnumMap) | |
| { // it's a real int32/16 property | |
| sal_Int32 nValue(0); | |
| #if OSL_DEBUG_LEVEL > 0 | |
| sal_Bool bSuccess = | |
| #endif | |
| _rImporter.GetMM100UnitConverter().convertNumber(nValue, _rReadCharacters); | |
| OSL_ENSURE(bSuccess, | |
| ::rtl::OString("PropertyConversion::convertString: could not convert \"") | |
| += ::rtl::OString(_rReadCharacters.getStr(), _rReadCharacters.getLength(), RTL_TEXTENCODING_ASCII_US) | |
| += ::rtl::OString("\" into an integer!")); | |
| if (TypeClass_SHORT == _rExpectedType.getTypeClass()) | |
| aReturn <<= (sal_Int16)nValue; | |
| else | |
| aReturn <<= (sal_Int32)nValue; | |
| break; | |
| } | |
| bEnumAsInt = sal_True; | |
| // NO BREAK! handle it as enum | |
| case TypeClass_ENUM: | |
| { | |
| sal_uInt16 nEnumValue(0); | |
| #if OSL_DEBUG_LEVEL > 0 | |
| sal_Bool bSuccess = | |
| #endif | |
| _rImporter.GetMM100UnitConverter().convertEnum(nEnumValue, _rReadCharacters, _pEnumMap); | |
| OSL_ENSURE(bSuccess, "PropertyConversion::convertString: could not convert to an enum value!"); | |
| if (bEnumAsInt) | |
| if (TypeClass_SHORT == _rExpectedType.getTypeClass()) | |
| aReturn <<= (sal_Int16)nEnumValue; | |
| else | |
| aReturn <<= (sal_Int32)nEnumValue; | |
| else | |
| aReturn = ::cppu::int2enum((sal_Int32)nEnumValue, _rExpectedType); | |
| } | |
| break; | |
| case TypeClass_HYPER: | |
| { | |
| OSL_ENSURE(sal_False, "PropertyConversion::convertString: 64-bit integers not implemented yet!"); | |
| } | |
| break; | |
| case TypeClass_DOUBLE: | |
| { | |
| double nValue; | |
| #if OSL_DEBUG_LEVEL > 0 | |
| sal_Bool bSuccess = | |
| #endif | |
| _rImporter.GetMM100UnitConverter().convertDouble(nValue, _rReadCharacters); | |
| OSL_ENSURE(bSuccess, | |
| ::rtl::OString("PropertyConversion::convertString: could not convert \"") | |
| += ::rtl::OString(_rReadCharacters.getStr(), _rReadCharacters.getLength(), RTL_TEXTENCODING_ASCII_US) | |
| += ::rtl::OString("\" into a double!")); | |
| aReturn <<= (double)nValue; | |
| } | |
| break; | |
| case TypeClass_STRING: | |
| aReturn <<= _rReadCharacters; | |
| break; | |
| case TypeClass_STRUCT: | |
| { | |
| sal_Int32 nType = 0; | |
| if ( _rExpectedType.equals( ::cppu::UnoType< ::com::sun::star::util::Date >::get() ) ) | |
| nType = TYPE_DATE; | |
| else if ( _rExpectedType.equals( ::cppu::UnoType< ::com::sun::star::util::Time >::get() ) ) | |
| nType = TYPE_TIME; | |
| else if ( _rExpectedType.equals( ::cppu::UnoType< ::com::sun::star::util::DateTime >::get() ) ) | |
| nType = TYPE_DATETIME; | |
| if ( nType ) | |
| { | |
| // first extract the double | |
| double nValue = 0; | |
| #if OSL_DEBUG_LEVEL > 0 | |
| sal_Bool bSuccess = | |
| #endif | |
| _rImporter.GetMM100UnitConverter().convertDouble(nValue, _rReadCharacters); | |
| OSL_ENSURE(bSuccess, | |
| ::rtl::OString("PropertyConversion::convertString: could not convert \"") | |
| += ::rtl::OString(_rReadCharacters.getStr(), _rReadCharacters.getLength(), RTL_TEXTENCODING_ASCII_US) | |
| += ::rtl::OString("\" into a double!")); | |
| // then convert it into the target type | |
| switch (nType) | |
| { | |
| case TYPE_DATE: | |
| { | |
| OSL_ENSURE(((sal_uInt32)nValue) - nValue == 0, | |
| "PropertyConversion::convertString: a Date value with a fractional part?"); | |
| aReturn <<= lcl_getDate(nValue); | |
| } | |
| break; | |
| case TYPE_TIME: | |
| { | |
| OSL_ENSURE(((sal_uInt32)nValue) == 0, | |
| "PropertyConversion::convertString: a Time value with more than a fractional part?"); | |
| aReturn <<= lcl_getTime(nValue); | |
| } | |
| break; | |
| case TYPE_DATETIME: | |
| { | |
| ::com::sun::star::util::Time aTime = lcl_getTime(nValue); | |
| ::com::sun::star::util::Date aDate = lcl_getDate(nValue); | |
| ::com::sun::star::util::DateTime aDateTime; | |
| aDateTime.HundredthSeconds = aTime.HundredthSeconds; | |
| aDateTime.Seconds = aTime.Seconds; | |
| aDateTime.Minutes = aTime.Minutes; | |
| aDateTime.Hours = aTime.Hours; | |
| aDateTime.Day = aDate.Day; | |
| aDateTime.Month = aDate.Month; | |
| aDateTime.Year = aDate.Year; | |
| aReturn <<= aDateTime; | |
| } | |
| break; | |
| } | |
| } | |
| else | |
| OSL_ENSURE(sal_False, "PropertyConversion::convertString: unsupported property type!"); | |
| } | |
| break; | |
| default: | |
| OSL_ENSURE(sal_False, "PropertyConversion::convertString: invalid type class!"); | |
| } | |
| return aReturn; | |
| } | |
| //--------------------------------------------------------------------- | |
| Type PropertyConversion::xmlTypeToUnoType( const ::rtl::OUString& _rType ) | |
| { | |
| Type aUnoType( ::getVoidCppuType() ); | |
| DECLARE_STL_USTRINGACCESS_MAP( ::com::sun::star::uno::Type, MapString2Type ); | |
| static MapString2Type s_aTypeNameMap; | |
| if ( s_aTypeNameMap.empty() ) | |
| { | |
| s_aTypeNameMap[ token::GetXMLToken( token::XML_BOOLEAN ) ] = ::getBooleanCppuType(); | |
| s_aTypeNameMap[ token::GetXMLToken( token::XML_FLOAT ) ] = ::getCppuType( static_cast< double* >(NULL) ); | |
| s_aTypeNameMap[ token::GetXMLToken( token::XML_STRING ) ] = ::getCppuType( static_cast< ::rtl::OUString* >(NULL) ); | |
| s_aTypeNameMap[ token::GetXMLToken( token::XML_VOID ) ] = ::getVoidCppuType(); | |
| } | |
| const ConstMapString2TypeIterator aTypePos = s_aTypeNameMap.find( _rType ); | |
| OSL_ENSURE( s_aTypeNameMap.end() != aTypePos, "PropertyConversion::xmlTypeToUnoType: invalid property name!" ); | |
| if ( s_aTypeNameMap.end() != aTypePos ) | |
| aUnoType = aTypePos->second; | |
| return aUnoType; | |
| } | |
| //===================================================================== | |
| //= OPropertyImport | |
| //===================================================================== | |
| //--------------------------------------------------------------------- | |
| OPropertyImport::OPropertyImport(OFormLayerXMLImport_Impl& _rImport, sal_uInt16 _nPrefix, const ::rtl::OUString& _rName) | |
| :SvXMLImportContext(_rImport.getGlobalContext(), _nPrefix, _rName) | |
| ,m_rContext(_rImport) | |
| ,m_bTrackAttributes(sal_False) | |
| { | |
| } | |
| //--------------------------------------------------------------------- | |
| SvXMLImportContext* OPropertyImport::CreateChildContext(sal_uInt16 _nPrefix, const ::rtl::OUString& _rLocalName, | |
| const Reference< sax::XAttributeList >& _rxAttrList) | |
| { | |
| if( token::IsXMLToken( _rLocalName, token::XML_PROPERTIES) ) | |
| { | |
| return new OPropertyElementsContext( m_rContext.getGlobalContext(), | |
| _nPrefix, _rLocalName, this); | |
| } | |
| else | |
| { | |
| OSL_ENSURE(sal_False, | |
| ::rtl::OString("OPropertyImport::CreateChildContext: unknown sub element (only \"properties\" is recognized, but it is ") | |
| += ::rtl::OString(_rLocalName.getStr(), _rLocalName.getLength(), RTL_TEXTENCODING_ASCII_US) | |
| += ::rtl::OString(")!")); | |
| return SvXMLImportContext::CreateChildContext(_nPrefix, _rLocalName, _rxAttrList); | |
| } | |
| } | |
| //--------------------------------------------------------------------- | |
| void OPropertyImport::StartElement(const Reference< sax::XAttributeList >& _rxAttrList) | |
| { | |
| OSL_ENSURE(_rxAttrList.is(), "OPropertyImport::StartElement: invalid attribute list!"); | |
| const sal_Int32 nAttributeCount = _rxAttrList->getLength(); | |
| // assume the 'worst' case: all attributes describe properties. This should save our property array | |
| // some reallocs | |
| m_aValues.reserve(nAttributeCount); | |
| const SvXMLNamespaceMap& rMap = m_rContext.getGlobalContext().GetNamespaceMap(); | |
| sal_uInt16 nNamespace; | |
| ::rtl::OUString sLocalName; | |
| for (sal_Int16 i=0; i<nAttributeCount; ++i) | |
| { | |
| nNamespace = rMap.GetKeyByAttrName(_rxAttrList->getNameByIndex(i), &sLocalName); | |
| handleAttribute(nNamespace, sLocalName, _rxAttrList->getValueByIndex(i)); | |
| if (m_bTrackAttributes) | |
| m_aEncounteredAttributes.insert(sLocalName); | |
| } | |
| // TODO: create PropertyValues for all the attributes which were not present, because they were implied | |
| // this is necessary as soon as we have properties where the XML default is different from the property | |
| // default | |
| } | |
| //--------------------------------------------------------------------- | |
| sal_Bool OPropertyImport::encounteredAttribute(const ::rtl::OUString& _rAttributeName) const | |
| { | |
| OSL_ENSURE(m_bTrackAttributes, "OPropertyImport::encounteredAttribute: attribute tracking not enabled!"); | |
| return m_aEncounteredAttributes.end() != m_aEncounteredAttributes.find(_rAttributeName); | |
| } | |
| //--------------------------------------------------------------------- | |
| void OPropertyImport::Characters(const ::rtl::OUString& | |
| #if OSL_DEBUG_LEVEL > 0 | |
| _rChars | |
| #endif | |
| ) | |
| { | |
| // ignore them (should be whitespaces only) | |
| OSL_ENSURE(0 == _rChars.trim().getLength(), "OPropertyImport::Characters: non-whitespace characters!"); | |
| } | |
| //--------------------------------------------------------------------- | |
| bool OPropertyImport::handleAttribute(sal_uInt16 /*_nNamespaceKey*/, const ::rtl::OUString& _rLocalName, const ::rtl::OUString& _rValue) | |
| { | |
| const OAttribute2Property::AttributeAssignment* pProperty = m_rContext.getAttributeMap().getAttributeTranslation(_rLocalName); | |
| if (pProperty) | |
| { | |
| // create and store a new PropertyValue | |
| PropertyValue aNewValue; | |
| aNewValue.Name = pProperty->sPropertyName; | |
| // convert the value string into the target type | |
| aNewValue.Value = PropertyConversion::convertString(m_rContext.getGlobalContext(), pProperty->aPropertyType, _rValue, pProperty->pEnumMap, pProperty->bInverseSemantics); | |
| implPushBackPropertyValue( aNewValue ); | |
| return true; | |
| } | |
| if (!token::IsXMLToken(_rLocalName, token::XML_TYPE)) // xlink:type is valid but ignored for <form:form> | |
| { | |
| #if OSL_DEBUG_LEVEL > 0 | |
| ::rtl::OString sMessage( "OPropertyImport::handleAttribute: Can't handle the following:\n" ); | |
| sMessage += ::rtl::OString( " Attribute name: " ); | |
| sMessage += ::rtl::OString( _rLocalName.getStr(), _rLocalName.getLength(), osl_getThreadTextEncoding() ); | |
| sMessage += ::rtl::OString( "\n value: " ); | |
| sMessage += ::rtl::OString( _rValue.getStr(), _rValue.getLength(), osl_getThreadTextEncoding() ); | |
| OSL_ENSURE( sal_False, sMessage.getStr() ); | |
| #endif | |
| return false; | |
| } | |
| return true; | |
| } | |
| //===================================================================== | |
| //= OPropertyElementsContext | |
| //===================================================================== | |
| //--------------------------------------------------------------------- | |
| OPropertyElementsContext::OPropertyElementsContext(SvXMLImport& _rImport, sal_uInt16 _nPrefix, const ::rtl::OUString& _rName, | |
| const OPropertyImportRef& _rPropertyImporter) | |
| :SvXMLImportContext(_rImport, _nPrefix, _rName) | |
| ,m_xPropertyImporter(_rPropertyImporter) | |
| { | |
| } | |
| //--------------------------------------------------------------------- | |
| SvXMLImportContext* OPropertyElementsContext::CreateChildContext(sal_uInt16 _nPrefix, const ::rtl::OUString& _rLocalName, | |
| const Reference< sax::XAttributeList >&) | |
| { | |
| if( token::IsXMLToken( _rLocalName, token::XML_PROPERTY ) ) | |
| { | |
| return new OSinglePropertyContext(GetImport(), _nPrefix, _rLocalName, m_xPropertyImporter); | |
| } | |
| else if( token::IsXMLToken( _rLocalName, token::XML_LIST_PROPERTY ) ) | |
| { | |
| return new OListPropertyContext( GetImport(), _nPrefix, _rLocalName, m_xPropertyImporter ); | |
| } | |
| else | |
| { | |
| OSL_ENSURE(sal_False, | |
| ::rtl::OString("OPropertyElementsContext::CreateChildContext: unknown child element (\"") | |
| += ::rtl::OString(_rLocalName.getStr(), _rLocalName.getLength(), RTL_TEXTENCODING_ASCII_US) | |
| += ::rtl::OString("\")!")); | |
| return new SvXMLImportContext(GetImport(), _nPrefix, _rLocalName); | |
| } | |
| } | |
| #if OSL_DEBUG_LEVEL > 0 | |
| //--------------------------------------------------------------------- | |
| void OPropertyElementsContext::StartElement(const Reference< sax::XAttributeList >& _rxAttrList) | |
| { | |
| OSL_ENSURE(0 == _rxAttrList->getLength(), "OPropertyElementsContext::StartElement: the form:properties element should not have attributes!"); | |
| SvXMLImportContext::StartElement(_rxAttrList); | |
| } | |
| //--------------------------------------------------------------------- | |
| void OPropertyElementsContext::Characters(const ::rtl::OUString& _rChars) | |
| { | |
| OSL_ENSURE(0 == _rChars.trim(), "OPropertyElementsContext::Characters: non-whitespace characters detected!"); | |
| SvXMLImportContext::Characters(_rChars); | |
| } | |
| #endif | |
| //===================================================================== | |
| //= OSinglePropertyContext | |
| //===================================================================== | |
| //--------------------------------------------------------------------- | |
| OSinglePropertyContext::OSinglePropertyContext(SvXMLImport& _rImport, sal_uInt16 _nPrefix, const ::rtl::OUString& _rName, | |
| const OPropertyImportRef& _rPropertyImporter) | |
| :SvXMLImportContext(_rImport, _nPrefix, _rName) | |
| ,m_xPropertyImporter(_rPropertyImporter) | |
| { | |
| } | |
| //--------------------------------------------------------------------- | |
| SvXMLImportContext* OSinglePropertyContext::CreateChildContext(sal_uInt16 _nPrefix, const ::rtl::OUString& _rLocalName, | |
| const Reference< sax::XAttributeList >&) | |
| { | |
| OSL_ENSURE(sal_False, | |
| ::rtl::OString("OSinglePropertyContext::CreateChildContext: unknown child element (\"") | |
| += ::rtl::OString(_rLocalName.getStr(), _rLocalName.getLength(), RTL_TEXTENCODING_ASCII_US) | |
| += ::rtl::OString("\")!")); | |
| return new SvXMLImportContext(GetImport(), _nPrefix, _rLocalName); | |
| } | |
| //--------------------------------------------------------------------- | |
| void OSinglePropertyContext::StartElement(const Reference< sax::XAttributeList >& _rxAttrList) | |
| { | |
| ::com::sun::star::beans::PropertyValue aPropValue; // the property the instance imports currently | |
| ::com::sun::star::uno::Type aPropType; // the type of the property the instance imports currently | |
| ::rtl::OUString sType, sValue; | |
| const SvXMLNamespaceMap& rMap = GetImport().GetNamespaceMap(); | |
| const sal_Int16 nAttrCount = _rxAttrList.is() ? _rxAttrList->getLength() : 0; | |
| for( sal_Int16 i=0; i < nAttrCount; i++ ) | |
| { | |
| const ::rtl::OUString& rAttrName = _rxAttrList->getNameByIndex( i ); | |
| //const ::rtl::OUString& rValue = _rxAttrList->getValueByIndex( i ); | |
| ::rtl::OUString aLocalName; | |
| sal_uInt16 nPrefix = | |
| rMap.GetKeyByAttrName( rAttrName, | |
| &aLocalName ); | |
| if( XML_NAMESPACE_FORM == nPrefix ) | |
| { | |
| if( token::IsXMLToken( aLocalName, token::XML_PROPERTY_NAME ) ) | |
| aPropValue.Name = _rxAttrList->getValueByIndex( i ); | |
| } | |
| else if( XML_NAMESPACE_OFFICE == nPrefix ) | |
| { | |
| if( token::IsXMLToken( aLocalName, token::XML_VALUE_TYPE ) ) | |
| sType = _rxAttrList->getValueByIndex( i ); | |
| else if( token::IsXMLToken( aLocalName, | |
| token::XML_VALUE ) || | |
| token::IsXMLToken( aLocalName, | |
| token::XML_BOOLEAN_VALUE ) || | |
| token::IsXMLToken( aLocalName, | |
| token::XML_STRING_VALUE ) ) | |
| sValue = _rxAttrList->getValueByIndex( i ); | |
| } | |
| } | |
| // the name of the property | |
| OSL_ENSURE(aPropValue.Name.getLength(), "OSinglePropertyContext::StartElement: invalid property name!"); | |
| // needs to be translated into a ::com::sun::star::uno::Type | |
| aPropType = PropertyConversion::xmlTypeToUnoType( sType ); | |
| if( TypeClass_VOID == aPropType.getTypeClass() ) | |
| { | |
| aPropValue.Value = Any(); | |
| } | |
| else | |
| { | |
| aPropValue.Value = | |
| PropertyConversion::convertString(GetImport(), aPropType, | |
| sValue); | |
| } | |
| // now that we finally have our property value, add it to our parent object | |
| if( aPropValue.Name.getLength() ) | |
| m_xPropertyImporter->implPushBackGenericPropertyValue(aPropValue); | |
| } | |
| //===================================================================== | |
| //= OListPropertyContext | |
| //===================================================================== | |
| //--------------------------------------------------------------------- | |
| OListPropertyContext::OListPropertyContext( SvXMLImport& _rImport, sal_uInt16 _nPrefix, const ::rtl::OUString& _rName, | |
| const OPropertyImportRef& _rPropertyImporter ) | |
| :SvXMLImportContext( _rImport, _nPrefix, _rName ) | |
| ,m_xPropertyImporter( _rPropertyImporter ) | |
| { | |
| } | |
| //--------------------------------------------------------------------- | |
| void OListPropertyContext::StartElement( const Reference< sax::XAttributeList >& _rxAttrList ) | |
| { | |
| sal_Int32 nAttributeCount = _rxAttrList->getLength(); | |
| sal_uInt16 nNamespace; | |
| ::rtl::OUString sAttributeName; | |
| const SvXMLNamespaceMap& rMap = GetImport().GetNamespaceMap(); | |
| for ( sal_Int16 i = 0; i < nAttributeCount; ++i ) | |
| { | |
| nNamespace = rMap.GetKeyByAttrName( _rxAttrList->getNameByIndex( i ), &sAttributeName ); | |
| if ( ( XML_NAMESPACE_FORM == nNamespace ) | |
| && ( token::IsXMLToken( sAttributeName, token::XML_PROPERTY_NAME ) ) | |
| ) | |
| { | |
| m_sPropertyName = _rxAttrList->getValueByIndex( i ); | |
| } | |
| else if ( ( XML_NAMESPACE_OFFICE == nNamespace ) | |
| && ( token::IsXMLToken( sAttributeName, token::XML_VALUE_TYPE ) ) | |
| ) | |
| { | |
| m_sPropertyType = _rxAttrList->getValueByIndex( i ); | |
| } | |
| else | |
| { | |
| OSL_ENSURE( false, | |
| ::rtl::OString( "OListPropertyContext::StartElement: unknown child element (\"") | |
| += ::rtl::OString( sAttributeName.getStr(), sAttributeName.getLength(), RTL_TEXTENCODING_ASCII_US ) | |
| += ::rtl::OString( "\")!" ) ); | |
| } | |
| } | |
| } | |
| //--------------------------------------------------------------------- | |
| void OListPropertyContext::EndElement() | |
| { | |
| OSL_ENSURE( m_sPropertyName.getLength() && m_sPropertyType.getLength(), | |
| "OListPropertyContext::EndElement: no property name or type!" ); | |
| if ( !m_sPropertyName.getLength() || !m_sPropertyType.getLength() ) | |
| return; | |
| Sequence< Any > aListElements( m_aListValues.size() ); | |
| Any* pListElement = aListElements.getArray(); | |
| com::sun::star::uno::Type aType = PropertyConversion::xmlTypeToUnoType( m_sPropertyType ); | |
| for ( ::std::vector< ::rtl::OUString >::const_iterator values = m_aListValues.begin(); | |
| values != m_aListValues.end(); | |
| ++values, ++pListElement | |
| ) | |
| { | |
| *pListElement = PropertyConversion::convertString( GetImport(), aType, *values ); | |
| } | |
| PropertyValue aSequenceValue; | |
| aSequenceValue.Name = m_sPropertyName; | |
| aSequenceValue.Value <<= aListElements; | |
| m_xPropertyImporter->implPushBackGenericPropertyValue( aSequenceValue ); | |
| } | |
| //--------------------------------------------------------------------- | |
| SvXMLImportContext* OListPropertyContext::CreateChildContext( sal_uInt16 _nPrefix, const ::rtl::OUString& _rLocalName, const Reference< sax::XAttributeList >& /*_rxAttrList*/ ) | |
| { | |
| if ( token::IsXMLToken( _rLocalName, token::XML_LIST_VALUE ) ) | |
| { | |
| m_aListValues.resize( m_aListValues.size() + 1 ); | |
| return new OListValueContext( GetImport(), _nPrefix, _rLocalName, *m_aListValues.rbegin() ); | |
| } | |
| else | |
| { | |
| OSL_ENSURE( sal_False, | |
| ::rtl::OString("OListPropertyContext::CreateChildContext: unknown child element (\"") | |
| += ::rtl::OString(_rLocalName.getStr(), _rLocalName.getLength(), RTL_TEXTENCODING_ASCII_US) | |
| += ::rtl::OString("\")!")); | |
| return new SvXMLImportContext( GetImport(), _nPrefix, _rLocalName ); | |
| } | |
| } | |
| //===================================================================== | |
| //= OListValueContext | |
| //===================================================================== | |
| //--------------------------------------------------------------------- | |
| OListValueContext::OListValueContext( SvXMLImport& _rImport, sal_uInt16 _nPrefix, const ::rtl::OUString& _rName, ::rtl::OUString& _rListValueHolder ) | |
| :SvXMLImportContext( _rImport, _nPrefix, _rName ) | |
| ,m_rListValueHolder( _rListValueHolder ) | |
| { | |
| } | |
| //--------------------------------------------------------------------- | |
| void OListValueContext::StartElement( const Reference< sax::XAttributeList >& _rxAttrList ) | |
| { | |
| const sal_Int32 nAttributeCount = _rxAttrList->getLength(); | |
| sal_uInt16 nNamespace; | |
| ::rtl::OUString sAttributeName; | |
| const SvXMLNamespaceMap& rMap = GetImport().GetNamespaceMap(); | |
| for ( sal_Int16 i = 0; i < nAttributeCount; ++i ) | |
| { | |
| nNamespace = rMap.GetKeyByAttrName( _rxAttrList->getNameByIndex( i ), &sAttributeName ); | |
| if ( XML_NAMESPACE_OFFICE == nNamespace ) | |
| { | |
| if ( token::IsXMLToken( sAttributeName, token::XML_VALUE ) | |
| || token::IsXMLToken( sAttributeName, token::XML_STRING_VALUE ) | |
| || token::IsXMLToken( sAttributeName, token::XML_BOOLEAN_VALUE ) | |
| ) | |
| { | |
| m_rListValueHolder = _rxAttrList->getValueByIndex( i ); | |
| continue; | |
| } | |
| } | |
| OSL_ENSURE( false, | |
| ::rtl::OString( "OListValueContext::StartElement: unknown child element (\"") | |
| += ::rtl::OString( sAttributeName.getStr(), sAttributeName.getLength(), RTL_TEXTENCODING_ASCII_US ) | |
| += ::rtl::OString( "\")!" ) ); | |
| } | |
| } | |
| //......................................................................... | |
| } // namespace xmloff | |
| //......................................................................... |