koheidatapilot03: merge with DEV300_m60

author: Jens-Heiner Rechtien <hr@openoffice.org> 2010-01-28 19:15:06 +0000
committer: Jens-Heiner Rechtien <hr@openoffice.org> 2010-01-28 19:15:06 +0000
commit: 119da1585819ab945cf07866c0185b7e63d691fa (patch)
tree: a8d7eecb5fa04157b0764b336d621860a9cafbe5 /xmloff/source
parent: 04b74d9eadff586cab293db3cd473108ca1d5827 (diff)
parent: ab33e14647ada2a32624fa39ec0ddbbbdc694df5 (diff)
26 files changed, 802 insertions, 309 deletions
diff --git a/xmloff/source/chart/SchXMLChartContext.cxx b/xmloff/source/chart/SchXMLChartContext.cxx
index d103876b9350..1f854469b4be 100644
--- a/xmloff/source/chart/SchXMLChartContext.cxx
+++ b/xmloff/source/chart/SchXMLChartContext.cxx
@@ -318,7 +318,12 @@ void SchXMLChartContext::StartElement( const uno::Reference< xml::sax::XAttribut
     // parse attributes
     sal_Int16 nAttrCount = xAttrList.is()? xAttrList->getLength(): 0;
     const SvXMLTokenMap& rAttrTokenMap = mrImportHelper.GetChartAttrTokenMap();
-    awt::Size aChartSize;
+
+    uno::Reference< embed::XVisualObject > xVisualObject( mrImportHelper.GetChartDocument(), uno::UNO_QUERY);
+    DBG_ASSERT(xVisualObject.is(),"need xVisualObject for page size");
+    if( xVisualObject.is() )
+        maChartSize = xVisualObject->getVisualAreaSize( embed::Aspects::MSOLE_CONTENT ); //#i103460# take the size given from the parent frame as default
+
     // this flag is necessarry for pie charts in the core
     sal_Bool bSetSwitchData = sal_False;
 
@@ -377,11 +382,11 @@ void SchXMLChartContext::StartElement( const uno::Reference< xml::sax::XAttribut
                 break;
 
             case XML_TOK_CHART_WIDTH:
-                GetImport().GetMM100UnitConverter().convertMeasure( aChartSize.Width, aValue );
+                GetImport().GetMM100UnitConverter().convertMeasure( maChartSize.Width, aValue );
                 break;
 
             case XML_TOK_CHART_HEIGHT:
-                GetImport().GetMM100UnitConverter().convertMeasure( aChartSize.Height, aValue );
+                GetImport().GetMM100UnitConverter().convertMeasure( maChartSize.Height, aValue );
                 break;
 
             case XML_TOK_CHART_STYLE_NAME:
@@ -406,7 +411,11 @@ void SchXMLChartContext::StartElement( const uno::Reference< xml::sax::XAttribut
         maChartTypeServiceName = SchXMLTools::GetChartTypeByClassName( aChartClass_Bar, false /* bUseOldNames */ );
     }
 
-    InitChart (aChartSize, aOldChartTypeName, bSetSwitchData);
+    //  Set the size of the draw page.
+    if( xVisualObject.is() )
+        xVisualObject->setVisualAreaSize( embed::Aspects::MSOLE_CONTENT, maChartSize );
+
+    InitChart( aOldChartTypeName, bSetSwitchData);
 
     if( bHasAddin )
     {
@@ -1198,11 +1207,9 @@ SvXMLImportContext* SchXMLChartContext::CreateChildContext(
         4.  Set the chart type.
 */
 void SchXMLChartContext::InitChart(
-    awt::Size aChartSize,
     const OUString & rChartTypeServiceName, // currently the old service name
     sal_Bool /* bSetSwitchData */ )
 {
-    maChartSize = aChartSize;
     uno::Reference< chart::XChartDocument > xDoc = mrImportHelper.GetChartDocument();
     DBG_ASSERT( xDoc.is(), "No valid document!" );
     uno::Reference< frame::XModel > xModel (xDoc, uno::UNO_QUERY );
@@ -1217,12 +1224,6 @@ void SchXMLChartContext::InitChart(
             xTitled->setTitleObject( 0 );
     }
 
-    //  Set the size of the draw page.
-    uno::Reference< embed::XVisualObject > xVisualObject(xModel,uno::UNO_QUERY);
-    DBG_ASSERT(xVisualObject.is(),"need xVisualObject for page size");
-    if( xVisualObject.is() )
-        xVisualObject->setVisualAreaSize( embed::Aspects::MSOLE_CONTENT, aChartSize );
-
     //  Set the chart type via setting the diagram.
     if( rChartTypeServiceName.getLength() &&
         xDoc.is())
diff --git a/xmloff/source/chart/SchXMLChartContext.hxx b/xmloff/source/chart/SchXMLChartContext.hxx
index c02f623ebe10..e14f09f965ca 100644
--- a/xmloff/source/chart/SchXMLChartContext.hxx
+++ b/xmloff/source/chart/SchXMLChartContext.hxx
@@ -138,15 +138,12 @@ private:
     ::com::sun::star::awt::Size maChartSize;
 
     /** @descr  This method bundles some settings to the chart model and executes them with
-            a locked controller.  This includes setting the draw page size and setting
-            the chart type.
-        @param  aChartSize  The size the draw page will be set to.
+            a locked controller.  This includes setting the chart type.
         @param  aServiceName The name of the service the diagram is initialized with.
         @param  bSetWitchData   Indicates wether the data set takes it's data series from
             rows or from columns.
     */
-    void    InitChart   (com::sun::star::awt::Size aChartSize,
-                        const ::rtl::OUString & rChartTypeServiceName,
+    void    InitChart   (const ::rtl::OUString & rChartTypeServiceName,
                         sal_Bool bSetSwitchData);
 
     void MergeSeriesForStockChart();
diff --git a/xmloff/source/chart/SchXMLExport.cxx b/xmloff/source/chart/SchXMLExport.cxx
index 3290cb31db96..f7cf82abe974 100644
--- a/xmloff/source/chart/SchXMLExport.cxx
+++ b/xmloff/source/chart/SchXMLExport.cxx
@@ -93,6 +93,7 @@
 #include <com/sun/star/chart2/data/XDataSink.hpp>
 #include <com/sun/star/chart2/data/XDataReceiver.hpp>
 #include <com/sun/star/chart2/data/XDataProvider.hpp>
+#include <com/sun/star/chart2/data/XDatabaseDataProvider.hpp>
 #include <com/sun/star/chart2/data/XRangeXMLConversion.hpp>
 #include <com/sun/star/chart2/data/XTextualDataSequence.hpp>
 #include <com/sun/star/chart2/data/XNumericalDataSequence.hpp>
@@ -1123,6 +1124,12 @@ void SchXMLExportHelper::parseDocument( Reference< chart::XChartDocument >& rCha
             OUString aDataProviderURL( RTL_CONSTASCII_USTRINGPARAM( ".." ) );
             if( xNewDoc->hasInternalDataProvider() )
                 aDataProviderURL = OUString( RTL_CONSTASCII_USTRINGPARAM( "." ) );
+            else //special handling for data base data provider necessary
+            {
+                Reference< chart2::data::XDatabaseDataProvider > xDBDataProvider( xNewDoc->getDataProvider(), uno::UNO_QUERY );
+                if( xDBDataProvider.is() )
+                    aDataProviderURL = OUString( RTL_CONSTASCII_USTRINGPARAM( "." ) );
+            }
             mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_HREF, aDataProviderURL );
         }
 
diff --git a/xmloff/source/chart/SchXMLTools.cxx b/xmloff/source/chart/SchXMLTools.cxx
index a1700c65d316..ebc48c0d24c0 100644
--- a/xmloff/source/chart/SchXMLTools.cxx
+++ b/xmloff/source/chart/SchXMLTools.cxx
@@ -173,6 +173,7 @@ static __FAR_DATA SvXMLEnumMapEntry aXMLChartClassMap[] =
     { XML_BAR,          XML_CHART_CLASS_BAR     },
     { XML_STOCK,        XML_CHART_CLASS_STOCK   },
     { XML_BUBBLE,       XML_CHART_CLASS_BUBBLE  },
+    { XML_SURFACE,      XML_CHART_CLASS_BAR     }, //@todo change this if a surface chart is available
     { XML_ADD_IN,       XML_CHART_CLASS_ADDIN   },
     { XML_TOKEN_INVALID, XML_CHART_CLASS_UNKNOWN }
 };
@@ -293,6 +294,14 @@ OUString GetChartTypeByClassName(
         else
             aResultBuffer.appendAscii( RTL_CONSTASCII_STRINGPARAM("CandleStick"));
     }
+    else if( IsXMLToken( rClassName, XML_SURFACE ))
+    {
+        //@todo change this if a surface chart is available
+        if( bUseOldNames )
+            aResultBuffer.appendAscii( RTL_CONSTASCII_STRINGPARAM("Bar"));
+        else
+            aResultBuffer.appendAscii( RTL_CONSTASCII_STRINGPARAM("Column"));
+    }
     else
         bInternalType = false;
 
diff --git a/xmloff/source/core/xmlexp.cxx b/xmloff/source/core/xmlexp.cxx
index 8045cd582e2f..55af99802f9d 100644
--- a/xmloff/source/core/xmlexp.cxx
+++ b/xmloff/source/core/xmlexp.cxx
@@ -1358,6 +1358,7 @@ sal_uInt32 SvXMLExport::exportDoc( enum ::xmloff::token::XMLTokenEnum eClass )
         const sal_Char* pVersion = 0;
         switch( getDefaultVersion() )
         {
+        case SvtSaveOptions::ODFVER_LATEST: pVersion = sXML_1_2; break;
         case SvtSaveOptions::ODFVER_012: pVersion = sXML_1_2; break;
         case SvtSaveOptions::ODFVER_011: pVersion = sXML_1_1; break;
         case SvtSaveOptions::ODFVER_010: break;
diff --git a/xmloff/source/core/xmlimp.cxx b/xmloff/source/core/xmlimp.cxx
index 28c970a94066..d4dc48ede241 100644
--- a/xmloff/source/core/xmlimp.cxx
+++ b/xmloff/source/core/xmlimp.cxx
@@ -58,13 +58,17 @@
 #include <com/sun/star/lang/ServiceNotRegisteredException.hpp>
 #include <com/sun/star/io/XOutputStream.hpp>
 #include <com/sun/star/document/XBinaryStreamResolver.hpp>
+#include <com/sun/star/document/XStorageBasedDocument.hpp>
 #include <com/sun/star/xml/sax/XLocator.hpp>
+#include <com/sun/star/packages/zip/ZipIOException.hpp>
 #include <comphelper/namecontainer.hxx>
 #include <rtl/logfile.hxx>
 #include <tools/string.hxx> // used in StartElement for logging
 #include <cppuhelper/implbase1.hxx>
 #include <comphelper/extract.hxx>
 #include <comphelper/processfactory.hxx>
+#include <comphelper/documentconstants.hxx>
+#include <comphelper/storagehelper.hxx>
 #include <vcl/fontcvt.hxx>
 
 #include <com/sun/star/rdf/XMetadatable.hpp>
@@ -89,6 +93,7 @@ using namespace ::com::sun::star::document;
 using namespace ::xmloff::token;
 
 sal_Char __READONLY_DATA sXML_np__office[] = "_office";
+sal_Char __READONLY_DATA sXML_np__office_ext[] = "_office_ooo";
 sal_Char __READONLY_DATA sXML_np__ooo[] = "_ooo";
 sal_Char __READONLY_DATA sXML_np__ooow[] = "_ooow";
 sal_Char __READONLY_DATA sXML_np__oooc[] = "_oooc";
@@ -241,6 +246,9 @@ void SvXMLImport::_InitCtor()
         mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__office ) ),
                             GetXMLToken(XML_N_OFFICE),
                             XML_NAMESPACE_OFFICE );
+        mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__office_ext ) ),
+                            GetXMLToken(XML_N_OFFICE_EXT),
+                            XML_NAMESPACE_OFFICE_EXT );
         mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__ooo ) ), GetXMLToken(XML_N_OOO), XML_NAMESPACE_OOO );
         mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__style) ),
                             GetXMLToken(XML_N_STYLE),
@@ -649,6 +657,21 @@ void SAL_CALL SvXMLImport::startElement( const OUString& rName,
         if ( rAttrName.equalsAscii("office:version") )
         {
             mpImpl->aODFVersion = xAttrList->getValueByIndex( i );
+
+            // the ODF version in content.xml and manifest.xml must be the same starting from ODF1.2
+            if ( mpImpl->mStreamName.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "content.xml" ) ) )
+              && !IsODFVersionConsistent( mpImpl->aODFVersion ) )
+            {
+                throw xml::sax::SAXException(
+                        ::rtl::OUString(
+                            RTL_CONSTASCII_USTRINGPARAM( "Inconsistent ODF versions in content.xml and manifest.xml!" ) ),
+                        uno::Reference< uno::XInterface >(),
+                        uno::makeAny(
+                            packages::zip::ZipIOException(
+                                ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
+                                    "Inconsistent ODF versions in content.xml and manifest.xml!" ) ),
+                                Reference< XInterface >() ) ) );
+            }
         }
         else if( ( rAttrName.getLength() >= 5 ) &&
             ( rAttrName.compareToAscii( sXML_xmlns, 5 ) == 0 ) &&
@@ -1598,6 +1621,50 @@ OUString SvXMLImport::GetAbsoluteReference(const OUString& rValue) const
         return rValue;
 }
 
+sal_Bool SvXMLImport::IsODFVersionConsistent( const ::rtl::OUString& aODFVersion )
+{
+    // the check returns sal_False only if the storage version could be retrieved
+    sal_Bool bResult = sal_True;
+
+    if ( aODFVersion.getLength() && aODFVersion.compareTo( ODFVER_012_TEXT ) >= 0 )
+    {
+        // check the consistency only for the ODF1.2 and later ( according to content.xml )
+        try
+        {
+            uno::Reference< document::XStorageBasedDocument > xDoc( mxModel, uno::UNO_QUERY_THROW );
+            uno::Reference< embed::XStorage > xStor = xDoc->getDocumentStorage();
+            uno::Reference< beans::XPropertySet > xStorProps( xStor, uno::UNO_QUERY_THROW );
+
+            // the check should be done only for OASIS format
+            ::rtl::OUString aMediaType;
+            xStorProps->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "MediaType" ) ) ) >>= aMediaType;
+            if ( ::comphelper::OStorageHelper::GetXStorageFormat( xStor ) >= SOFFICE_FILEFORMAT_8 )
+            {
+                sal_Bool bRepairPackage = sal_False;
+                try
+                {
+                    xStorProps->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "RepairPackage" ) ) )
+                        >>= bRepairPackage;
+                } catch ( uno::Exception& )
+                {}
+
+                // check only if not in Repair mode
+                if ( !bRepairPackage )
+                {
+                    ::rtl::OUString aStorVersion;
+                    xStorProps->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Version" ) ) )
+                        >>= aStorVersion;
+                    bResult = aODFVersion.equals( aStorVersion );
+                }
+            }
+        }
+        catch( uno::Exception& )
+        {}
+    }
+
+    return bResult;
+}
+
 void SvXMLImport::_CreateNumberFormatsSupplier()
 {
     DBG_ASSERT( !mxNumberFormatsSupplier.is(),
@@ -1894,6 +1961,7 @@ void SvXMLImport::SetXmlId(uno::Reference<uno::XInterface> const & i_xIfc,
                 }
             }
         } catch (uno::Exception &) {
+            OSL_ENSURE(false, "SvXMLImport::SetXmlId: exception?");
         }
     }
 }
diff --git a/xmloff/source/core/xmltoken.cxx b/xmloff/source/core/xmltoken.cxx
index 937d3c64d3a1..61c95a9dac9f 100644
--- a/xmloff/source/core/xmltoken.cxx
+++ b/xmloff/source/core/xmltoken.cxx
@@ -152,6 +152,10 @@ namespace xmloff { namespace token {
         TOKEN( "grddl",                                 XML_NP_GRDDL ),
         TOKEN( "http://www.w3.org/2003/g/data-view#",   XML_N_GRDDL ),
 
+        // ODF Enhanced namespaces
+        TOKEN( "officeooo", XML_NP_OFFICE_EXT ),
+        TOKEN( "http://openoffice.org/2009/office", XML_N_OFFICE_EXT ),
+
         // units
         TOKEN( "mm",                              XML_UNIT_MM ),
         TOKEN( "m",                               XML_UNIT_M ),
@@ -3078,6 +3082,7 @@ namespace xmloff { namespace token {
         TOKEN( "at-axis",               XML_AT_AXIS ),
         TOKEN( "at-labels-and-axis",    XML_AT_LABELS_AND_AXIS ),
         TOKEN( "filled-radar",                    XML_FILLED_RADAR ),
+        TOKEN( "surface",               XML_SURFACE ),
 
         TOKEN( "mathvariant",           XML_MATHVARIANT ),
         TOKEN( "mathsize",              XML_MATHSIZE ),
diff --git a/xmloff/source/draw/sdxmlexp.cxx b/xmloff/source/draw/sdxmlexp.cxx
index 67c66b6a1d5f..1d7414d4ca23 100644
--- a/xmloff/source/draw/sdxmlexp.cxx
+++ b/xmloff/source/draw/sdxmlexp.cxx
@@ -39,7 +39,9 @@
 #include <com/sun/star/lang/ServiceNotRegisteredException.hpp>
 #include <com/sun/star/presentation/XPresentationSupplier.hpp>
 #include <com/sun/star/presentation/XCustomPresentationSupplier.hpp>
+#include <com/sun/star/geometry/RealPoint2D.hpp>
 #include <com/sun/star/task/XStatusIndicatorSupplier.hpp>
+#include <com/sun/star/office/XAnnotationAccess.hpp>
 #include <com/sun/star/lang/Locale.hpp>
 #include <com/sun/star/uno/Any.hxx>
 #include "sdxmlexp_impl.hxx"
@@ -51,9 +53,7 @@
 #include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
 #include <com/sun/star/style/XStyle.hpp>
 
-#ifndef _COM_SUN_STAR_FORM_XFORMSUPPLIER2_HPP_
 #include <com/sun/star/form/XFormsSupplier2.hpp>
-#endif
 #include <com/sun/star/presentation/XPresentationPage.hpp>
 #include <com/sun/star/drawing/XMasterPageTarget.hpp>
 #include <com/sun/star/text/XText.hpp>
@@ -96,9 +96,13 @@ using ::rtl::OUStringBuffer;
 using namespace ::com::sun::star;
 using namespace ::com::sun::star::uno;
 using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::util;
 using namespace ::com::sun::star::container;
 using namespace ::com::sun::star::drawing;
+using namespace ::com::sun::star::office;
 using namespace ::com::sun::star::presentation;
+using namespace ::com::sun::star::geometry;
+using namespace ::com::sun::star::text;
 using namespace ::xmloff::token;
 
 
@@ -640,6 +644,14 @@ void SAL_CALL SdXMLExport::setSourceDocument( const Reference< lang::XComponent
         GetXMLToken(XML_N_ANIMATION),
         XML_NAMESPACE_ANIMATION);
 
+    if( getDefaultVersion() == SvtSaveOptions::ODFVER_LATEST )
+    {
+        _GetNamespaceMap().Add(
+            GetXMLToken(XML_NP_OFFICE_EXT),
+            GetXMLToken(XML_N_OFFICE_EXT),
+            XML_NAMESPACE_OFFICE_EXT);
+    }
+
     GetShapeExport()->enableLayerExport();
 
     // #88546# enable progress bar increments
@@ -2060,6 +2072,8 @@ void SdXMLExport::_ExportContent()
                     }
                 }
             }
+
+            exportAnnotations( xDrawPage );
         }
     }
 
@@ -2355,10 +2369,9 @@ void SdXMLExport::_ExportAutoStyles()
         // create auto style infos for objects on master pages
         for(sal_Int32 nMPageId(0L); nMPageId < mnDocMasterPageCount; nMPageId++)
         {
-            Any aAny(mxDocMasterPages->getByIndex(nMPageId));
-            Reference< XDrawPage > xMasterPage;
+            Reference< XDrawPage > xMasterPage(mxDocMasterPages->getByIndex(nMPageId), UNO_QUERY );
 
-            if((aAny >>= xMasterPage) && xMasterPage.is() )
+            if( xMasterPage.is() )
             {
                 // collect layer information
                 GetFormExport()->examineForms( xMasterPage );
@@ -2397,6 +2410,7 @@ void SdXMLExport::_ExportAutoStyles()
                         }
                     }
                 }
+                collectAnnotationAutoStyles(xMasterPage);
             }
         }
     }
@@ -2413,10 +2427,8 @@ void SdXMLExport::_ExportAutoStyles()
         // create auto style infos for objects on pages
         for(sal_Int32 nPageInd(0); nPageInd < mnDocDrawPageCount; nPageInd++)
         {
-            Any aAny(mxDocDrawPages->getByIndex(nPageInd));
-            Reference<XDrawPage> xDrawPage;
-
-            if((aAny >>= xDrawPage) && xDrawPage.is() )
+            Reference<XDrawPage> xDrawPage( mxDocDrawPages->getByIndex(nPageInd), UNO_QUERY );
+            if( xDrawPage.is() )
             {
                 // collect layer information
                 GetFormExport()->examineForms( xDrawPage );
@@ -2466,6 +2478,8 @@ void SdXMLExport::_ExportAutoStyles()
                         }
                     }
                 }
+
+                collectAnnotationAutoStyles( xDrawPage );
             }
         }
         if(IsImpress())
@@ -2536,10 +2550,8 @@ void SdXMLExport::_ExportMasterStyles()
     // export MasterPages in master-styles section
     for(sal_Int32 nMPageId = 0L; nMPageId < mnDocMasterPageCount; nMPageId++)
     {
-        Any aAny(mxDocMasterPages->getByIndex(nMPageId));
-        Reference< XDrawPage > xMasterPage;
-
-        if((aAny >>= xMasterPage) && xMasterPage.is())
+        Reference< XDrawPage > xMasterPage( mxDocMasterPages->getByIndex(nMPageId), UNO_QUERY );
+        if(xMasterPage.is())
         {
             // prepare masterpage attributes
             OUString sMasterPageName;
@@ -2610,6 +2622,7 @@ void SdXMLExport::_ExportMasterStyles()
                     }
                 }
             }
+            exportAnnotations( xMasterPage );
         }
     }
 }
@@ -2770,6 +2783,98 @@ OUString SdXMLExport::getNavigationOrder( const Reference< XDrawPage >& xDrawPag
 
 //////////////////////////////////////////////////////////////////////////////
 
+void SdXMLExport::collectAnnotationAutoStyles( const Reference<XDrawPage>& xDrawPage )
+{
+    Reference< XAnnotationAccess > xAnnotationAccess( xDrawPage, UNO_QUERY );
+    if( xAnnotationAccess.is() ) try
+    {
+        Reference< XAnnotationEnumeration > xAnnotationEnumeration( xAnnotationAccess->createAnnotationEnumeration() );
+        if( xAnnotationEnumeration.is() )
+        {
+            while( xAnnotationEnumeration->hasMoreElements() )
+            {
+                Reference< XAnnotation > xAnnotation( xAnnotationEnumeration->nextElement(), UNO_QUERY_THROW );
+                Reference< XText > xText( xAnnotation->getTextRange() );
+                if(xText.is() && xText->getString().getLength())
+                    GetTextParagraphExport()->collectTextAutoStyles( xText );
+            }
+        }
+    }
+    catch( Exception& )
+    {
+        DBG_ERROR("SdXMLExport::collectAnnotationAutoStyles(), exception caught during export of annotation auto styles");
+    }
+}
+
+void SdXMLExport::exportAnnotations( const Reference<XDrawPage>& xDrawPage )
+{
+    // do not export in ODF 1.2 or older
+    if( getDefaultVersion() != SvtSaveOptions::ODFVER_LATEST )
+        return;
+
+    Reference< XAnnotationAccess > xAnnotationAccess( xDrawPage, UNO_QUERY );
+    if( xAnnotationAccess.is() ) try
+    {
+        Reference< XAnnotationEnumeration > xAnnotationEnumeration( xAnnotationAccess->createAnnotationEnumeration() );
+        if( xAnnotationEnumeration.is() && xAnnotationEnumeration->hasMoreElements() )
+        {
+            OUStringBuffer sStringBuffer;
+            do
+            {
+                Reference< XAnnotation > xAnnotation( xAnnotationEnumeration->nextElement(), UNO_QUERY_THROW );
+
+                RealPoint2D aPosition( xAnnotation->getPosition() );
+
+                   GetMM100UnitConverter().convertMeasure(sStringBuffer, static_cast<sal_Int32>( aPosition.X * 100 ) );
+                AddAttribute(XML_NAMESPACE_SVG, XML_X, sStringBuffer.makeStringAndClear());
+
+                   GetMM100UnitConverter().convertMeasure(sStringBuffer, static_cast<sal_Int32>( aPosition.Y * 100 ) );
+                AddAttribute(XML_NAMESPACE_SVG, XML_Y, sStringBuffer.makeStringAndClear());
+
+                RealSize2D aSize( xAnnotation->getSize() );
+
+                if( aSize.Width || aSize.Height )
+                {
+                       GetMM100UnitConverter().convertMeasure(sStringBuffer, static_cast<sal_Int32>( aSize.Width * 100 ) );
+                    AddAttribute(XML_NAMESPACE_SVG, XML_WIDTH, sStringBuffer.makeStringAndClear());
+                       GetMM100UnitConverter().convertMeasure(sStringBuffer, static_cast<sal_Int32>( aSize.Height * 100 ) );
+                    AddAttribute(XML_NAMESPACE_SVG, XML_HEIGHT, sStringBuffer.makeStringAndClear());
+                }
+
+                // annotation element + content
+                SvXMLElementExport aElem(*this, XML_NAMESPACE_OFFICE_EXT, XML_ANNOTATION, sal_False, sal_True);
+
+                // author
+                OUString aAuthor( xAnnotation->getAuthor() );
+                if( aAuthor.getLength() )
+                {
+                    SvXMLElementExport aCreatorElem( *this, XML_NAMESPACE_DC, XML_CREATOR, sal_True, sal_False );
+                    this->Characters(aAuthor);
+                }
+
+                {
+                    // date time
+                    DateTime aDate( xAnnotation->getDateTime() );
+                    GetMM100UnitConverter().convertDateTime(sStringBuffer, aDate, sal_True);
+                    SvXMLElementExport aDateElem( *this, XML_NAMESPACE_DC, XML_DATE, sal_True, sal_False );
+                    Characters(sStringBuffer.makeStringAndClear());
+                }
+
+                com::sun::star::uno::Reference < com::sun::star::text::XText > xText( xAnnotation->getTextRange() );
+                if( xText.is() )
+                    this->GetTextParagraphExport()->exportText( xText );
+            }
+            while( xAnnotationEnumeration->hasMoreElements() );
+        }
+    }
+    catch( Exception& )
+    {
+        DBG_ERROR("SdXMLExport::exportAnnotations(), exception caught during export of annotations");
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
 #define SERVICE( classname, servicename, implementationname, draw, flags )\
 uno::Sequence< OUString > SAL_CALL classname##_getSupportedServiceNames() throw()\
 {\
diff --git a/xmloff/source/draw/sdxmlexp_impl.hxx b/xmloff/source/draw/sdxmlexp_impl.hxx
index eaf5c7c531f2..2738e948ea69 100644
--- a/xmloff/source/draw/sdxmlexp_impl.hxx
+++ b/xmloff/source/draw/sdxmlexp_impl.hxx
@@ -186,6 +186,9 @@ class SdXMLExport : public SvXMLExport
 
     rtl::OUString getNavigationOrder( const ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XDrawPage >& xDrawPage );
 
+    void collectAnnotationAutoStyles( const ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XDrawPage >& xDrawPage );
+    void exportAnnotations( const ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XDrawPage >& xDrawPage );
+
 protected:
     virtual void GetViewSettings(com::sun::star::uno::Sequence<com::sun::star::beans::PropertyValue>& aProps);
     virtual void GetConfigurationSettings(com::sun::star::uno::Sequence<com::sun::star::beans::PropertyValue>& aProps);
diff --git a/xmloff/source/draw/ximppage.cxx b/xmloff/source/draw/ximppage.cxx
index 4daa6263d391..9d64d49f9421 100644
--- a/xmloff/source/draw/ximppage.cxx
+++ b/xmloff/source/draw/ximppage.cxx
@@ -32,6 +32,9 @@
 #include "precompiled_xmloff.hxx"
 #include <tools/debug.hxx>
 
+#include <com/sun/star/geometry/RealPoint2D.hpp>
+#include <com/sun/star/text/XTextCursor.hpp>
+#include <com/sun/star/util/DateTime.hpp>
 #include <cppuhelper/implbase1.hxx>
 #include "XMLNumberStylesImport.hxx"
 #include <xmloff/xmlstyle.hxx>
@@ -41,6 +44,7 @@
 #include "ximppage.hxx"
 #include "ximpshap.hxx"
 #include "animimp.hxx"
+#include "XMLStringBufferImportContext.hxx"
 #include <xmloff/formsimp.hxx>
 #include <xmloff/xmlictxt.hxx>
 #include "ximpstyl.hxx"
@@ -57,9 +61,155 @@ using namespace ::com::sun::star;
 using namespace ::xmloff::token;
 using namespace ::com::sun::star::uno;
 using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::text;
+using namespace ::com::sun::star::util;
 using namespace ::com::sun::star::beans;
 using namespace ::com::sun::star::drawing;
 using namespace ::com::sun::star::container;
+using namespace ::com::sun::star::office;
+using namespace ::com::sun::star::xml::sax;
+using namespace ::com::sun::star::geometry;
+
+
+//////////////////////////////////////////////////////////////////////////////
+
+class DrawAnnotationContext : public SvXMLImportContext
+{
+
+public:
+    DrawAnnotationContext( SvXMLImport& rImport, USHORT nPrfx, const OUString& rLocalName,const Reference< xml::sax::XAttributeList>& xAttrList, const Reference< XAnnotationAccess >& xAnnotationAccess );
+
+    virtual SvXMLImportContext * CreateChildContext( USHORT nPrefix, const ::rtl::OUString& rLocalName, const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList );
+    virtual void EndElement();
+
+private:
+    Reference< XAnnotation > mxAnnotation;
+    Reference< XTextCursor > mxCursor;
+
+    OUStringBuffer maAuthorBuffer;
+    OUStringBuffer maDateBuffer;
+};
+
+DrawAnnotationContext::DrawAnnotationContext( SvXMLImport& rImport, USHORT nPrfx, const OUString& rLocalName,const Reference< xml::sax::XAttributeList>& xAttrList, const Reference< XAnnotationAccess >& xAnnotationAccess )
+: SvXMLImportContext( rImport, nPrfx, rLocalName )
+, mxAnnotation( xAnnotationAccess->createAndInsertAnnotation() )
+{
+    if( mxAnnotation.is() )
+    {
+        sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
+
+        RealPoint2D aPosition;
+        RealSize2D aSize;
+
+        for(sal_Int16 i=0; i < nAttrCount; i++)
+        {
+            OUString sValue( xAttrList->getValueByIndex( i ) );
+            OUString sAttrName( xAttrList->getNameByIndex( i ) );
+            OUString aLocalName;
+            switch( GetImport().GetNamespaceMap().GetKeyByAttrName( sAttrName, &aLocalName ) )
+            {
+            case XML_NAMESPACE_SVG:
+                if( IsXMLToken( aLocalName, XML_X ) )
+                {
+                    sal_Int32 x;
+                    GetImport().GetMM100UnitConverter().convertMeasure(x, sValue);
+                    aPosition.X = static_cast<double>(x) / 100.0;
+                }
+                else if( IsXMLToken( aLocalName, XML_Y ) )
+                {
+                    sal_Int32 y;
+                    GetImport().GetMM100UnitConverter().convertMeasure(y, sValue);
+                    aPosition.Y = static_cast<double>(y) / 100.0;
+                }
+                else if( IsXMLToken( aLocalName, XML_WIDTH ) )
+                {
+                    sal_Int32 w;
+                    GetImport().GetMM100UnitConverter().convertMeasure(w, sValue);
+                    aSize.Width = static_cast<double>(w) / 100.0;
+                }
+                else if( IsXMLToken( aLocalName, XML_HEIGHT ) )
+                {
+                    sal_Int32 h;
+                    GetImport().GetMM100UnitConverter().convertMeasure(h, sValue);
+                    aSize.Height = static_cast<double>(h) / 100.0;
+                }
+                break;
+            default:
+                break;
+            }
+        }
+
+        mxAnnotation->setPosition( aPosition );
+        mxAnnotation->setSize( aSize );
+    }
+}
+
+SvXMLImportContext * DrawAnnotationContext::CreateChildContext( USHORT nPrefix, const OUString& rLocalName, const Reference< XAttributeList >& xAttrList )
+{
+    SvXMLImportContext * pContext = NULL;
+
+    if( mxAnnotation.is() )
+    {
+        if( XML_NAMESPACE_DC == nPrefix )
+        {
+            if( IsXMLToken( rLocalName, XML_CREATOR ) )
+                pContext = new XMLStringBufferImportContext(GetImport(), nPrefix, rLocalName, maAuthorBuffer);
+            else if( IsXMLToken( rLocalName, XML_DATE ) )
+                pContext = new XMLStringBufferImportContext(GetImport(), nPrefix, rLocalName, maDateBuffer);
+        }
+        else
+        {
+            // create text cursor on demand
+            if( !mxCursor.is() )
+            {
+                uno::Reference< text::XText > xText( mxAnnotation->getTextRange() );
+                if( xText.is() )
+                {
+                    UniReference < XMLTextImportHelper > xTxtImport = GetImport().GetTextImport();
+                    mxCursor = xText->createTextCursor();
+                    if( mxCursor.is() )
+                        xTxtImport->SetCursor( mxCursor );
+                }
+            }
+
+            // if we have a text cursor, lets  try to import some text
+            if( mxCursor.is() )
+            {
+                pContext = GetImport().GetTextImport()->CreateTextChildContext( GetImport(), nPrefix, rLocalName, xAttrList );
+            }
+        }
+    }
+
+    // call parent for content
+    if(!pContext)
+        pContext = SvXMLImportContext::CreateChildContext( nPrefix, rLocalName, xAttrList );
+
+    return pContext;
+}
+
+void DrawAnnotationContext::EndElement()
+{
+    if(mxCursor.is())
+    {
+        // delete addition newline
+        const OUString aEmpty;
+        mxCursor->gotoEnd( sal_False );
+        mxCursor->goLeft( 1, sal_True );
+        mxCursor->setString( aEmpty );
+
+        // reset cursor
+        GetImport().GetTextImport()->ResetCursor();
+    }
+
+    if( mxAnnotation.is() )
+    {
+        mxAnnotation->setAuthor( maAuthorBuffer.makeStringAndClear() );
+
+        DateTime aDateTime;
+        if(SvXMLUnitConverter::convertDateTime(aDateTime,  maDateBuffer.makeStringAndClear()))
+            mxAnnotation->setDateTime(aDateTime);
+    }
+}
 
 //////////////////////////////////////////////////////////////////////////////
 
@@ -70,8 +220,9 @@ SdXMLGenericPageContext::SdXMLGenericPageContext(
     USHORT nPrfx, const OUString& rLocalName,
     const Reference< xml::sax::XAttributeList>& xAttrList,
     Reference< drawing::XShapes >& rShapes)
-:   SvXMLImportContext( rImport, nPrfx, rLocalName ),
-    mxShapes( rShapes )
+: SvXMLImportContext( rImport, nPrfx, rLocalName )
+, mxShapes( rShapes )
+, mxAnnotationAccess( rShapes, UNO_QUERY )
 {
     sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
 
@@ -100,10 +251,8 @@ void SdXMLGenericPageContext::StartElement( const Reference< ::com::sun::star::x
 {
     GetImport().GetShapeImport()->pushGroupForSorting( mxShapes );
 
-#ifndef SVX_LIGHT
     if( GetImport().IsFormsSupported() )
         GetImport().GetFormImport()->startPage( Reference< drawing::XDrawPage >::query( mxShapes ) );
-#endif
 }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -120,10 +269,13 @@ SvXMLImportContext* SdXMLGenericPageContext::CreateChildContext( USHORT nPrefix,
     }
     else if( nPrefix == XML_NAMESPACE_OFFICE && IsXMLToken( rLocalName, XML_FORMS ) )
     {
-#ifndef SVX_LIGHT
         if( GetImport().IsFormsSupported() )
             pContext = GetImport().GetFormImport()->createOfficeFormsContext( GetImport(), nPrefix, rLocalName );
-#endif
+    }
+    else if( ((nPrefix == XML_NAMESPACE_OFFICE) || (nPrefix == XML_NAMESPACE_OFFICE_EXT)) && IsXMLToken( rLocalName, XML_ANNOTATION ) )
+    {
+        if( mxAnnotationAccess.is() )
+            pContext = new DrawAnnotationContext( GetImport(), nPrefix, rLocalName, xAttrList, mxAnnotationAccess );
     }
     else
     {
diff --git a/xmloff/source/draw/ximppage.hxx b/xmloff/source/draw/ximppage.hxx
index fa32546b0810..45b505e2044f 100644
--- a/xmloff/source/draw/ximppage.hxx
+++ b/xmloff/source/draw/ximppage.hxx
@@ -35,6 +35,7 @@
 #include "sdxmlimp_impl.hxx"
 #include <xmloff/nmspmap.hxx>
 #include <com/sun/star/drawing/XShapes.hpp>
+#include <com/sun/star/office/XAnnotationAccess.hpp>
 #include <tools/rtti.hxx>
 #include "ximpshap.hxx"
 
@@ -44,7 +45,8 @@
 class SdXMLGenericPageContext : public SvXMLImportContext
 {
     // the shape group this group is working on
-    com::sun::star::uno::Reference< com::sun::star::drawing::XShapes > mxShapes;
+    ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XShapes > mxShapes;
+    ::com::sun::star::uno::Reference< ::com::sun::star::office::XAnnotationAccess > mxAnnotationAccess;
 
 protected:
     rtl::OUString               maPageLayoutName;
diff --git a/xmloff/source/meta/MetaExportComponent.cxx b/xmloff/source/meta/MetaExportComponent.cxx
index 0b65592c3613..996e75d0f740 100644
--- a/xmloff/source/meta/MetaExportComponent.cxx
+++ b/xmloff/source/meta/MetaExportComponent.cxx
@@ -170,6 +170,7 @@ sal_uInt32 XMLMetaExportComponent::exportDoc( enum XMLTokenEnum )
         const sal_Char* pVersion = 0;
         switch( getDefaultVersion() )
         {
+        case SvtSaveOptions::ODFVER_LATEST: pVersion = "1.2"; break;
         case SvtSaveOptions::ODFVER_012: pVersion = "1.2"; break;
         case SvtSaveOptions::ODFVER_011: pVersion = "1.1"; break;
         case SvtSaveOptions::ODFVER_010: break;
diff --git a/xmloff/source/style/GradientStyle.cxx b/xmloff/source/style/GradientStyle.cxx
index 0961175e28b8..fc3f199f9c50 100644
--- a/xmloff/source/style/GradientStyle.cxx
+++ b/xmloff/source/style/GradientStyle.cxx
@@ -201,7 +201,7 @@ sal_Bool XMLGradientStyleImport::importXML(
         case XML_TOK_GRADIENT_ANGLE:
             {
                 sal_Int32 nValue;
-                SvXMLUnitConverter::convertNumber( nValue, rStrValue, 0, 360 );
+                SvXMLUnitConverter::convertNumber( nValue, rStrValue, 0, 3600 );
                 aGradient.Angle = sal_Int16( nValue );
             }
             break;
diff --git a/xmloff/source/style/HatchStyle.cxx b/xmloff/source/style/HatchStyle.cxx
index ee8719c133f7..ac40a6ee4c10 100644
--- a/xmloff/source/style/HatchStyle.cxx
+++ b/xmloff/source/style/HatchStyle.cxx
@@ -159,7 +159,7 @@ sal_Bool XMLHatchStyleImport::importXML(
             case XML_TOK_HATCH_ROTATION:
                 {
                     sal_Int32 nValue;
-                    rUnitConverter.convertNumber( nValue, rStrValue, 0, 360 );
+                    rUnitConverter.convertNumber( nValue, rStrValue, 0, 3600 );
                     aHatch.Angle = sal_Int16( nValue );
                 }
                 break;
diff --git a/xmloff/source/style/TransGradientStyle.cxx b/xmloff/source/style/TransGradientStyle.cxx
index e98aeb2599ff..297440bcc5eb 100644
--- a/xmloff/source/style/TransGradientStyle.cxx
+++ b/xmloff/source/style/TransGradientStyle.cxx
@@ -194,7 +194,7 @@ sal_Bool XMLTransGradientStyleImport::importXML(
         case XML_TOK_GRADIENT_ANGLE:
             {
                 sal_Int32 nValue;
-                SvXMLUnitConverter::convertNumber( nValue, rStrValue, 0, 360 );
+                SvXMLUnitConverter::convertNumber( nValue, rStrValue, 0, 3600 );
                 aGradient.Angle = sal_Int16( nValue );
             }
             break;
diff --git a/xmloff/source/style/impastp3.cxx b/xmloff/source/style/impastp3.cxx
index 1f5450204562..0bae295f32de 100644
--- a/xmloff/source/style/impastp3.cxx
+++ b/xmloff/source/style/impastp3.cxx
@@ -98,6 +98,46 @@ sal_Bool SvXMLAutoStylePoolParentP_Impl::Add( XMLFamilyData_Impl* pFamilyData, c
 
 ///////////////////////////////////////////////////////////////////////////////
 //
+// Adds a array of XMLPropertyState ( vector< XMLPropertyState > ) with a given name.
+// If the name exists already, nothing is done. If a style with a different name and
+// the same properties exists, a new one is added (like with bDontSeek).
+//
+
+sal_Bool SvXMLAutoStylePoolParentP_Impl::AddNamed( XMLFamilyData_Impl* pFamilyData, const vector< XMLPropertyState >& rProperties, const OUString& rName )
+{
+    sal_Bool bAdded = sal_False;
+    sal_uInt32 i = 0;
+    sal_Int32 nProperties = rProperties.size();
+    sal_uInt32 nCount = maPropertiesList.Count();
+
+    for( i = 0; i < nCount; i++ )
+    {
+        SvXMLAutoStylePoolPropertiesP_Impl *pIS = maPropertiesList.GetObject( i );
+        if( nProperties > (sal_Int32)pIS->GetProperties().size() )
+        {
+            continue;
+        }
+        else if( nProperties < (sal_Int32)pIS->GetProperties().size() )
+        {
+            break;
+        }
+    }
+
+    if( !pFamilyData->mpNameList->Seek_Entry( &rName, 0 ) )
+    {
+        SvXMLAutoStylePoolPropertiesP_Impl* pProperties =
+                new SvXMLAutoStylePoolPropertiesP_Impl( pFamilyData, rProperties );
+        // ignore the generated name
+        pProperties->SetName( rName );
+        maPropertiesList.Insert( pProperties, i );
+        bAdded = sal_True;
+    }
+
+    return bAdded;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//
 // Search for a array of XMLPropertyState ( vector< XMLPropertyState > ) in list
 //
 
diff --git a/xmloff/source/style/impastp4.cxx b/xmloff/source/style/impastp4.cxx
index 20772b00a4c0..946b613473db 100644
--- a/xmloff/source/style/impastp4.cxx
+++ b/xmloff/source/style/impastp4.cxx
@@ -235,6 +235,47 @@ sal_Bool SvXMLAutoStylePoolP_Impl::Add(OUString& rName, sal_Int32 nFamily,
     return bRet;
 }
 
+sal_Bool SvXMLAutoStylePoolP_Impl::AddNamed(const OUString& rName, sal_Int32 nFamily,
+                const OUString& rParent, const ::std::vector< XMLPropertyState >& rProperties )
+{
+    // get family and parent the same way as in Add()
+    sal_Bool bRet(sal_False);
+    ULONG nPos;
+
+    XMLFamilyData_Impl *pFamily = 0;
+    XMLFamilyData_Impl aTemporary( nFamily );
+    if( maFamilyList.Seek_Entry( &aTemporary, &nPos ) )
+    {
+        pFamily = maFamilyList.GetObject( nPos );
+    }
+
+    DBG_ASSERT( pFamily, "SvXMLAutoStylePool_Impl::Add: unknown family" );
+    if( pFamily )
+    {
+        SvXMLAutoStylePoolParentP_Impl aTmp( rParent );
+        SvXMLAutoStylePoolParentP_Impl *pParent = 0;
+
+        SvXMLAutoStylePoolParentsP_Impl *pParents = pFamily->mpParentList;
+        if( pParents->Seek_Entry( &aTmp, &nPos ) )
+        {
+            pParent = pParents->GetObject( nPos );
+        }
+        else
+        {
+            pParent = new SvXMLAutoStylePoolParentP_Impl( rParent );
+            pParents->Insert( pParent );
+        }
+
+        if( pParent->AddNamed( pFamily, rProperties, rName ) )
+        {
+            pFamily->mnCount++;
+            bRet = sal_True;
+        }
+    }
+
+    return bRet;
+}
+
 OUString SvXMLAutoStylePoolP_Impl::AddToCache( sal_Int32 nFamily,
                                          const OUString& rParent )
 {
diff --git a/xmloff/source/style/impastpl.hxx b/xmloff/source/style/impastpl.hxx
index 3c4145a829a4..d63384a71068 100644
--- a/xmloff/source/style/impastpl.hxx
+++ b/xmloff/source/style/impastpl.hxx
@@ -124,6 +124,8 @@ public:
     const ::rtl::OUString& GetName() const { return msName; }
     const ::std::vector< XMLPropertyState >& GetProperties() const { return maProperties; }
     sal_uInt32 GetPos() const { return mnPos; }
+
+    void SetName( const ::rtl::OUString& rNew ) { msName = rNew; }
 };
 
 typedef SvXMLAutoStylePoolPropertiesP_Impl *SvXMLAutoStylePoolPropertiesPPtr;
@@ -150,6 +152,8 @@ public:
 
     sal_Bool Add( XMLFamilyData_Impl* pFamilyData, const ::std::vector< XMLPropertyState >& rProperties, ::rtl::OUString& rName, bool bDontSeek = false );
 
+    sal_Bool AddNamed( XMLFamilyData_Impl* pFamilyData, const ::std::vector< XMLPropertyState >& rProperties, const ::rtl::OUString& rName );
+
     ::rtl::OUString Find( const XMLFamilyData_Impl* pFamilyData, const ::std::vector< XMLPropertyState >& rProperties ) const;
 
     const ::rtl::OUString& GetParent() const { return msParent; }
@@ -197,6 +201,10 @@ public:
                 const ::std::vector< XMLPropertyState >& rProperties,
                 sal_Bool bCache = sal_False,
                 bool bDontSeek = false );
+    sal_Bool AddNamed( const ::rtl::OUString& rName, sal_Int32 nFamily,
+                const ::rtl::OUString& rParent,
+                const ::std::vector< XMLPropertyState >& rProperties );
+
     ::rtl::OUString AddToCache( sal_Int32 nFamily,
                                 const ::rtl::OUString& rParent );
     ::rtl::OUString Find( sal_Int32 nFamily, const ::rtl::OUString& rParent,
diff --git a/xmloff/source/style/xmlaustp.cxx b/xmloff/source/style/xmlaustp.cxx
index cc7a4408e1e6..32c53ceb724a 100644
--- a/xmloff/source/style/xmlaustp.cxx
+++ b/xmloff/source/style/xmlaustp.cxx
@@ -381,6 +381,13 @@ sal_Bool SvXMLAutoStylePoolP::Add(OUString& rName, sal_Int32 nFamily, const OUSt
     return pImpl->Add(rName, nFamily, rParent, rProperties);
 }
 
+sal_Bool SvXMLAutoStylePoolP::AddNamed( const OUString& rName, sal_Int32 nFamily, const OUString& rParent,
+                                        const ::std::vector< XMLPropertyState >& rProperties )
+
+{
+    return pImpl->AddNamed(rName, nFamily, rParent, rProperties);
+}
+
 OUString SvXMLAutoStylePoolP::AddAndCache( sal_Int32 nFamily,
                                   const vector< XMLPropertyState >& rProperties )
 {
diff --git a/xmloff/source/text/XMLTextMarkImportContext.cxx b/xmloff/source/text/XMLTextMarkImportContext.cxx
index 1091636c9d3f..5e6f47ed5b6a 100644
--- a/xmloff/source/text/XMLTextMarkImportContext.cxx
+++ b/xmloff/source/text/XMLTextMarkImportContext.cxx
@@ -47,6 +47,7 @@
 #include <com/sun/star/beans/XPropertySet.hpp>
 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
 #include <com/sun/star/container/XNamed.hpp>
+#include <com/sun/star/rdf/XMetadatable.hpp>
 
 #include <com/sun/star/text/XFormField.hpp>
 
@@ -111,9 +112,10 @@ XMLTextMarkImportContext::XMLTextMarkImportContext(
     SvXMLImport& rImport,
     XMLTextImportHelper& rHlp,
     sal_uInt16 nPrefix,
-    const OUString& rLocalName ) :
-        SvXMLImportContext(rImport, nPrefix, rLocalName),
-        rHelper(rHlp)
+    const OUString& rLocalName )
+    : SvXMLImportContext(rImport, nPrefix, rLocalName)
+    , m_rHelper(rHlp)
+    , m_bHaveAbout(false)
 {
 }
 
@@ -139,19 +141,24 @@ static SvXMLEnumMapEntry __READONLY_DATA lcl_aMarkTypeMap[] =
 void XMLTextMarkImportContext::StartElement(
     const Reference<XAttributeList> & xAttrList)
 {
-    if (!FindName(GetImport(), xAttrList, sBookmarkName, m_XmlId, &sFieldName))
-        sBookmarkName=OUString();
+    if (!FindName(GetImport(), xAttrList))
+    {
+        m_sBookmarkName = OUString();
+    }
 
     if (IsXMLToken(GetLocalName(), XML_FIELDMARK_END))
-        sBookmarkName=rHelper.FindActiveBookmarkName();
+    {
+        m_sBookmarkName = m_rHelper.FindActiveBookmarkName();
+    }
 
     if (IsXMLToken(GetLocalName(), XML_FIELDMARK_START) || IsXMLToken(GetLocalName(), XML_FIELDMARK))
     {
-        if (sBookmarkName.getLength()==0)
-            sBookmarkName=::rtl::OUString::createFromAscii("Unknown");
-        rHelper.pushFieldCtx( sBookmarkName, sFieldName );
+        if (m_sBookmarkName.getLength() == 0)
+        {
+            m_sBookmarkName = ::rtl::OUString::createFromAscii("Unknown");
+        }
+        m_rHelper.pushFieldCtx( m_sBookmarkName, m_sFieldName );
     }
-
 }
 
 void XMLTextMarkImportContext::EndElement()
@@ -167,7 +174,7 @@ void XMLTextMarkImportContext::EndElement()
     const OUString sAPI_formfieldmark(
         RTL_CONSTASCII_USTRINGPARAM("com.sun.star.text.FormFieldmark"));
 
-    if (sBookmarkName.getLength()>0)
+    if (m_sBookmarkName.getLength() > 0)
     {
         sal_uInt16 nTmp;
         if (SvXMLUnitConverter::convertEnum(nTmp, GetLocalName(),
@@ -178,34 +185,42 @@ void XMLTextMarkImportContext::EndElement()
                 case TypeReference:
                     // export point reference mark
                     CreateAndInsertMark(GetImport(),
-                                        sAPI_reference_mark,
-                                        sBookmarkName,
-                                       rHelper.GetCursorAsRange()->getStart(),
-                                       ::rtl::OUString());
+                        sAPI_reference_mark,
+                        m_sBookmarkName,
+                        m_rHelper.GetCursorAsRange()->getStart(),
+                        ::rtl::OUString());
                     break;
 
                 case TypeFieldmark:
                 case TypeBookmark:
                     {
-                        bool bImportAsField=((lcl_MarkType)nTmp==TypeFieldmark && sFieldName.compareToAscii("msoffice.field.FORMCHECKBOX")==0); // for now only import FORMCHECKBOX boxes
+                        bool bImportAsField=((lcl_MarkType)nTmp==TypeFieldmark && m_sFieldName.compareToAscii("msoffice.field.FORMCHECKBOX")==0); // for now only import FORMCHECKBOX boxes
                         // export point bookmark
-                        Reference<XInterface> xIfc=CreateAndInsertMark(GetImport(),
+                        const Reference<XInterface> xContent(
+                            CreateAndInsertMark(GetImport(),
                                         (bImportAsField?sAPI_formfieldmark:sAPI_bookmark),
-                                        sBookmarkName,
-                                       rHelper.GetCursorAsRange()->getStart(),
-                                       m_XmlId);
+                                m_sBookmarkName,
+                                m_rHelper.GetCursorAsRange()->getStart(),
+                                m_sXmlId) );
+                        if (m_bHaveAbout)
+                        {
+                            const Reference<com::sun::star::rdf::XMetadatable>
+                                xMeta( xContent, UNO_QUERY);
+                            GetImport().AddRDFa(xMeta,
+                                m_sAbout, m_sProperty, m_sContent, m_sDatatype);
+                        }
                         if ((lcl_MarkType)nTmp==TypeFieldmark) {
-                            if (xIfc.is() && bImportAsField) {
+                            if (xContent.is() && bImportAsField) {
                                 // setup fieldmark...
-                                Reference< ::com::sun::star::text::XFormField> xFormField(xIfc, UNO_QUERY);
+                                Reference< ::com::sun::star::text::XFormField> xFormField(xContent, UNO_QUERY);
                                 xFormField->setType(1); // Checkbox...
-                                if (xFormField.is() && rHelper.hasCurrentFieldCtx()) {
+                                if (xFormField.is() && m_rHelper.hasCurrentFieldCtx()) {
 //                                  xFormField->setDescription(::rtl::OUString::createFromAscii("HELLO CHECKBOX"));
 //                                  xFormField->setRes(1);
-                                    rHelper.setCurrentFieldParamsTo(xFormField);
+                                    m_rHelper.setCurrentFieldParamsTo(xFormField);
                                 }
                             }
-                            rHelper.popFieldCtx();
+                            m_rHelper.popFieldCtx();
                         }
                     }
                     break;
@@ -213,9 +228,9 @@ void XMLTextMarkImportContext::EndElement()
                 case TypeFieldmarkStart:
                 case TypeBookmarkStart:
                     // save XTextRange for later construction of bookmark
-                    rHelper.InsertBookmarkStartRange(
-                        sBookmarkName, rHelper.GetCursorAsRange()->getStart(),
-                        m_XmlId);
+                    m_rHelper.InsertBookmarkStartRange(
+                        m_sBookmarkName, m_rHelper.GetCursorAsRange()->getStart(),
+                        m_sXmlId);
                     break;
 
                 case TypeFieldmarkEnd:
@@ -223,18 +238,18 @@ void XMLTextMarkImportContext::EndElement()
                 {
                     // get old range, and construct
                     Reference<XTextRange> xStartRange;
-                    if (rHelper.FindAndRemoveBookmarkStartRange(sBookmarkName,
-                            xStartRange, m_XmlId))
+                    if (m_rHelper.FindAndRemoveBookmarkStartRange(m_sBookmarkName,
+                            xStartRange, m_sXmlId))
                     {
                         Reference<XTextRange> xEndRange(
-                            rHelper.GetCursorAsRange()->getStart());
+                            m_rHelper.GetCursorAsRange()->getStart());
 
                         // check if beginning and end are in same XText
                         if (xStartRange->getText() == xEndRange->getText())
                         {
                             // create range for insertion
                             Reference<XTextCursor> xInsertionCursor =
-                                rHelper.GetText()->createTextCursorByRange(
+                                m_rHelper.GetText()->createTextCursorByRange(
                                     xEndRange);
                             xInsertionCursor->gotoRange(xStartRange, sal_True);
 
@@ -247,30 +262,39 @@ void XMLTextMarkImportContext::EndElement()
                             Reference<XTextRange> xInsertionRange(
                                 xInsertionCursor, UNO_QUERY);
 
-                            bool bImportAsField=((lcl_MarkType)nTmp==TypeFieldmarkEnd && rHelper.hasCurrentFieldCtx());
+                            bool bImportAsField=((lcl_MarkType)nTmp==TypeFieldmarkEnd && m_rHelper.hasCurrentFieldCtx());
                             if (bImportAsField) {
-                                ::rtl::OUString currentFieldType=rHelper.getCurrentFieldType();
+                                ::rtl::OUString currentFieldType =
+                                    m_rHelper.getCurrentFieldType();
                                 bImportAsField=currentFieldType.compareToAscii("msoffice.field.FORMTEXT")==0; // for now only import FORMTEXT boxes
                             }
 
                             // insert reference
-                            Reference<XInterface> xIfc=CreateAndInsertMark(GetImport(),
+                            const Reference<XInterface> xContent(
+                                CreateAndInsertMark(GetImport(),
                                                 (bImportAsField?sAPI_fieldmark:sAPI_bookmark),
-                                                sBookmarkName,
-                                                xInsertionRange,
-                                                m_XmlId);
+                                    m_sBookmarkName,
+                                    xInsertionRange,
+                                    m_sXmlId) );
+                            if (m_bHaveAbout)
+                            {
+                                const Reference<com::sun::star::rdf::XMetadatable>
+                                    xMeta( xContent, UNO_QUERY);
+                                GetImport().AddRDFa(xMeta,
+                                    m_sAbout, m_sProperty, m_sContent, m_sDatatype);
+                            }
 
                             if ((lcl_MarkType)nTmp==TypeFieldmarkEnd) {
-                                if (xIfc.is() && bImportAsField) {
+                                if (xContent.is() && bImportAsField) {
                                     // setup fieldmark...
-                                    Reference< ::com::sun::star::text::XFormField> xFormField(xIfc, UNO_QUERY);
+                                    Reference< ::com::sun::star::text::XFormField> xFormField(xContent, UNO_QUERY);
                                     xFormField->setType(0); // Text
-                                    if (xFormField.is() && rHelper.hasCurrentFieldCtx()) {
-                                        rHelper.setCurrentFieldParamsTo(xFormField);
+                                    if (xFormField.is() && m_rHelper.hasCurrentFieldCtx()) {
+                                        m_rHelper.setCurrentFieldParamsTo(xFormField);
 //                                  xFormField->setDescription(::rtl::OUString::createFromAscii("HELLO"));
                                     }
                                 }
-                                rHelper.popFieldCtx();
+                                m_rHelper.popFieldCtx();
                             }
                         }
                         // else: beginning/end in different XText -> ignore!
@@ -296,11 +320,12 @@ SvXMLImportContext *XMLTextMarkImportContext::CreateChildContext( USHORT nPrefix
                                         const ::rtl::OUString& rLocalName,
                                         const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XAttributeList >&  )
 {
-    return new XMLFieldParamImportContext(GetImport(), rHelper, nPrefix, rLocalName);
+    return new XMLFieldParamImportContext(GetImport(), m_rHelper,
+                nPrefix, rLocalName);
 }
 
 
-Reference<XInterface> XMLTextMarkImportContext::CreateAndInsertMark(
+Reference<XTextContent> XMLTextMarkImportContext::CreateAndInsertMark(
     SvXMLImport& rImport,
     const OUString& sServiceName,
     const OUString& sMarkName,
@@ -337,9 +362,6 @@ Reference<XInterface> XMLTextMarkImportContext::CreateAndInsertMark(
             }
         }
 
-        // xml:id for RDF metadata
-        rImport.SetXmlId(xIfc, i_rXmlId);
-
         // cast to XTextContent and attach to document
         const Reference<XTextContent> xTextContent(xIfc, UNO_QUERY);
         if (xTextContent.is())
@@ -350,6 +372,11 @@ Reference<XInterface> XMLTextMarkImportContext::CreateAndInsertMark(
                 // collapsing of the given XTextRange.
                 rImport.GetTextImport()->GetText()->insertTextContent(rRange,
                     xTextContent, sal_True);
+
+                // xml:id for RDF metadata -- after insertion!
+                rImport.SetXmlId(xIfc, i_rXmlId);
+
+                return xTextContent;
             }
             catch (com::sun::star::lang::IllegalArgumentException &)
             {
@@ -358,44 +385,60 @@ Reference<XInterface> XMLTextMarkImportContext::CreateAndInsertMark(
             }
         }
     }
-    return xIfc;
+    return 0;
 }
 
 sal_Bool XMLTextMarkImportContext::FindName(
     SvXMLImport& rImport,
-    const Reference<XAttributeList> & xAttrList,
-    OUString& sName,
-    OUString& o_rXmlId,
-    ::rtl::OUString *pFieldName)
+    const Reference<XAttributeList> & xAttrList)
 {
     sal_Bool bNameOK = sal_False;
 
     // find name attribute first
-    sal_Int16 nLength = xAttrList->getLength();
+    const sal_Int16 nLength = xAttrList->getLength();
     for(sal_Int16 nAttr = 0; nAttr < nLength; nAttr++)
     {
         OUString sLocalName;
-        sal_uInt16 nPrefix = rImport.GetNamespaceMap().
+        const sal_uInt16 nPrefix = rImport.GetNamespaceMap().
             GetKeyByAttrName( xAttrList->getNameByIndex(nAttr),
                               &sLocalName );
 
         if ( (XML_NAMESPACE_TEXT == nPrefix) &&
              IsXMLToken(sLocalName, XML_NAME)   )
         {
-            sName = xAttrList->getValueByIndex(nAttr);
+            m_sBookmarkName = xAttrList->getValueByIndex(nAttr);
             bNameOK = sal_True;
         }
         else if ( (XML_NAMESPACE_XML == nPrefix) &&
              IsXMLToken(sLocalName, XML_ID)   )
         {
-            o_rXmlId = xAttrList->getValueByIndex(nAttr);
+            m_sXmlId = xAttrList->getValueByIndex(nAttr);
+        }
+        else if ( XML_NAMESPACE_XHTML == nPrefix )
+        {
+            // RDFa
+            if ( IsXMLToken( sLocalName, XML_ABOUT) )
+            {
+                m_sAbout = xAttrList->getValueByIndex(nAttr);
+                m_bHaveAbout = true;
+            }
+            else if ( IsXMLToken( sLocalName, XML_PROPERTY) )
+            {
+                m_sProperty = xAttrList->getValueByIndex(nAttr);
+            }
+            else if ( IsXMLToken( sLocalName, XML_CONTENT) )
+            {
+                m_sContent = xAttrList->getValueByIndex(nAttr);
+            }
+            else if ( IsXMLToken( sLocalName, XML_DATATYPE) )
+            {
+                m_sDatatype = xAttrList->getValueByIndex(nAttr);
+            }
         }
-//FIXME: RDFa (text:bookmark-start)
-        else if ( pFieldName!=NULL &&
-            (XML_NAMESPACE_FIELD == nPrefix) &&
+        else if ( (XML_NAMESPACE_FIELD == nPrefix) &&
              IsXMLToken(sLocalName, XML_TYPE)   )
         {
-            *pFieldName = xAttrList->getValueByIndex(nAttr);
+            m_sFieldName = xAttrList->getValueByIndex(nAttr);
         }
     }
 
diff --git a/xmloff/source/text/XMLTextMarkImportContext.hxx b/xmloff/source/text/XMLTextMarkImportContext.hxx
index 4491524e9ec2..0269a3b4622d 100644
--- a/xmloff/source/text/XMLTextMarkImportContext.hxx
+++ b/xmloff/source/text/XMLTextMarkImportContext.hxx
@@ -39,6 +39,7 @@
 namespace com { namespace sun { namespace star {
     namespace text {
         class XTextRange;
+        class XTextContent;
     }
     namespace xml { namespace sax {
         class XAttributeList;
@@ -75,10 +76,16 @@ public:
 class XMLTextMarkImportContext : public SvXMLImportContext
 {
 
-    XMLTextImportHelper& rHelper;
-    ::rtl::OUString m_XmlId;
-    ::rtl::OUString sBookmarkName;
-    ::rtl::OUString sFieldName;
+    XMLTextImportHelper & m_rHelper;
+    ::rtl::OUString m_sBookmarkName;
+    ::rtl::OUString m_sFieldName;
+    ::rtl::OUString m_sXmlId;
+    // RDFa
+    bool m_bHaveAbout;
+    ::rtl::OUString m_sAbout;
+    ::rtl::OUString m_sProperty;
+    ::rtl::OUString m_sContent;
+    ::rtl::OUString m_sDatatype;
 
 public:
 
@@ -90,7 +97,6 @@ public:
         sal_uInt16 nPrfx,
         const ::rtl::OUString& rLocalName );
 
-
 protected:
 
     virtual void StartElement(
@@ -103,7 +109,8 @@ protected:
                                                     const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XAttributeList >& xAttrList );
 
 public:
-    static ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > CreateAndInsertMark(
+    static ::com::sun::star::uno::Reference<
+            ::com::sun::star::text::XTextContent > CreateAndInsertMark(
         SvXMLImport& rImport,
         const ::rtl::OUString& sServiceName,
         const ::rtl::OUString& sMarkName,
@@ -111,13 +118,10 @@ public:
             ::com::sun::star::text::XTextRange> & rRange,
         const ::rtl::OUString& i_rXmlId = ::rtl::OUString());
 
-    static sal_Bool FindName(
+    sal_Bool FindName(
         SvXMLImport& rImport,
         const ::com::sun::star::uno::Reference<
-            ::com::sun::star::xml::sax::XAttributeList> & xAttrList,
-        ::rtl::OUString& sName,
-        ::rtl::OUString& o_rXmlId,
-        ::rtl::OUString *pFieldName=NULL);
+        ::com::sun::star::xml::sax::XAttributeList> & xAttrList);
 };
 
 #endif
diff --git a/xmloff/source/text/txtflde.cxx b/xmloff/source/text/txtflde.cxx
index 873a4a42f02c..198938fdc8f6 100644
--- a/xmloff/source/text/txtflde.cxx
+++ b/xmloff/source/text/txtflde.cxx
@@ -148,7 +148,7 @@ static sal_Char __READONLY_DATA FIELD_SERVICE_BIBLIOGRAPHY[] = "Bibliography";
 static sal_Char __READONLY_DATA FIELD_SERVICE_SCRIPT[] = "Script";
 static sal_Char __READONLY_DATA FIELD_SERVICE_ANNOTATION[] = "Annotation";
 static sal_Char __READONLY_DATA FIELD_SERVICE_COMBINED_CHARACTERS[] = "CombinedCharacters";
-static sal_Char __READONLY_DATA FIELD_SERVICE_META[] = "MetaField";
+static sal_Char __READONLY_DATA FIELD_SERVICE_META[] = "MetadataField";
 static sal_Char __READONLY_DATA FIELD_SERVICE_MEASURE[] = "Measure";
 static sal_Char __READONLY_DATA FIELD_SERVICE_TABLE_FORMULA[] = "TableFormula";
 static sal_Char __READONLY_DATA FIELD_SERVICE_DROP_DOWN[] = "DropDown";
@@ -263,7 +263,7 @@ XMLTextFieldExport::XMLTextFieldExport( SvXMLExport& rExp,
                                         XMLPropertyState* pCombinedCharState)
     : rExport(rExp),
       pUsedMasters(NULL),
-      sServicePrefix(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.text.TextField.")),
+      sServicePrefix(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.text.textfield.")),
       sFieldMasterPrefix(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.text.FieldMaster.")),
       sPresentationServicePrefix(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.presentation.TextField.")),
 
@@ -645,7 +645,7 @@ sal_Bool XMLTextFieldExport::IsStringField(
         return !bRet;
     }
 
-    case FIELD_ID_META://FIXME ?????? no idea...
+    case FIELD_ID_META:
         return 0 > GetIntProperty(sPropertyNumberFormat, xPropSet);
 
     case FIELD_ID_DATABASE_DISPLAY:
@@ -740,7 +740,8 @@ sal_Bool XMLTextFieldExport::IsStringField(
 /// export the styles needed by the given field. Called on first pass
 /// through document
 void XMLTextFieldExport::ExportFieldAutoStyle(
-    const Reference<XTextField> & rTextField, sal_Bool bProgress )
+    const Reference<XTextField> & rTextField, const sal_Bool bProgress,
+    const sal_Bool bRecursive )
 {
     // get property set
     Reference<XPropertySet> xPropSet(rTextField, UNO_QUERY);
@@ -835,7 +836,10 @@ void XMLTextFieldExport::ExportFieldAutoStyle(
 
     case FIELD_ID_META:
         // recurse into content (does not export element, so can be done first)
-        ExportMetaField(xPropSet, true, bProgress);
+        if (bRecursive)
+        {
+            ExportMetaField(xPropSet, true, bProgress);
+        }
         // fall-through: for the meta-field itself!
     case FIELD_ID_DOCINFO_PRINT_TIME:
     case FIELD_ID_DOCINFO_PRINT_DATE:
@@ -2263,7 +2267,6 @@ void XMLTextFieldExport::ExportMacro(
     GetExport().Characters(rContent);
 }
 
-// FIXME: this is untested
 void XMLTextFieldExport::ExportMetaField(
     const Reference<XPropertySet> & i_xMeta,
     bool i_bAutoStyles, sal_Bool i_bProgress )
diff --git a/xmloff/source/text/txtimp.cxx b/xmloff/source/text/txtimp.cxx
index add97d20efda..613a4688389f 100644
--- a/xmloff/source/text/txtimp.cxx
+++ b/xmloff/source/text/txtimp.cxx
@@ -1163,30 +1163,38 @@ OUString XMLTextImportHelper::SetStyleAndAttrs(
 
         if (pListBlock || pNumberedParagraph)
         {
-            sal_Bool bSameNumRules = xNewNumRules == xNumRules;
-            if( !bSameNumRules && xNewNumRules.is() && xNumRules.is() )
+            // --> OD 2009-08-24 #i101349#
+            // Assure that list style of automatic paragraph style is applied at paragraph.
+            sal_Bool bApplyNumRules = pStyle && pStyle->IsListStyleSet();
+            if ( !bApplyNumRules )
             {
-                // If the interface pointers are different then this does
-                // not mean that the num rules are different. Further tests
-                // are required then. However, if only one num rule is
-                // set, no tests are required of course.
-                Reference< XNamed > xNewNamed( xNewNumRules, UNO_QUERY );
-                Reference< XNamed > xNamed( xNumRules, UNO_QUERY );
-                if( xNewNamed.is() && xNamed.is() )
+                sal_Bool bSameNumRules = xNewNumRules == xNumRules;
+                if( !bSameNumRules && xNewNumRules.is() && xNumRules.is() )
                 {
-                    bSameNumRules = xNewNamed->getName() == xNamed->getName();
-                }
-                else
-                {
-                    Reference< XAnyCompare > xNumRuleCompare( xNumRules, UNO_QUERY );
-                    if( xNumRuleCompare.is() )
+                    // If the interface pointers are different then this does
+                    // not mean that the num rules are different. Further tests
+                    // are required then. However, if only one num rule is
+                    // set, no tests are required of course.
+                    Reference< XNamed > xNewNamed( xNewNumRules, UNO_QUERY );
+                    Reference< XNamed > xNamed( xNumRules, UNO_QUERY );
+                    if( xNewNamed.is() && xNamed.is() )
                     {
-                        bSameNumRules = (xNumRuleCompare->compare( Any(xNumRules), Any(xNewNumRules) ) == 0);
+                        bSameNumRules = xNewNamed->getName() == xNamed->getName();
+                    }
+                    else
+                    {
+                        Reference< XAnyCompare > xNumRuleCompare( xNumRules, UNO_QUERY );
+                        if( xNumRuleCompare.is() )
+                        {
+                            bSameNumRules = (xNumRuleCompare->compare( Any(xNumRules), Any(xNewNumRules) ) == 0);
+                        }
                     }
                 }
+                bApplyNumRules = !bSameNumRules;
             }
 
-            if( !bSameNumRules )
+            if ( bApplyNumRules )
+            // <--
             {
                 // #102607# This may except when xNewNumRules contains
                 // a Writer-NumRule-Implementation bug gets applied to
diff --git a/xmloff/source/text/txtparae.cxx b/xmloff/source/text/txtparae.cxx
index 6a3b66ec58ee..2c160eabd334 100644
--- a/xmloff/source/text/txtparae.cxx
+++ b/xmloff/source/text/txtparae.cxx
@@ -1461,8 +1461,8 @@ bool XMLTextParagraphExport::collectTextAutoStylesOptimized( sal_Bool bIsProgres
         {
             Any aAny = xTextFieldsEnum->nextElement();
             Reference< XTextField > xTextField = *(Reference<XTextField>*)aAny.getValue();
-            exportTextField( xTextField->getAnchor(), bAutoStyles,
-                bIsProgress );
+            exportTextField( xTextField, bAutoStyles, bIsProgress,
+                !xAutoStylesSupp.is() );
             try
             {
                 Reference < XPropertySet > xSet( xTextField, UNO_QUERY );
@@ -1470,8 +1470,11 @@ bool XMLTextParagraphExport::collectTextAutoStylesOptimized( sal_Bool bIsProgres
                 Any a = xSet->getPropertyValue( ::rtl::OUString::createFromAscii("TextRange") );
                 a >>= xText;
                 if ( xText.is() )
+                {
                     exportText( xText, sal_True, bIsProgress, bExportContent );
-                GetExport().GetTextParagraphExport()->collectTextAutoStyles( xText );
+                    GetExport().GetTextParagraphExport()
+                        ->collectTextAutoStyles( xText );
+                }
             }
             catch (Exception&)
             {
@@ -2145,7 +2148,7 @@ void XMLTextParagraphExport::exportTextRangeEnumeration(
         sal_Bool bAutoStyles, sal_Bool bIsProgress,
         sal_Bool bPrvChrIsSpc )
 {
-    static OUString sMeta(RTL_CONSTASCII_USTRINGPARAM("Meta")); // FIXME
+    static OUString sMeta(RTL_CONSTASCII_USTRINGPARAM("InContentMetadata"));
     sal_Bool bPrevCharIsSpace = bPrvChrIsSpc;
 
     while( rTextEnum->hasMoreElements() )
@@ -2305,7 +2308,8 @@ void XMLTextParagraphExport::exportTextRangeEnumeration(
         }
     }
 
-    DBG_ASSERT( !bOpenRuby, "Red Alert: Ruby still open!" );
+// now that there are nested enumerations for meta(-field), this may be valid!
+//  DBG_ASSERT( !bOpenRuby, "Red Alert: Ruby still open!" );
 }
 
 void XMLTextParagraphExport::exportTable(
@@ -2326,21 +2330,29 @@ void XMLTextParagraphExport::exportTextField(
         DBG_ASSERT( xTxtFld.is(), "text field missing" );
         if( xTxtFld.is() )
         {
-            if( bAutoStyles )
-            {
-                pFieldExport->ExportFieldAutoStyle( xTxtFld, bIsProgress );
-            }
-            else
-            {
-                pFieldExport->ExportField( xTxtFld, bIsProgress );
-            }
+            exportTextField(xTxtFld, bAutoStyles, bIsProgress, sal_True);
         }
         else
         {
             // write only characters
             GetExport().Characters(rTextRange->getString());
         }
+    }
+}
 
+void XMLTextParagraphExport::exportTextField(
+        const Reference < XTextField > & xTextField,
+        const sal_Bool bAutoStyles, const sal_Bool bIsProgress,
+        const sal_Bool bRecursive )
+{
+    if ( bAutoStyles )
+    {
+        pFieldExport->ExportFieldAutoStyle( xTextField, bIsProgress,
+                bRecursive );
+    }
+    else
+    {
+        pFieldExport->ExportField( xTextField, bIsProgress );
     }
 }
 
@@ -2385,9 +2397,12 @@ void XMLTextParagraphExport::exportTextMark(
             nElement = *(sal_Bool *)rPropSet->getPropertyValue(sIsStart).getValue() ? 1 : 2;
         }
 
-        // bookmark, bookmark-start: xml:id for RDF metadata
+        // bookmark, bookmark-start: xml:id and RDFa for RDF metadata
         if( nElement < 2 ) {
             GetExport().AddAttributeXmlId(xName);
+            const uno::Reference<text::XTextContent> xTextContent(
+                    xName, uno::UNO_QUERY_THROW);
+            GetExport().AddAttributesRDFa(xTextContent);
         }
 
         // export element
@@ -3664,11 +3679,12 @@ void XMLTextParagraphExport::exportRuby(
     }
 }
 
-// FIXME: this is untested
 void XMLTextParagraphExport::exportMeta(
-    const Reference<XPropertySet> & i_xMeta,
+    const Reference<XPropertySet> & i_xPortion,
     sal_Bool i_bAutoStyles, sal_Bool i_isProgress)
 {
+    static OUString sMeta(RTL_CONSTASCII_USTRINGPARAM("InContentMetadata"));
+
     bool doExport(!i_bAutoStyles); // do not export element if autostyles
     // check version >= 1.2
     switch (GetExport().getDefaultVersion()) {
@@ -3677,13 +3693,14 @@ void XMLTextParagraphExport::exportMeta(
         default: break;
     }
 
-    const Reference < XEnumerationAccess > xEA( i_xMeta, UNO_QUERY_THROW );
-    const Reference < XEnumeration > xTextEnum( xEA->createEnumeration() );
+    const Reference< XTextContent > xTextContent(
+            i_xPortion->getPropertyValue(sMeta), UNO_QUERY_THROW);
+    const Reference< XEnumerationAccess > xEA( xTextContent, UNO_QUERY_THROW );
+    const Reference< XEnumeration > xTextEnum( xEA->createEnumeration() );
 
     if (doExport)
     {
-        const Reference<rdf::XMetadatable> xMeta( i_xMeta, UNO_QUERY_THROW );
-        const Reference<XTextContent> xTextContent( i_xMeta, UNO_QUERY_THROW );
+        const Reference<rdf::XMetadatable> xMeta(xTextContent, UNO_QUERY_THROW);
 
         // text:meta with neither xml:id nor RDFa is invalid
         xMeta->ensureMetadataReference();
diff --git a/xmloff/source/text/txtparai.cxx b/xmloff/source/text/txtparai.cxx
index 6fb213f43642..dda2c3d49030 100644
--- a/xmloff/source/text/txtparai.cxx
+++ b/xmloff/source/text/txtparai.cxx
@@ -190,6 +190,11 @@ public:
         const OUString& rLocalName,
         XMLHints_Impl& rHnts,
         const Reference<xml::sax::XAttributeList> & xAttrList);
+
+    static sal_Bool FindName(
+        SvXMLImport& rImport,
+        const Reference<xml::sax::XAttributeList> & xAttrList,
+        OUString& rName);
 };
 
 TYPEINIT1( XMLStartReferenceContext_Impl, SvXMLImportContext );
@@ -203,11 +208,8 @@ XMLStartReferenceContext_Impl::XMLStartReferenceContext_Impl(
         SvXMLImportContext(rImport, nPrefix, rLocalName)
 {
     OUString sName;
-    OUString dummy;
 
-    // borrow FindName from XMLTextMarkImportContext, where bookmarks
-    // and point references are handled.
-    if (XMLTextMarkImportContext::FindName(GetImport(), xAttrList, sName, dummy))
+    if (FindName(GetImport(), xAttrList, sName))
     {
         XMLHint_Impl* pHint = new XMLReferenceHint_Impl(
             sName, rImport.GetTextImport()->GetCursor()->getStart() );
@@ -219,6 +221,33 @@ XMLStartReferenceContext_Impl::XMLStartReferenceContext_Impl(
     }
 }
 
+sal_Bool XMLStartReferenceContext_Impl::FindName(
+    SvXMLImport& rImport,
+    const Reference<xml::sax::XAttributeList> & xAttrList,
+    OUString& rName)
+{
+    sal_Bool bNameOK( sal_False );
+
+    // find name attribute first
+    const sal_Int16 nLength( xAttrList->getLength() );
+    for (sal_Int16 nAttr = 0; nAttr < nLength; nAttr++)
+    {
+        OUString sLocalName;
+        const sal_uInt16 nPrefix = rImport.GetNamespaceMap().
+            GetKeyByAttrName( xAttrList->getNameByIndex(nAttr),
+                              &sLocalName );
+
+        if ( (XML_NAMESPACE_TEXT == nPrefix) &&
+             IsXMLToken(sLocalName, XML_NAME)   )
+        {
+            rName = xAttrList->getValueByIndex(nAttr);
+            bNameOK = sal_True;
+        }
+    }
+
+    return bNameOK;
+}
+
 // ---------------------------------------------------------------------
 
 /** import end of reference (<text:reference-end>) */
@@ -247,10 +276,9 @@ XMLEndReferenceContext_Impl::XMLEndReferenceContext_Impl(
         SvXMLImportContext(rImport, nPrefix, rLocalName)
 {
     OUString sName;
-    OUString dummy;
 
-    // borrow from XMLTextMarkImportContext
-    if (XMLTextMarkImportContext::FindName(GetImport(), xAttrList, sName, dummy))
+    // borrow from XMLStartReferenceContext_Impl
+    if (XMLStartReferenceContext_Impl::FindName(GetImport(), xAttrList, sName))
     {
         // search for reference start
         sal_uInt16 nCount = rHints.Count();
@@ -511,9 +539,44 @@ void XMLImpRubyBaseContext_Impl::Characters( const OUString& rChars )
 
 // ---------------------------------------------------------------------
 
+class XMLImpRubyContext_Impl : public SvXMLImportContext
+{
+    XMLHints_Impl&  rHints;
+
+    sal_Bool&       rIgnoreLeadingSpace;
+
+    Reference < XTextRange > m_xStart;
+    OUString        m_sStyleName;
+    OUString        m_sTextStyleName;
+    OUString        m_sText;
+
+public:
+
+    TYPEINFO();
+
+    XMLImpRubyContext_Impl(
+            SvXMLImport& rImport,
+            sal_uInt16 nPrfx,
+            const OUString& rLName,
+            const Reference< xml::sax::XAttributeList > & xAttrList,
+            XMLHints_Impl& rHnts,
+            sal_Bool& rIgnLeadSpace );
+
+    virtual ~XMLImpRubyContext_Impl();
+
+    virtual SvXMLImportContext *CreateChildContext(
+            sal_uInt16 nPrefix, const OUString& rLocalName,
+            const Reference< xml::sax::XAttributeList > & xAttrList );
+
+    void SetTextStyleName( const OUString& s ) { m_sTextStyleName = s; }
+    void AppendText( const OUString& s ) { m_sText += s; }
+};
+
+// ---------------------------------------------------------------------
+
 class XMLImpRubyTextContext_Impl : public SvXMLImportContext
 {
-    XMLRubyHint_Impl    *pHint;
+    XMLImpRubyContext_Impl & m_rRubyContext;
 
 public:
 
@@ -524,7 +587,7 @@ public:
             sal_uInt16 nPrfx,
             const OUString& rLName,
             const Reference< xml::sax::XAttributeList > & xAttrList,
-            XMLRubyHint_Impl *pHint );
+            XMLImpRubyContext_Impl & rParent );
 
     virtual ~XMLImpRubyTextContext_Impl();
 
@@ -538,9 +601,9 @@ XMLImpRubyTextContext_Impl::XMLImpRubyTextContext_Impl(
         sal_uInt16 nPrfx,
         const OUString& rLName,
         const Reference< xml::sax::XAttributeList > & xAttrList,
-        XMLRubyHint_Impl *pHt ) :
-    SvXMLImportContext( rImport, nPrfx, rLName ),
-    pHint( pHt )
+        XMLImpRubyContext_Impl & rParent )
+    : SvXMLImportContext( rImport, nPrfx, rLName )
+    , m_rRubyContext( rParent )
 {
     sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
     for( sal_Int16 i=0; i < nAttrCount; i++ )
@@ -555,7 +618,7 @@ XMLImpRubyTextContext_Impl::XMLImpRubyTextContext_Impl(
         if( XML_NAMESPACE_TEXT == nPrefix &&
             IsXMLToken( aLocalName, XML_STYLE_NAME ) )
         {
-            pHint->SetTextStyleName( rValue );
+            m_rRubyContext.SetTextStyleName( rValue );
             break;
         }
     }
@@ -567,37 +630,11 @@ XMLImpRubyTextContext_Impl::~XMLImpRubyTextContext_Impl()
 
 void XMLImpRubyTextContext_Impl::Characters( const OUString& rChars )
 {
-    pHint->AppendText( rChars );
+    m_rRubyContext.AppendText( rChars );
 }
 
 // ---------------------------------------------------------------------
 
-class XMLImpRubyContext_Impl : public SvXMLImportContext
-{
-    XMLHints_Impl&  rHints;
-    XMLRubyHint_Impl    *pHint;
-
-    sal_Bool&       rIgnoreLeadingSpace;
-
-public:
-
-    TYPEINFO();
-
-    XMLImpRubyContext_Impl(
-            SvXMLImport& rImport,
-            sal_uInt16 nPrfx,
-            const OUString& rLName,
-            const Reference< xml::sax::XAttributeList > & xAttrList,
-            XMLHints_Impl& rHnts,
-            sal_Bool& rIgnLeadSpace );
-
-    virtual ~XMLImpRubyContext_Impl();
-
-    virtual SvXMLImportContext *CreateChildContext(
-            sal_uInt16 nPrefix, const OUString& rLocalName,
-            const Reference< xml::sax::XAttributeList > & xAttrList );
-};
-
 TYPEINIT1( XMLImpRubyContext_Impl, SvXMLImportContext );
 
 XMLImpRubyContext_Impl::XMLImpRubyContext_Impl(
@@ -609,9 +646,8 @@ XMLImpRubyContext_Impl::XMLImpRubyContext_Impl(
         sal_Bool& rIgnLeadSpace ) :
     SvXMLImportContext( rImport, nPrfx, rLName ),
     rHints( rHnts ),
-    pHint( new XMLRubyHint_Impl(
-              GetImport().GetTextImport()->GetCursorAsRange()->getStart() ) ),
     rIgnoreLeadingSpace( rIgnLeadSpace )
+    , m_xStart( GetImport().GetTextImport()->GetCursorAsRange()->getStart() )
 {
     sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
     for( sal_Int16 i=0; i < nAttrCount; i++ )
@@ -626,18 +662,22 @@ XMLImpRubyContext_Impl::XMLImpRubyContext_Impl(
         if( XML_NAMESPACE_TEXT == nPrefix &&
             IsXMLToken( aLocalName, XML_STYLE_NAME ) )
         {
-            pHint->SetStyleName( rValue );
+            m_sStyleName = rValue;
             break;
         }
     }
-    rHints.Insert( pHint, rHints.Count() );
 }
 
 XMLImpRubyContext_Impl::~XMLImpRubyContext_Impl()
 {
-    if( pHint )
-        pHint->SetEnd( GetImport().GetTextImport()
-                            ->GetCursorAsRange()->getStart() );
+    const UniReference < XMLTextImportHelper > xTextImport(
+        GetImport().GetTextImport());
+    const Reference < XTextCursor > xAttrCursor(
+        xTextImport->GetText()->createTextCursorByRange( m_xStart ));
+    xAttrCursor->gotoRange(xTextImport->GetCursorAsRange()->getStart(),
+            sal_True);
+    xTextImport->SetRuby( GetImport(), xAttrCursor,
+         m_sStyleName, m_sTextStyleName, m_sText );
 }
 
 SvXMLImportContext *XMLImpRubyContext_Impl::CreateChildContext(
@@ -657,7 +697,7 @@ SvXMLImportContext *XMLImpRubyContext_Impl::CreateChildContext(
             pContext = new XMLImpRubyTextContext_Impl( GetImport(), nPrefix,
                                                        rLocalName,
                                                        xAttrList,
-                                                       pHint );
+                                                       *this );
         else
             pContext = new SvXMLImportContext(
                 GetImport(), nPrefix, rLocalName );
@@ -672,7 +712,6 @@ SvXMLImportContext *XMLImpRubyContext_Impl::CreateChildContext(
 // ---------------------------------------------------------------------
 
 /** for text:meta and text:meta-field
-//FIXME not tested
  */
 class XMLMetaImportContextBase : public SvXMLImportContext
 {
@@ -691,19 +730,21 @@ public:
 
     XMLMetaImportContextBase(
         SvXMLImport& i_rImport,
-        sal_uInt16 i_nPrefix,
+        const sal_uInt16 i_nPrefix,
         const OUString& i_rLocalName,
-        const Reference< xml::sax::XAttributeList > & i_xAttrList,
         XMLHints_Impl& i_rHints,
         sal_Bool & i_rIgnoreLeadingSpace );
 
     virtual ~XMLMetaImportContextBase();
 
+    virtual void StartElement(
+            const Reference<xml::sax::XAttributeList> & i_xAttrList);
+
     virtual void EndElement();
 
     virtual SvXMLImportContext *CreateChildContext(
             sal_uInt16 i_nPrefix, const OUString& i_rLocalName,
-            const Reference< xml::sax::XAttributeList > & i_xAttrList );
+            const Reference< xml::sax::XAttributeList > & i_xAttrList);
 
     virtual void Characters( const OUString& i_rChars );
 
@@ -718,33 +759,36 @@ TYPEINIT1( XMLMetaImportContextBase, SvXMLImportContext );
 
 XMLMetaImportContextBase::XMLMetaImportContextBase(
         SvXMLImport& i_rImport,
-        sal_uInt16 i_nPrefix,
+        const sal_uInt16 i_nPrefix,
         const OUString& i_rLocalName,
-        const Reference< xml::sax::XAttributeList > & i_xAttrList,
         XMLHints_Impl& i_rHints,
         sal_Bool & i_rIgnoreLeadingSpace )
     : SvXMLImportContext( i_rImport, i_nPrefix, i_rLocalName )
     , m_rHints( i_rHints )
     , m_rIgnoreLeadingSpace( i_rIgnoreLeadingSpace )
-    , m_xStart()
+    , m_xStart( GetImport().GetTextImport()->GetCursorAsRange()->getStart() )
+{
+}
+
+XMLMetaImportContextBase::~XMLMetaImportContextBase()
+{
+}
+
+void XMLMetaImportContextBase::StartElement(
+        const Reference<xml::sax::XAttributeList> & i_xAttrList)
 {
     const sal_Int16 nAttrCount(i_xAttrList.is() ? i_xAttrList->getLength() : 0);
-    for ( sal_Int16 i=0; i < nAttrCount; i++ )
+    for ( sal_Int16 i = 0; i < nAttrCount; ++i )
     {
         const OUString& rAttrName( i_xAttrList->getNameByIndex( i ) );
         const OUString& rValue( i_xAttrList->getValueByIndex( i ) );
 
         OUString sLocalName;
-        sal_uInt16 nPrefix =
+        const sal_uInt16 nPrefix(
             GetImport().GetNamespaceMap().GetKeyByAttrName( rAttrName,
-                                                            &sLocalName );
+                                                            &sLocalName ));
         ProcessAttribute(nPrefix, sLocalName, rValue);
     }
-    m_xStart = GetImport().GetTextImport()->GetCursorAsRange()->getStart();
-}
-
-XMLMetaImportContextBase::~XMLMetaImportContextBase()
-{
 }
 
 void XMLMetaImportContextBase::EndElement()
@@ -764,41 +808,15 @@ void XMLMetaImportContextBase::EndElement()
     const Reference<XTextRange> xInsertionRange(xInsertionCursor, UNO_QUERY);
 
     InsertMeta(xInsertionRange);
-//FIXME
-#if 0
-    Reference<XMultiServiceFactory> xFactory(rImport.GetModel(), UNO_QUERY);
-    if ( xFactory.is() )
-    {
-        Reference<XInterface> xIfc = xFactory->createInstance(sServiceName);
-
-        // xml:id for RDF metadata
-        rImport.SetXmlId(xIfc, i_rXmlId);
-
-        // cast to XTextContent and attach to document
-        Reference<XTextContent> xTextContent(xIfc, UNO_QUERY);
-        if (xTextContent.is())
-        {
-            try
-            {
-                rImport.GetTextImport()->GetText()->insertTextContent(
-                    xInsertionRange, xTextContent, sal_True);
-            }
-            catch (com::sun::star::lang::IllegalArgumentException &)
-            {
-                OSL_ENSURE(false, "XMLMetaImportContext::EndElement: iae");
-            }
-        }
-    }
-#endif
 }
 
 SvXMLImportContext * XMLMetaImportContextBase::CreateChildContext(
             sal_uInt16 i_nPrefix, const OUString& i_rLocalName,
             const Reference< xml::sax::XAttributeList > & i_xAttrList )
 {
-    const SvXMLTokenMap& rTokenMap =
-        GetImport().GetTextImport()->GetTextPElemTokenMap();
-    sal_uInt16 nToken = rTokenMap.Get( i_nPrefix, i_rLocalName );
+    const SvXMLTokenMap& rTokenMap(
+        GetImport().GetTextImport()->GetTextPElemTokenMap() );
+    const sal_uInt16 nToken( rTokenMap.Get( i_nPrefix, i_rLocalName ) );
 
     return XMLImpSpanContext_Impl::CreateChildContext( GetImport(), i_nPrefix,
         i_rLocalName, i_xAttrList, nToken, m_rHints, m_rIgnoreLeadingSpace );
@@ -812,8 +830,7 @@ void XMLMetaImportContextBase::Characters( const OUString& i_rChars )
 void XMLMetaImportContextBase::ProcessAttribute(sal_uInt16 const i_nPrefix,
     OUString const & i_rLocalName, OUString const & i_rValue)
 {
-    if ( (XML_NAMESPACE_XML == i_nPrefix) &&
-         IsXMLToken(i_rLocalName, XML_ID)   )
+    if ( (XML_NAMESPACE_XML == i_nPrefix) && IsXMLToken(i_rLocalName, XML_ID) )
     {
         m_XmlId = i_rValue;
     }
@@ -822,9 +839,7 @@ void XMLMetaImportContextBase::ProcessAttribute(sal_uInt16 const i_nPrefix,
 
 // ---------------------------------------------------------------------
 
-/** text:meta
-//FIXME not tested
- */
+/** text:meta */
 class XMLMetaImportContext : public XMLMetaImportContextBase
 {
     // RDFa
@@ -839,9 +854,8 @@ public:
 
     XMLMetaImportContext(
         SvXMLImport& i_rImport,
-        sal_uInt16 i_nPrefix,
+        const sal_uInt16 i_nPrefix,
         const OUString& i_rLocalName,
-        const Reference< xml::sax::XAttributeList > & i_xAttrList,
         XMLHints_Impl& i_rHints,
         sal_Bool & i_rIgnoreLeadingSpace );
 
@@ -855,13 +869,12 @@ TYPEINIT1( XMLMetaImportContext, XMLMetaImportContextBase );
 
 XMLMetaImportContext::XMLMetaImportContext(
         SvXMLImport& i_rImport,
-        sal_uInt16 i_nPrefix,
+        const sal_uInt16 i_nPrefix,
         const OUString& i_rLocalName,
-        const Reference< xml::sax::XAttributeList > & i_xAttrList,
         XMLHints_Impl& i_rHints,
         sal_Bool & i_rIgnoreLeadingSpace )
     : XMLMetaImportContextBase( i_rImport, i_nPrefix, i_rLocalName,
-            i_xAttrList, i_rHints, i_rIgnoreLeadingSpace )
+            i_rHints, i_rIgnoreLeadingSpace )
     , m_bHaveAbout(false)
 {
 }
@@ -929,9 +942,7 @@ void XMLMetaImportContext::InsertMeta(
 
 // ---------------------------------------------------------------------
 
-/** text:meta-field
-//FIXME not tested
- */
+/** text:meta-field */
 class XMLMetaFieldImportContext : public XMLMetaImportContextBase
 {
     OUString m_DataStyleName;
@@ -941,9 +952,8 @@ public:
 
     XMLMetaFieldImportContext(
         SvXMLImport& i_rImport,
-        sal_uInt16 i_nPrefix,
+        const sal_uInt16 i_nPrefix,
         const OUString& i_rLocalName,
-        const Reference< xml::sax::XAttributeList > & i_xAttrList,
         XMLHints_Impl& i_rHints,
         sal_Bool & i_rIgnoreLeadingSpace );
 
@@ -957,21 +967,20 @@ TYPEINIT1( XMLMetaFieldImportContext, XMLMetaImportContextBase );
 
 XMLMetaFieldImportContext::XMLMetaFieldImportContext(
         SvXMLImport& i_rImport,
-        sal_uInt16 i_nPrefix,
+        const sal_uInt16 i_nPrefix,
         const OUString& i_rLocalName,
-        const Reference< xml::sax::XAttributeList > & i_xAttrList,
         XMLHints_Impl& i_rHints,
         sal_Bool & i_rIgnoreLeadingSpace )
     : XMLMetaImportContextBase( i_rImport, i_nPrefix, i_rLocalName,
-            i_xAttrList, i_rHints, i_rIgnoreLeadingSpace )
+            i_rHints, i_rIgnoreLeadingSpace )
 {
 }
 
 void XMLMetaFieldImportContext::ProcessAttribute(sal_uInt16 const i_nPrefix,
     OUString const & i_rLocalName, OUString const & i_rValue)
 {
-    if( XML_NAMESPACE_STYLE == i_nPrefix &&
-        IsXMLToken( i_rLocalName, XML_DATA_STYLE_NAME ) )
+    if ( XML_NAMESPACE_STYLE == i_nPrefix &&
+         IsXMLToken( i_rLocalName, XML_DATA_STYLE_NAME ) )
     {
         m_DataStyleName = i_rValue;
     }
@@ -1811,18 +1820,15 @@ SvXMLImportContext *XMLImpSpanContext_Impl::CreateChildContext(
             sal_False);
         break;
 
-// FIXME: should test before enabling...
-#if 0
     case XML_TOK_TEXT_META:
         pContext = new XMLMetaImportContext(rImport, nPrefix, rLocalName,
-            xAttrList, rHints, rIgnoreLeadingSpace );
+            rHints, rIgnoreLeadingSpace );
         break;
 
     case XML_TOK_TEXT_META_FIELD:
         pContext = new XMLMetaFieldImportContext(rImport, nPrefix, rLocalName,
-            xAttrList, rHints, rIgnoreLeadingSpace );
+            rHints, rIgnoreLeadingSpace );
         break;
-#endif
 
     default:
         // none of the above? then it's probably  a text field!
@@ -2190,17 +2196,6 @@ XMLParaContext::~XMLParaContext()
                                               pHHint->GetEventsContext() );
                 }
                 break;
-            case XML_HINT_RUBY:
-                {
-                    const XMLRubyHint_Impl *pRHint =
-                        (const XMLRubyHint_Impl *)pHint;
-                    xTxtImport->SetRuby( GetImport(),
-                                         xAttrCursor,
-                                         pRHint->GetStyleName(),
-                                         pRHint->GetTextStyleName(),
-                                         pRHint->GetText() );
-                }
-                break;
             case XML_HINT_INDEX_MARK:
                 {
                     Reference<beans::XPropertySet> xMark(
@@ -2341,7 +2336,6 @@ XMLNumberedParaContext::XMLNumberedParaContext(
     m_xNumRules()
 {
     ::rtl::OUString StyleName;
-    bool ContinuteNumbering(false);
 
     const SvXMLTokenMap& rTokenMap(
         i_rImport.GetTextImport()->GetTextNumberedParagraphAttrTokenMap() );
@@ -2378,8 +2372,8 @@ XMLNumberedParaContext::XMLNumberedParaContext(
                 StyleName = rValue;
                 break;
             case XML_TOK_TEXT_NUMBERED_PARAGRAPH_CONTINUE_NUMBERING:
-                ContinuteNumbering = IsXMLToken(rValue, XML_TRUE);
-// ??? what in Fred's name is this supposed to do?
+                // this attribute is deprecated
+//                ContinuteNumbering = IsXMLToken(rValue, XML_TRUE);
                 break;
             case XML_TOK_TEXT_NUMBERED_PARAGRAPH_START_VALUE:
                 {
diff --git a/xmloff/source/text/txtparaimphint.hxx b/xmloff/source/text/txtparaimphint.hxx
index 2012764e38b7..f3c8da0bcf03 100644
--- a/xmloff/source/text/txtparaimphint.hxx
+++ b/xmloff/source/text/txtparaimphint.hxx
@@ -49,7 +49,6 @@ using namespace ::xmloff::token;
 #define XML_HINT_STYLE 1
 #define XML_HINT_REFERENCE 2
 #define XML_HINT_HYPERLINK 3
-#define XML_HINT_RUBY 4
 #define XML_HINT_INDEX_MARK 5
 #define XML_HINT_TEXT_FRAME 6
 // --> DVO, OD 2004-07-14 #i26791#
@@ -209,28 +208,6 @@ public:
     const OUString& GetID() const { return sID; }
 };
 
-class XMLRubyHint_Impl : public XMLHint_Impl
-{
-    OUString                 sStyleName;
-    OUString                 sTextStyleName;
-    OUString                 sText;
-
-public:
-
-    XMLRubyHint_Impl( const Reference < XTextRange > & rPos ) :
-        XMLHint_Impl( XML_HINT_RUBY, rPos, rPos )
-    {
-    }
-
-    virtual ~XMLRubyHint_Impl() {}
-
-    void SetStyleName( const OUString& s ) { sStyleName = s; }
-    const OUString& GetStyleName() const { return sStyleName; }
-    void SetTextStyleName( const OUString& s ) { sTextStyleName = s; }
-    const OUString& GetTextStyleName() const { return sTextStyleName; }
-    void AppendText( const OUString& s ) { sText += s; }
-    const OUString& GetText() const { return sText; }
-};
 
 class XMLTextFrameHint_Impl : public XMLHint_Impl
 {
author	Jens-Heiner Rechtien <hr@openoffice.org>	2010-01-28 19:15:06 +0000
committer	Jens-Heiner Rechtien <hr@openoffice.org>	2010-01-28 19:15:06 +0000
commit	119da1585819ab945cf07866c0185b7e63d691fa (patch)
tree	a8d7eecb5fa04157b0764b336d621860a9cafbe5 /xmloff/source
parent	04b74d9eadff586cab293db3cd473108ca1d5827 (diff)
parent	ab33e14647ada2a32624fa39ec0ddbbbdc694df5 (diff)