LCOV - code coverage report
Current view: top level - libreoffice/xmloff/source/text - txtparae.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 612 1826 33.5 %
Date: 2012-12-27 Functions: 52 82 63.4 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include <xmloff/unointerfacetouniqueidentifiermapper.hxx>
      21             : #include <tools/debug.hxx>
      22             : #include <rtl/ustrbuf.hxx>
      23             : #include <sal/types.h>
      24             : 
      25             : #include <vector>
      26             : #include <list>
      27             : #include <boost/unordered_map.hpp>
      28             : 
      29             : #include <com/sun/star/lang/XServiceInfo.hpp>
      30             : #include <com/sun/star/container/XEnumerationAccess.hpp>
      31             : #include <com/sun/star/container/XEnumeration.hpp>
      32             : #include <com/sun/star/container/XIndexReplace.hpp>
      33             : #include <com/sun/star/beans/XPropertySet.hpp>
      34             : #include <com/sun/star/beans/XMultiPropertySet.hpp>
      35             : #include <com/sun/star/beans/XPropertyState.hpp>
      36             : #include <com/sun/star/text/XTextDocument.hpp>
      37             : #include <com/sun/star/text/XTextSectionsSupplier.hpp>
      38             : #include <com/sun/star/text/XTextTablesSupplier.hpp>
      39             : #include <com/sun/star/text/XNumberingRulesSupplier.hpp>
      40             : #include <com/sun/star/text/XChapterNumberingSupplier.hpp>
      41             : #include <com/sun/star/text/XTextTable.hpp>
      42             : #include <com/sun/star/text/XText.hpp>
      43             : #include <com/sun/star/text/XTextContent.hpp>
      44             : #include <com/sun/star/text/XTextRange.hpp>
      45             : #include <com/sun/star/text/XTextField.hpp>
      46             : #include <com/sun/star/text/XFootnote.hpp>
      47             : #include <com/sun/star/container/XNamed.hpp>
      48             : #include <com/sun/star/container/XContentEnumerationAccess.hpp>
      49             : #include <com/sun/star/text/XTextFrame.hpp>
      50             : #include <com/sun/star/container/XNameAccess.hpp>
      51             : #include <com/sun/star/text/SizeType.hpp>
      52             : #include <com/sun/star/text/HoriOrientation.hpp>
      53             : #include <com/sun/star/text/VertOrientation.hpp>
      54             : #include <com/sun/star/text/TextContentAnchorType.hpp>
      55             : #include <com/sun/star/text/XTextFramesSupplier.hpp>
      56             : #include <com/sun/star/text/XTextGraphicObjectsSupplier.hpp>
      57             : #include <com/sun/star/text/XTextEmbeddedObjectsSupplier.hpp>
      58             : #include <com/sun/star/drawing/XDrawPageSupplier.hpp>
      59             : #include <com/sun/star/document/XEmbeddedObjectSupplier.hpp>
      60             : #include <com/sun/star/document/XEventsSupplier.hpp>
      61             : #include <com/sun/star/document/XRedlinesSupplier.hpp>
      62             : 
      63             : #include <com/sun/star/text/XBookmarksSupplier.hpp>
      64             : #include <com/sun/star/text/XFormField.hpp>
      65             : 
      66             : #include <com/sun/star/text/XTextSection.hpp>
      67             : #include <com/sun/star/text/SectionFileLink.hpp>
      68             : #include <com/sun/star/drawing/XShape.hpp>
      69             : #include <com/sun/star/text/XTextShapesSupplier.hpp>
      70             : 
      71             : #include <com/sun/star/style/XAutoStylesSupplier.hpp>
      72             : #include <com/sun/star/style/XAutoStyleFamily.hpp>
      73             : #include <com/sun/star/text/XTextFieldsSupplier.hpp>
      74             : #include <com/sun/star/text/XFootnotesSupplier.hpp>
      75             : #include <com/sun/star/text/XEndnotesSupplier.hpp>
      76             : #include <com/sun/star/drawing/XControlShape.hpp>
      77             : #include <com/sun/star/util/DateTime.hpp>
      78             : 
      79             : #include <sax/tools/converter.hxx>
      80             : 
      81             : #include "xmloff/xmlnmspe.hxx"
      82             : #include <xmloff/xmlaustp.hxx>
      83             : #include <xmloff/families.hxx>
      84             : #include "txtexppr.hxx"
      85             : #include <xmloff/xmlnumfe.hxx>
      86             : #include <xmloff/xmlnume.hxx>
      87             : #include <xmloff/xmluconv.hxx>
      88             : #include "XMLAnchorTypePropHdl.hxx"
      89             : #include "xexptran.hxx"
      90             : #include <xmloff/ProgressBarHelper.hxx>
      91             : #include <xmloff/nmspmap.hxx>
      92             : #include <xmloff/xmlexp.hxx>
      93             : #include "txtflde.hxx"
      94             : #include <xmloff/txtprmap.hxx>
      95             : #include "XMLImageMapExport.hxx"
      96             : #include "XMLTextNumRuleInfo.hxx"
      97             : #include "xmloff/XMLTextListAutoStylePool.hxx"
      98             : #include <xmloff/txtparae.hxx>
      99             : #include "XMLSectionExport.hxx"
     100             : #include "XMLIndexMarkExport.hxx"
     101             : #include <xmloff/XMLEventExport.hxx>
     102             : #include "XMLRedlineExport.hxx"
     103             : #include "MultiPropertySetHelper.hxx"
     104             : #include <xmloff/formlayerexport.hxx>
     105             : #include "XMLTextCharStyleNamesElementExport.hxx"
     106             : #include <comphelper/stlunosequence.hxx>
     107             : 
     108             : #include <xmloff/odffields.hxx>
     109             : #include <com/sun/star/embed/ElementModes.hpp>
     110             : #include <com/sun/star/embed/XTransactedObject.hpp>
     111             : #include <com/sun/star/document/XStorageBasedDocument.hpp>
     112             : #include <txtlists.hxx>
     113             : #include <com/sun/star/rdf/XMetadatable.hpp>
     114             : 
     115             : using ::rtl::OUString;
     116             : using ::rtl::OUStringBuffer;
     117             : 
     118             : using namespace ::std;
     119             : using namespace ::com::sun::star;
     120             : using namespace ::com::sun::star::uno;
     121             : using namespace ::com::sun::star::lang;
     122             : using namespace ::com::sun::star::beans;
     123             : using namespace ::com::sun::star::container;
     124             : using namespace ::com::sun::star::text;
     125             : using namespace ::com::sun::star::style;
     126             : using namespace ::com::sun::star::util;
     127             : using namespace ::com::sun::star::drawing;
     128             : using namespace ::com::sun::star::document;
     129             : using namespace ::com::sun::star::frame;
     130             : using namespace ::xmloff;
     131             : using namespace ::xmloff::token;
     132             : 
     133             : namespace
     134             : {
     135          96 :     class TextContentSet
     136             :     {
     137             :         public:
     138             :             typedef Reference<XTextContent> text_content_ref_t;
     139             :             typedef list<text_content_ref_t> contents_t;
     140             :             typedef back_insert_iterator<contents_t> inserter_t;
     141             :             typedef contents_t::const_iterator const_iterator_t;
     142             : 
     143           0 :             inserter_t getInserter()
     144           0 :                 { return back_insert_iterator<contents_t>(m_vTextContents); };
     145           8 :             const_iterator_t getBegin() const
     146           8 :                 { return m_vTextContents.begin(); };
     147           8 :             const_iterator_t getEnd() const
     148           8 :                 { return m_vTextContents.end(); };
     149             : 
     150             :         private:
     151             :             contents_t m_vTextContents;
     152             :     };
     153             : 
     154             :     struct FrameRefHash
     155             :         : public unary_function<Reference<XTextFrame>, size_t>
     156             :     {
     157           0 :         size_t operator()(const Reference<XTextFrame> xFrame) const
     158           0 :             { return sal::static_int_cast<size_t>(reinterpret_cast<sal_uIntPtr>(xFrame.get())); }
     159             :     };
     160             : 
     161           0 :     static bool lcl_TextContentsUnfiltered(const Reference<XTextContent>&)
     162           0 :         { return true; };
     163             : 
     164           0 :     static bool lcl_ShapeFilter(const Reference<XTextContent>& xTxtContent)
     165             :     {
     166           0 :         static const OUString sTextFrameService("com.sun.star.text.TextFrame");
     167           0 :         static const OUString sTextGraphicService("com.sun.star.text.TextGraphicObject");
     168           0 :         static const OUString sTextEmbeddedService("com.sun.star.text.TextEmbeddedObject");
     169           0 :         Reference<XShape> xShape(xTxtContent, UNO_QUERY);
     170           0 :         if(!xShape.is())
     171           0 :             return false;
     172           0 :         Reference<XServiceInfo> xServiceInfo(xTxtContent, UNO_QUERY);
     173           0 :         if(xServiceInfo->supportsService(sTextFrameService) ||
     174           0 :             xServiceInfo->supportsService(sTextGraphicService) ||
     175           0 :             xServiceInfo->supportsService(sTextEmbeddedService) )
     176           0 :             return false;
     177           0 :         return true;
     178             :     };
     179             : 
     180          48 :     class BoundFrames
     181             :     {
     182             :         public:
     183             :             typedef bool (*filter_t)(const Reference<XTextContent>&);
     184          16 :             BoundFrames(
     185             :                 const Reference<XEnumerationAccess> xEnumAccess,
     186             :                 const filter_t& rFilter)
     187          16 :                 : m_xEnumAccess(xEnumAccess)
     188             :             {
     189          16 :                 Fill(rFilter);
     190          16 :             };
     191          32 :             BoundFrames()
     192          32 :                 {};
     193           8 :             const TextContentSet* GetPageBoundContents() const
     194           8 :                 { return &m_vPageBounds; };
     195           0 :             const TextContentSet* GetFrameBoundContents(const Reference<XTextFrame>& rParentFrame) const
     196             :             {
     197           0 :                 framebound_map_t::const_iterator it = m_vFrameBoundsOf.find(rParentFrame);
     198           0 :                 if(it == m_vFrameBoundsOf.end())
     199           0 :                     return NULL;
     200           0 :                 return &(it->second);
     201             :             };
     202          10 :             Reference<XEnumeration> createEnumeration() const
     203             :             {
     204          10 :                 if(!m_xEnumAccess.is())
     205           0 :                     return Reference<XEnumeration>();
     206          10 :                 return m_xEnumAccess->createEnumeration();
     207             :             };
     208             : 
     209             :         private:
     210             :             typedef boost::unordered_map<
     211             :                 Reference<XTextFrame>,
     212             :                 TextContentSet,
     213             :                 FrameRefHash> framebound_map_t;
     214             :             TextContentSet m_vPageBounds;
     215             :             framebound_map_t m_vFrameBoundsOf;
     216             :             const Reference<XEnumerationAccess> m_xEnumAccess;
     217             :             void Fill(const filter_t& rFilter);
     218             :     };
     219             : 
     220           0 :     class FieldParamExporter
     221             :     {
     222             :         public:
     223           0 :             FieldParamExporter(SvXMLExport* const pExport, Reference<XNameContainer> xFieldParams)
     224             :                 : m_pExport(pExport)
     225           0 :                 , m_xFieldParams(xFieldParams)
     226           0 :                 { };
     227             :             void Export();
     228             : 
     229             :         private:
     230             :             SvXMLExport* const m_pExport;
     231             :             const Reference<XNameContainer> m_xFieldParams;
     232             : 
     233             :             void ExportParameter(const OUString& sKey, const OUString& sValue);
     234             :     };
     235             : }
     236             : 
     237             : namespace xmloff
     238             : {
     239           8 :     class BoundFrameSets
     240             :     {
     241             :         public:
     242             :             BoundFrameSets(const Reference<XInterface> xModel);
     243           4 :             const BoundFrames* GetTexts() const
     244           4 :                 { return m_pTexts.get(); };
     245           4 :             const BoundFrames* GetGraphics() const
     246           4 :                 { return m_pGraphics.get(); };
     247           4 :             const BoundFrames* GetEmbeddeds() const
     248           4 :                 { return m_pEmbeddeds.get(); };
     249           6 :             const BoundFrames* GetShapes() const
     250           6 :                 { return m_pShapes.get(); };
     251             :         private:
     252             :             SAL_WNODEPRECATED_DECLARATIONS_PUSH
     253             :             auto_ptr<BoundFrames> m_pTexts;
     254             :             auto_ptr<BoundFrames> m_pGraphics;
     255             :             auto_ptr<BoundFrames> m_pEmbeddeds;
     256             :             auto_ptr<BoundFrames> m_pShapes;
     257             :             SAL_WNODEPRECATED_DECLARATIONS_POP
     258             :     };
     259             : }
     260             : 
     261             : #ifdef DBG_UTIL
     262             : static int txtparae_bContainsIllegalCharacters = sal_False;
     263             : #endif
     264             : 
     265             : // The following map shows which property values are required:
     266             : //
     267             : // property                     auto style pass     export
     268             : // --------------------------------------------------------
     269             : // ParaStyleName                if style exists     always
     270             : // ParaConditionalStyleName     if style exists     always
     271             : // NumberingRules               if style exists     always
     272             : // TextSection                  always              always
     273             : // ParaChapterNumberingLevel    never               always
     274             : // NumberingIsNumber            never               always
     275             : 
     276             : // The conclusion is that for auto styles the first three properties
     277             : // should be queried using a multi property set if, and only if, an
     278             : // auto style needs to be exported. TextSection should be queried by
     279             : // an individual call to getPropertyvalue, because this seems to be
     280             : // less expensive than querying the first three properties if they aren't
     281             : // required.
     282             : 
     283             : // For the export pass all properties can be queried using a multi property
     284             : // set.
     285             : 
     286             : static const sal_Char* aParagraphPropertyNamesAuto[] =
     287             : {
     288             :     "NumberingRules",
     289             :     "ParaConditionalStyleName",
     290             :     "ParaStyleName",
     291             :     NULL
     292             : };
     293             : 
     294             : enum eParagraphPropertyNamesEnumAuto
     295             : {
     296             :     NUMBERING_RULES_AUTO = 0,
     297             :     PARA_CONDITIONAL_STYLE_NAME_AUTO = 1,
     298             :     PARA_STYLE_NAME_AUTO = 2
     299             : };
     300             : 
     301             : static const sal_Char* aParagraphPropertyNames[] =
     302             : {
     303             :     "NumberingIsNumber",
     304             :     "NumberingStyleName",
     305             :     "OutlineLevel",
     306             :     "ParaConditionalStyleName",
     307             :     "ParaStyleName",
     308             :     "TextSection",
     309             :     NULL
     310             : };
     311             : 
     312             : enum eParagraphPropertyNamesEnum
     313             : {
     314             :     NUMBERING_IS_NUMBER = 0,
     315             :     PARA_NUMBERING_STYLENAME = 1,
     316             :     PARA_OUTLINE_LEVEL=2,
     317             :     PARA_CONDITIONAL_STYLE_NAME = 3,
     318             :     PARA_STYLE_NAME = 4,
     319             :     TEXT_SECTION = 5
     320             : };
     321             : 
     322          16 : void BoundFrames::Fill(const filter_t& rFilter)
     323             : {
     324          16 :     if(!m_xEnumAccess.is())
     325             :         return;
     326          16 :     const Reference< XEnumeration > xEnum = m_xEnumAccess->createEnumeration();
     327          16 :     if(!xEnum.is())
     328             :         return;
     329          16 :     const OUString our_sAnchorType("AnchorType");
     330          16 :     const OUString our_sAnchorFrame("AnchorFrame");
     331          32 :     while(xEnum->hasMoreElements())
     332             :     {
     333           0 :         Reference<XPropertySet> xPropSet(xEnum->nextElement(), UNO_QUERY);
     334           0 :         Reference<XTextContent> xTextContent(xPropSet, UNO_QUERY);
     335           0 :         if(!xPropSet.is() || !xTextContent.is())
     336           0 :             continue;
     337             :         TextContentAnchorType eAnchor;
     338           0 :         xPropSet->getPropertyValue(our_sAnchorType) >>= eAnchor;
     339           0 :         if(TextContentAnchorType_AT_PAGE != eAnchor && TextContentAnchorType_AT_FRAME != eAnchor)
     340           0 :             continue;
     341           0 :         if(!rFilter(xTextContent))
     342           0 :             continue;
     343             : 
     344           0 :         TextContentSet::inserter_t pInserter = m_vPageBounds.getInserter();
     345           0 :         if(TextContentAnchorType_AT_FRAME == eAnchor)
     346             :         {
     347             :             Reference<XTextFrame> xAnchorTxtFrame(
     348           0 :                 xPropSet->getPropertyValue(our_sAnchorFrame),
     349           0 :                 uno::UNO_QUERY);
     350           0 :             pInserter = m_vFrameBoundsOf[xAnchorTxtFrame].getInserter();
     351             :         }
     352           0 :         *pInserter++ = xTextContent;
     353          16 :     }
     354             : }
     355             : 
     356           8 : BoundFrameSets::BoundFrameSets(const Reference<XInterface> xModel)
     357           0 :     : m_pTexts(new BoundFrames())
     358           0 :     , m_pGraphics(new BoundFrames())
     359           0 :     , m_pEmbeddeds(new BoundFrames())
     360           8 :     , m_pShapes(new BoundFrames())
     361             : {
     362           8 :     const Reference<XTextFramesSupplier> xTFS(xModel, UNO_QUERY);
     363           8 :     const Reference<XTextGraphicObjectsSupplier> xGOS(xModel, UNO_QUERY);
     364           8 :     const Reference<XTextEmbeddedObjectsSupplier> xEOS(xModel, UNO_QUERY);
     365           8 :     const Reference<XDrawPageSupplier> xDPS(xModel, UNO_QUERY);
     366           8 :     if(xTFS.is())
     367             :         m_pTexts = auto_ptr<BoundFrames>(new BoundFrames(
     368           4 :             Reference<XEnumerationAccess>(xTFS->getTextFrames(), UNO_QUERY),
     369           4 :             &lcl_TextContentsUnfiltered));
     370           8 :     if(xGOS.is())
     371             :         m_pGraphics = auto_ptr<BoundFrames>(new BoundFrames(
     372           4 :             Reference<XEnumerationAccess>(xGOS->getGraphicObjects(), UNO_QUERY),
     373           4 :             &lcl_TextContentsUnfiltered));
     374           8 :     if(xEOS.is())
     375             :         m_pEmbeddeds = auto_ptr<BoundFrames>(new BoundFrames(
     376           4 :             Reference<XEnumerationAccess>(xEOS->getEmbeddedObjects(), UNO_QUERY),
     377           4 :             &lcl_TextContentsUnfiltered));
     378           8 :     if(xDPS.is())
     379             :         m_pShapes = auto_ptr<BoundFrames>(new BoundFrames(
     380           4 :             Reference<XEnumerationAccess>(xDPS->getDrawPage(), UNO_QUERY),
     381           4 :             &lcl_ShapeFilter));
     382           8 : };
     383             : 
     384           0 : void FieldParamExporter::Export()
     385             : {
     386           0 :     const Type aStringType = ::getCppuType((OUString*)0);
     387           0 :     const Type aBoolType = ::getCppuType((sal_Bool*)0);
     388           0 :     const Type aSeqType = ::getCppuType((Sequence<OUString>*)0);
     389           0 :     const Type aIntType = ::getCppuType((sal_Int32*)0);
     390           0 :     Sequence<OUString> vParameters(m_xFieldParams->getElementNames());
     391           0 :     for(const OUString* pCurrent=::comphelper::stl_begin(vParameters); pCurrent!=::comphelper::stl_end(vParameters); ++pCurrent)
     392             :     {
     393           0 :         const Any aValue = m_xFieldParams->getByName(*pCurrent);
     394           0 :         const Type aValueType = aValue.getValueType();
     395           0 :         if(aValueType == aStringType)
     396             :         {
     397           0 :             OUString sValue;
     398           0 :             aValue >>= sValue;
     399           0 :             ExportParameter(*pCurrent,sValue);
     400             : 
     401           0 :             if ( pCurrent->equalsAscii( ODF_OLE_PARAM ) )
     402             :             {
     403             :                 // Save the OLE object
     404           0 :                 Reference< embed::XStorage > xTargetStg = m_pExport->GetTargetStorage();
     405           0 :                 Reference< embed::XStorage > xDstStg = xTargetStg->openStorageElement(
     406           0 :                         rtl::OUString("OLELinks"), embed::ElementModes::WRITE );
     407             : 
     408           0 :                 if ( !xDstStg->hasByName( sValue ) ) {
     409             :                     Reference< XStorageBasedDocument > xStgDoc (
     410           0 :                             m_pExport->GetModel( ), UNO_QUERY );
     411           0 :                     Reference< embed::XStorage > xDocStg = xStgDoc->getDocumentStorage();
     412           0 :                     Reference< embed::XStorage > xOleStg = xDocStg->openStorageElement(
     413           0 :                             rtl::OUString("OLELinks"), embed::ElementModes::READ );
     414             : 
     415           0 :                     xOleStg->copyElementTo( sValue, xDstStg, sValue );
     416           0 :                     Reference< embed::XTransactedObject > xTransact( xDstStg, UNO_QUERY );
     417           0 :                     if ( xTransact.is( ) )
     418           0 :                         xTransact->commit( );
     419           0 :                 }
     420           0 :             }
     421             :         }
     422           0 :         else if(aValueType == aBoolType)
     423             :         {
     424           0 :             sal_Bool bValue = false;
     425           0 :             aValue >>= bValue;
     426           0 :             ExportParameter(*pCurrent, (bValue ? OUString("true" ) : OUString("false")) );
     427             :         }
     428           0 :         else if(aValueType == aSeqType)
     429             :         {
     430           0 :             Sequence<OUString> vValue;
     431           0 :             aValue >>= vValue;
     432           0 :             for(OUString* pSeqCurrent = ::comphelper::stl_begin(vValue); pSeqCurrent != ::comphelper::stl_end(vValue); ++pSeqCurrent)
     433             :             {
     434           0 :                 ExportParameter(*pCurrent, *pSeqCurrent);
     435           0 :             }
     436             :         }
     437           0 :         else if(aValueType == aIntType)
     438             :         {
     439           0 :             sal_Int32 nValue = 0;
     440           0 :             aValue >>= nValue;
     441           0 :             ExportParameter(*pCurrent, OUStringBuffer().append(nValue).makeStringAndClear());
     442             :         }
     443           0 :     }
     444           0 : }
     445             : 
     446           0 : void FieldParamExporter::ExportParameter(const OUString& sKey, const OUString& sValue)
     447             : {
     448           0 :     m_pExport->AddAttribute(XML_NAMESPACE_FIELD, XML_NAME, sKey);
     449           0 :     m_pExport->AddAttribute(XML_NAMESPACE_FIELD, XML_VALUE, sValue);
     450           0 :     m_pExport->StartElement(XML_NAMESPACE_FIELD, XML_PARAM, sal_False);
     451           0 :     m_pExport->EndElement(XML_NAMESPACE_FIELD, XML_PARAM, sal_False);
     452           0 : }
     453             : 
     454          84 : void XMLTextParagraphExport::Add( sal_uInt16 nFamily,
     455             :                                   const Reference < XPropertySet > & rPropSet,
     456             :                                   const XMLPropertyState** ppAddStates, bool bDontSeek )
     457             : {
     458          84 :     UniReference < SvXMLExportPropertyMapper > xPropMapper;
     459          84 :     switch( nFamily )
     460             :     {
     461             :     case XML_STYLE_FAMILY_TEXT_PARAGRAPH:
     462           3 :         xPropMapper = GetParaPropMapper();
     463           3 :         break;
     464             :     case XML_STYLE_FAMILY_TEXT_TEXT:
     465          81 :         xPropMapper = GetTextPropMapper();
     466          81 :         break;
     467             :     case XML_STYLE_FAMILY_TEXT_FRAME:
     468           0 :         xPropMapper = GetAutoFramePropMapper();
     469           0 :         break;
     470             :     case XML_STYLE_FAMILY_TEXT_SECTION:
     471           0 :         xPropMapper = GetSectionPropMapper();
     472           0 :         break;
     473             :     case XML_STYLE_FAMILY_TEXT_RUBY:
     474           0 :         xPropMapper = GetRubyPropMapper();
     475           0 :         break;
     476             :     }
     477             :     DBG_ASSERT( xPropMapper.is(), "There is the property mapper?" );
     478             : 
     479             :     vector< XMLPropertyState > xPropStates =
     480          84 :             xPropMapper->Filter( rPropSet );
     481             : 
     482          84 :     if( ppAddStates )
     483             :     {
     484           0 :         while( *ppAddStates )
     485             :         {
     486           0 :             xPropStates.push_back( **ppAddStates );
     487           0 :             ppAddStates++;
     488             :         }
     489             :     }
     490             : 
     491          84 :     if( !xPropStates.empty() )
     492             :     {
     493           3 :         Reference< XPropertySetInfo > xPropSetInfo(rPropSet->getPropertySetInfo());
     494           3 :         OUString sParent, sCondParent;
     495           3 :         sal_uInt16 nIgnoreProps = 0;
     496           3 :         switch( nFamily )
     497             :         {
     498             :         case XML_STYLE_FAMILY_TEXT_PARAGRAPH:
     499           3 :             if( xPropSetInfo->hasPropertyByName( sParaStyleName ) )
     500             :             {
     501           3 :                 rPropSet->getPropertyValue( sParaStyleName ) >>= sParent;
     502             :             }
     503           3 :             if( xPropSetInfo->hasPropertyByName( sParaConditionalStyleName ) )
     504             :             {
     505           3 :                 rPropSet->getPropertyValue( sParaConditionalStyleName ) >>= sCondParent;
     506             :             }
     507           3 :             if( xPropSetInfo->hasPropertyByName( sNumberingRules ) )
     508             :             {
     509           0 :                 Reference < XIndexReplace > xNumRule(rPropSet->getPropertyValue( sNumberingRules ), uno::UNO_QUERY);
     510           0 :                 if( xNumRule.is() && xNumRule->getCount() )
     511             :                 {
     512           0 :                     Reference < XNamed > xNamed( xNumRule, UNO_QUERY );
     513           0 :                     OUString sName;
     514           0 :                     if( xNamed.is() )
     515           0 :                         sName = xNamed->getName();
     516           0 :                     sal_Bool bAdd = sName.isEmpty();
     517           0 :                     if( !bAdd )
     518             :                     {
     519             :                         Reference < XPropertySet > xNumPropSet( xNumRule,
     520           0 :                                                                 UNO_QUERY );
     521           0 :                         const OUString sIsAutomatic( "IsAutomatic"  );
     522           0 :                         if( xNumPropSet.is() &&
     523           0 :                             xNumPropSet->getPropertySetInfo()
     524           0 :                                        ->hasPropertyByName( sIsAutomatic ) )
     525             :                         {
     526           0 :                             bAdd = *(sal_Bool *)xNumPropSet->getPropertyValue( sIsAutomatic ).getValue();
     527             :                             // Check on outline style (#i73361#)
     528           0 :                             const OUString sNumberingIsOutline( "NumberingIsOutline"  );
     529           0 :                             if ( bAdd &&
     530           0 :                                  xNumPropSet->getPropertySetInfo()
     531           0 :                                            ->hasPropertyByName( sNumberingIsOutline ) )
     532             :                             {
     533           0 :                                 bAdd = !(*(sal_Bool *)xNumPropSet->getPropertyValue( sNumberingIsOutline ).getValue());
     534           0 :                             }
     535             :                         }
     536             :                         else
     537             :                         {
     538           0 :                             bAdd = sal_True;
     539           0 :                         }
     540             :                     }
     541           0 :                     if( bAdd )
     542           0 :                         pListAutoPool->Add( xNumRule );
     543           0 :                 }
     544             :             }
     545           3 :             break;
     546             :         case XML_STYLE_FAMILY_TEXT_TEXT:
     547             :             {
     548             :                 // Get parent and remove hyperlinks (they aren't of interest)
     549           0 :                 UniReference< XMLPropertySetMapper > xPM(xPropMapper->getPropertySetMapper());
     550           0 :                 for( ::std::vector< XMLPropertyState >::iterator i(xPropStates.begin());
     551           0 :                       nIgnoreProps < 2 && i != xPropStates.end(); )
     552             :                 {
     553           0 :                     if( i->mnIndex == -1 )
     554             :                     {
     555           0 :                         ++i;
     556           0 :                         continue;
     557             :                     }
     558             : 
     559           0 :                     switch( xPM->GetEntryContextId(i->mnIndex) )
     560             :                     {
     561             :                     case CTF_CHAR_STYLE_NAME:
     562             :                     case CTF_HYPERLINK_URL:
     563           0 :                         i->mnIndex = -1;
     564           0 :                         nIgnoreProps++;
     565           0 :                         i = xPropStates.erase( i );
     566           0 :                         break;
     567             :                     default:
     568           0 :                         ++i;
     569           0 :                         break;
     570             :                     }
     571           0 :                 }
     572             :             }
     573           0 :             break;
     574             :         case XML_STYLE_FAMILY_TEXT_FRAME:
     575           0 :             if( xPropSetInfo->hasPropertyByName( sFrameStyleName ) )
     576             :             {
     577           0 :                 rPropSet->getPropertyValue( sFrameStyleName ) >>= sParent;
     578             :             }
     579           0 :             break;
     580             :         case XML_STYLE_FAMILY_TEXT_SECTION:
     581             :         case XML_STYLE_FAMILY_TEXT_RUBY:
     582             :             ; // section styles have no parents
     583           0 :             break;
     584             :         }
     585           3 :         if( (xPropStates.size() - nIgnoreProps) > 0 )
     586             :         {
     587           3 :             GetAutoStylePool().Add( nFamily, sParent, xPropStates, bDontSeek );
     588           3 :             if( !sCondParent.isEmpty() && sParent != sCondParent )
     589           0 :                 GetAutoStylePool().Add( nFamily, sCondParent, xPropStates );
     590           3 :         }
     591          84 :     }
     592          84 : }
     593             : 
     594           6 : static bool lcl_validPropState( const XMLPropertyState& rState )
     595             : {
     596           6 :     return rState.mnIndex != -1;
     597             : }
     598             : 
     599          13 : void XMLTextParagraphExport::Add( sal_uInt16 nFamily,
     600             :                                   MultiPropertySetHelper& rPropSetHelper,
     601             :                                   const Reference < XPropertySet > & rPropSet,
     602             :                                   const XMLPropertyState** ppAddStates)
     603             : {
     604          13 :     UniReference < SvXMLExportPropertyMapper > xPropMapper;
     605          13 :     switch( nFamily )
     606             :     {
     607             :     case XML_STYLE_FAMILY_TEXT_PARAGRAPH:
     608          13 :         xPropMapper = GetParaPropMapper();
     609          13 :         break;
     610             :     }
     611             :     DBG_ASSERT( xPropMapper.is(), "There is the property mapper?" );
     612             : 
     613          13 :     vector< XMLPropertyState > xPropStates(xPropMapper->Filter( rPropSet ));
     614          13 :     if( ppAddStates )
     615             :     {
     616           0 :         while( *ppAddStates )
     617             :         {
     618           0 :             xPropStates.push_back( **ppAddStates );
     619           0 :             ++ppAddStates;
     620             :         }
     621             :     }
     622             : 
     623          13 :     if( rPropSetHelper.hasProperty( NUMBERING_RULES_AUTO ) )
     624             :     {
     625             :         Reference < XIndexReplace > xNumRule(rPropSetHelper.getValue( NUMBERING_RULES_AUTO,
     626          13 :             rPropSet, sal_True ), uno::UNO_QUERY);
     627          13 :         if( xNumRule.is() && xNumRule->getCount() )
     628             :         {
     629           0 :             Reference < XNamed > xNamed( xNumRule, UNO_QUERY );
     630           0 :             OUString sName;
     631           0 :             if( xNamed.is() )
     632           0 :                 sName = xNamed->getName();
     633           0 :             sal_Bool bAdd = sName.isEmpty();
     634           0 :             if( !bAdd )
     635             :             {
     636             :                 Reference < XPropertySet > xNumPropSet( xNumRule,
     637           0 :                                                         UNO_QUERY );
     638           0 :                 const OUString sIsAutomatic( "IsAutomatic"  );
     639           0 :                 if( xNumPropSet.is() &&
     640           0 :                     xNumPropSet->getPropertySetInfo()
     641           0 :                                ->hasPropertyByName( sIsAutomatic ) )
     642             :                 {
     643           0 :                     bAdd = *(sal_Bool *)xNumPropSet->getPropertyValue( sIsAutomatic ).getValue();
     644             :                     // Check on outline style (#i73361#)
     645           0 :                     const OUString sNumberingIsOutline( "NumberingIsOutline"  );
     646           0 :                     if ( bAdd &&
     647           0 :                          xNumPropSet->getPropertySetInfo()
     648           0 :                                    ->hasPropertyByName( sNumberingIsOutline ) )
     649             :                     {
     650           0 :                         bAdd = !(*(sal_Bool *)xNumPropSet->getPropertyValue( sNumberingIsOutline ).getValue());
     651           0 :                     }
     652             :                 }
     653             :                 else
     654             :                 {
     655           0 :                     bAdd = sal_True;
     656           0 :                 }
     657             :             }
     658           0 :             if( bAdd )
     659           0 :                 pListAutoPool->Add( xNumRule );
     660          13 :         }
     661             :     }
     662             : 
     663          13 :     if( !xPropStates.empty() )
     664             :     {
     665           0 :         OUString sParent, sCondParent;
     666           0 :         switch( nFamily )
     667             :         {
     668             :         case XML_STYLE_FAMILY_TEXT_PARAGRAPH:
     669           0 :             if( rPropSetHelper.hasProperty( PARA_STYLE_NAME_AUTO ) )
     670             :             {
     671             :                 rPropSetHelper.getValue( PARA_STYLE_NAME_AUTO, rPropSet,
     672           0 :                                                 sal_True ) >>= sParent;
     673             :             }
     674           0 :             if( rPropSetHelper.hasProperty( PARA_CONDITIONAL_STYLE_NAME_AUTO ) )
     675             :             {
     676             :                 rPropSetHelper.getValue( PARA_CONDITIONAL_STYLE_NAME_AUTO,
     677           0 :                                                  rPropSet, sal_True ) >>= sCondParent;
     678             :             }
     679             : 
     680           0 :             break;
     681             :         }
     682             : 
     683           0 :         if( find_if( xPropStates.begin(), xPropStates.end(), lcl_validPropState ) != xPropStates.end() )
     684             :         {
     685           0 :             GetAutoStylePool().Add( nFamily, sParent, xPropStates );
     686           0 :             if( !sCondParent.isEmpty() && sParent != sCondParent )
     687           0 :                 GetAutoStylePool().Add( nFamily, sCondParent, xPropStates );
     688           0 :         }
     689          13 :     }
     690          13 : }
     691             : 
     692          20 : OUString XMLTextParagraphExport::Find(
     693             :         sal_uInt16 nFamily,
     694             :            const Reference < XPropertySet > & rPropSet,
     695             :         const OUString& rParent,
     696             :         const XMLPropertyState** ppAddStates) const
     697             : {
     698          20 :     OUString sName( rParent );
     699          20 :     UniReference < SvXMLExportPropertyMapper > xPropMapper;
     700          20 :     switch( nFamily )
     701             :     {
     702             :     case XML_STYLE_FAMILY_TEXT_PARAGRAPH:
     703          20 :         xPropMapper = GetParaPropMapper();
     704          20 :         break;
     705             :     case XML_STYLE_FAMILY_TEXT_FRAME:
     706           0 :         xPropMapper = GetAutoFramePropMapper();
     707           0 :         break;
     708             :     case XML_STYLE_FAMILY_TEXT_SECTION:
     709           0 :         xPropMapper = GetSectionPropMapper();
     710           0 :         break;
     711             :     case XML_STYLE_FAMILY_TEXT_RUBY:
     712           0 :         xPropMapper = GetRubyPropMapper();
     713           0 :         break;
     714             :     }
     715             :     DBG_ASSERT( xPropMapper.is(), "There is the property mapper?" );
     716          20 :     if( !xPropMapper.is() )
     717             :         return sName;
     718          20 :     vector< XMLPropertyState > xPropStates(xPropMapper->Filter( rPropSet ));
     719          20 :     if( ppAddStates )
     720             :     {
     721           0 :         while( *ppAddStates )
     722             :         {
     723           0 :             xPropStates.push_back( **ppAddStates );
     724           0 :             ++ppAddStates;
     725             :         }
     726             :     }
     727          20 :     if( find_if( xPropStates.begin(), xPropStates.end(), lcl_validPropState ) != xPropStates.end() )
     728           6 :         sName = GetAutoStylePool().Find( nFamily, sName, xPropStates );
     729             : 
     730          20 :     return sName;
     731             : }
     732             : 
     733          51 : OUString XMLTextParagraphExport::FindTextStyleAndHyperlink(
     734             :            const Reference < XPropertySet > & rPropSet,
     735             :         sal_Bool& rbHyperlink,
     736             :         sal_Bool& rbHasCharStyle,
     737             :         sal_Bool& rbHasAutoStyle,
     738             :         const XMLPropertyState** ppAddStates ) const
     739             : {
     740          51 :     UniReference < SvXMLExportPropertyMapper > xPropMapper(GetTextPropMapper());
     741          51 :     vector< XMLPropertyState > xPropStates(xPropMapper->Filter( rPropSet ));
     742             : 
     743             :     // Get parent and remove hyperlinks (they aren't of interest)
     744          51 :     OUString sName;
     745          51 :     rbHyperlink = rbHasCharStyle = rbHasAutoStyle = sal_False;
     746          51 :     sal_uInt16 nIgnoreProps = 0;
     747          51 :     UniReference< XMLPropertySetMapper > xPM(xPropMapper->getPropertySetMapper());
     748          51 :     ::std::vector< XMLPropertyState >::iterator aFirstDel = xPropStates.end();
     749          51 :     ::std::vector< XMLPropertyState >::iterator aSecondDel = xPropStates.end();
     750             : 
     751         204 :     for( ::std::vector< XMLPropertyState >::iterator
     752          51 :             i = xPropStates.begin();
     753         153 :          nIgnoreProps < 2 && i != xPropStates.end();
     754             :          ++i )
     755             :     {
     756           0 :         if( i->mnIndex == -1 )
     757           0 :             continue;
     758             : 
     759           0 :         switch( xPM->GetEntryContextId(i->mnIndex) )
     760             :         {
     761             :         case CTF_CHAR_STYLE_NAME:
     762           0 :             i->maValue >>= sName;
     763           0 :             i->mnIndex = -1;
     764           0 :             rbHasCharStyle = !sName.isEmpty();
     765           0 :             if( nIgnoreProps )
     766           0 :                 aSecondDel = i;
     767             :             else
     768           0 :                 aFirstDel = i;
     769           0 :             nIgnoreProps++;
     770           0 :             break;
     771             :         case CTF_HYPERLINK_URL:
     772           0 :             rbHyperlink = sal_True;
     773           0 :             i->mnIndex = -1;
     774           0 :             if( nIgnoreProps )
     775           0 :                 aSecondDel = i;
     776             :             else
     777           0 :                 aFirstDel = i;
     778           0 :             nIgnoreProps++;
     779           0 :             break;
     780             :         }
     781             :     }
     782          51 :     if( ppAddStates )
     783             :     {
     784           0 :         while( *ppAddStates )
     785             :         {
     786           0 :             xPropStates.push_back( **ppAddStates );
     787           0 :             ppAddStates++;
     788             :         }
     789             :     }
     790          51 :     if( (xPropStates.size() - nIgnoreProps) > 0L )
     791             :     {
     792             :         // erase the character style, otherwise the autostyle cannot be found!
     793             :         // erase the hyperlink, otherwise the autostyle cannot be found!
     794           0 :         if ( nIgnoreProps )
     795             :         {
     796             :             // If two elements of a vector have to be deleted,
     797             :             // we should delete the second one first.
     798           0 :             if( --nIgnoreProps )
     799           0 :                 xPropStates.erase( aSecondDel );
     800           0 :             xPropStates.erase( aFirstDel );
     801             :         }
     802           0 :         OUString sParent; // AutoStyles should not have parents!
     803           0 :         sName = GetAutoStylePool().Find( XML_STYLE_FAMILY_TEXT_TEXT, sParent, xPropStates );
     804             :         DBG_ASSERT( !sName.isEmpty(), "AutoStyle could not be found" );
     805           0 :         rbHasAutoStyle = sal_True;
     806             :     }
     807             : 
     808          51 :     return sName;
     809             : }
     810             : 
     811             : // adjustments to support lists independent from list style
     812          55 : void XMLTextParagraphExport::exportListChange(
     813             :         const XMLTextNumRuleInfo& rPrevInfo,
     814             :         const XMLTextNumRuleInfo& rNextInfo )
     815             : {
     816             :     // end a list
     817          55 :     if ( rPrevInfo.GetLevel() > 0 )
     818             :     {
     819           0 :         sal_Int16 nListLevelsToBeClosed = 0;
     820           0 :         if ( !rNextInfo.BelongsToSameList( rPrevInfo ) ||
     821           0 :              rNextInfo.GetLevel() <= 0 )
     822             :         {
     823             :             // close complete previous list
     824           0 :             nListLevelsToBeClosed = rPrevInfo.GetLevel();
     825             :         }
     826           0 :         else if ( rPrevInfo.GetLevel() > rNextInfo.GetLevel() )
     827             :         {
     828             :             // close corresponding sub lists
     829             :             DBG_ASSERT( rNextInfo.GetLevel() > 0,
     830             :                         "<rPrevInfo.GetLevel() > 0> not hold. Serious defect -> please inform OD." );
     831           0 :             nListLevelsToBeClosed = rPrevInfo.GetLevel() - rNextInfo.GetLevel();
     832             :         }
     833             : 
     834           0 :         if ( nListLevelsToBeClosed > 0 &&
     835             :              pListElements &&
     836           0 :              pListElements->size() >= sal::static_int_cast< sal_uInt32 >( 2 * nListLevelsToBeClosed ) )
     837             :         {
     838           0 :             do {
     839           0 :                 for(size_t j = 0; j < 2; ++j)
     840             :                 {
     841           0 :                     rtl::OUString aElem(pListElements->back());
     842           0 :                     pListElements->pop_back();
     843           0 :                     GetExport().EndElement(aElem, sal_True);
     844           0 :                 }
     845             : 
     846             :                 // remove closed list from list stack
     847           0 :                 mpTextListsHelper->PopListFromStack();
     848             : 
     849           0 :                 --nListLevelsToBeClosed;
     850             :             } while ( nListLevelsToBeClosed > 0 );
     851             :         }
     852             :     }
     853             : 
     854             :     const bool bExportODF =
     855          55 :                 ( GetExport().getExportFlags() & EXPORT_OASIS ) != 0;
     856             :     const SvtSaveOptions::ODFDefaultVersion eODFDefaultVersion =
     857          55 :                                     GetExport().getDefaultVersion();
     858             : 
     859             :     // start a new list
     860          55 :     if ( rNextInfo.GetLevel() > 0 )
     861             :     {
     862           0 :         bool bRootListToBeStarted = false;
     863           0 :         sal_Int16 nListLevelsToBeOpened = 0;
     864           0 :         if ( !rPrevInfo.BelongsToSameList( rNextInfo ) ||
     865           0 :              rPrevInfo.GetLevel() <= 0 )
     866             :         {
     867             :             // new root list
     868           0 :             bRootListToBeStarted = true;
     869           0 :             nListLevelsToBeOpened = rNextInfo.GetLevel();
     870             :         }
     871           0 :         else if ( rNextInfo.GetLevel() > rPrevInfo.GetLevel() )
     872             :         {
     873             :             // open corresponding sub lists
     874             :             DBG_ASSERT( rPrevInfo.GetLevel() > 0,
     875             :                         "<rPrevInfo.GetLevel() > 0> not hold. Serious defect -> please inform OD." );
     876           0 :             nListLevelsToBeOpened = rNextInfo.GetLevel() - rPrevInfo.GetLevel();
     877             :         }
     878             : 
     879           0 :         if ( nListLevelsToBeOpened > 0 )
     880             :         {
     881           0 :             const ::rtl::OUString sListStyleName( rNextInfo.GetNumRulesName() );
     882             :             // Currently only the text documents support <ListId>.
     883             :             // Thus, for other document types <sListId> is empty.
     884           0 :             const ::rtl::OUString sListId( rNextInfo.GetListId() );
     885           0 :             bool bExportListStyle( true );
     886           0 :             bool bRestartNumberingAtContinuedList( false );
     887           0 :             sal_Int32 nRestartValueForContinuedList( -1 );
     888           0 :             bool bContinueingPreviousSubList = !bRootListToBeStarted &&
     889           0 :                                                rNextInfo.IsContinueingPreviousSubTree();
     890           0 :             do {
     891           0 :                 GetExport().CheckAttrList();
     892             : 
     893           0 :                 if ( bRootListToBeStarted )
     894             :                 {
     895           0 :                     if ( !mpTextListsHelper->IsListProcessed( sListId ) )
     896             :                     {
     897           0 :                         if ( bExportODF &&
     898             :                              eODFDefaultVersion >= SvtSaveOptions::ODFVER_012 &&
     899           0 :                              !sListId.isEmpty() )
     900             :                         {
     901             :                             /* Property text:id at element <text:list> has to be
     902             :                                replaced by property xml:id (#i92221#)
     903             :                             */
     904           0 :                             GetExport().AddAttribute( XML_NAMESPACE_XML,
     905             :                                                       XML_ID,
     906           0 :                                                       sListId );
     907             :                         }
     908             :                         mpTextListsHelper->KeepListAsProcessed( sListId,
     909             :                                                                 sListStyleName,
     910           0 :                                                                 ::rtl::OUString() );
     911             :                     }
     912             :                     else
     913             :                     {
     914             :                         const ::rtl::OUString sNewListId(
     915           0 :                                         mpTextListsHelper->GenerateNewListId() );
     916           0 :                         if ( bExportODF &&
     917             :                              eODFDefaultVersion >= SvtSaveOptions::ODFVER_012 &&
     918           0 :                              !sListId.isEmpty() )
     919             :                         {
     920             :                             /* Property text:id at element <text:list> has to be
     921             :                                replaced by property xml:id (#i92221#)
     922             :                             */
     923           0 :                             GetExport().AddAttribute( XML_NAMESPACE_XML,
     924             :                                                       XML_ID,
     925           0 :                                                       sNewListId );
     926             :                         }
     927             : 
     928             :                         const ::rtl::OUString sContinueListId =
     929           0 :                             mpTextListsHelper->GetLastContinuingListId( sListId );
     930             :                         // store that list with list id <sNewListId> is last list,
     931             :                         // which has continued list with list id <sListId>
     932             :                         mpTextListsHelper->StoreLastContinuingList( sListId,
     933           0 :                                                                     sNewListId );
     934           0 :                         if ( sListStyleName ==
     935           0 :                                 mpTextListsHelper->GetListStyleOfLastProcessedList() &&
     936             :                              // Inconsistent behavior regarding lists (#i92811#)
     937             :                              sContinueListId ==
     938           0 :                                 mpTextListsHelper->GetLastProcessedListId() &&
     939           0 :                              !rNextInfo.IsRestart() )
     940             :                         {
     941           0 :                             GetExport().AddAttribute( XML_NAMESPACE_TEXT,
     942             :                                                       XML_CONTINUE_NUMBERING,
     943           0 :                                                       XML_TRUE );
     944             :                         }
     945             :                         else
     946             :                         {
     947           0 :                             if ( bExportODF &&
     948             :                                  eODFDefaultVersion >= SvtSaveOptions::ODFVER_012 &&
     949           0 :                                  !sListId.isEmpty() )
     950             :                             {
     951           0 :                                 GetExport().AddAttribute( XML_NAMESPACE_TEXT,
     952             :                                                           XML_CONTINUE_LIST,
     953           0 :                                                           sContinueListId );
     954             :                             }
     955             : 
     956           0 :                             if ( rNextInfo.IsRestart() &&
     957             :                                  ( nListLevelsToBeOpened != 1 ||
     958           0 :                                    !rNextInfo.HasStartValue() ) )
     959             :                             {
     960           0 :                                 bRestartNumberingAtContinuedList = true;
     961             :                                 nRestartValueForContinuedList =
     962           0 :                                             rNextInfo.GetListLevelStartValue();
     963             :                             }
     964             :                         }
     965             : 
     966             :                         mpTextListsHelper->KeepListAsProcessed( sNewListId,
     967             :                                                                 sListStyleName,
     968           0 :                                                                 sContinueListId );
     969             :                     }
     970             : 
     971           0 :                     GetExport().AddAttribute( XML_NAMESPACE_TEXT, XML_STYLE_NAME,
     972           0 :                             GetExport().EncodeStyleName( sListStyleName ) );
     973           0 :                     bExportListStyle = false;
     974             : 
     975           0 :                     bRootListToBeStarted = false;
     976             :                 }
     977           0 :                 else if ( bExportListStyle &&
     978           0 :                           !mpTextListsHelper->EqualsToTopListStyleOnStack( sListStyleName ) )
     979             :                 {
     980           0 :                     GetExport().AddAttribute( XML_NAMESPACE_TEXT, XML_STYLE_NAME,
     981           0 :                             GetExport().EncodeStyleName( sListStyleName ) );
     982           0 :                     bExportListStyle = false;
     983             : 
     984             : 
     985             :                 }
     986             :                 else
     987             :                 {
     988             :                     // rhbz#746174: also export list restart for non root list
     989           0 :                     if (rNextInfo.IsRestart() && !rNextInfo.HasStartValue())
     990             :                     {
     991           0 :                         bRestartNumberingAtContinuedList = true;
     992             :                         nRestartValueForContinuedList =
     993           0 :                                         rNextInfo.GetListLevelStartValue();
     994             :                     }
     995             :                 }
     996             : 
     997           0 :                 if ( bContinueingPreviousSubList )
     998             :                 {
     999           0 :                     GetExport().AddAttribute( XML_NAMESPACE_TEXT,
    1000           0 :                                               XML_CONTINUE_NUMBERING, XML_TRUE );
    1001           0 :                     bContinueingPreviousSubList = false;
    1002             :                 }
    1003             : 
    1004           0 :                 enum XMLTokenEnum eLName = XML_LIST;
    1005             : 
    1006           0 :                 rtl::OUString aElem(GetExport().GetNamespaceMap().GetQNameByKey(
    1007             :                                             XML_NAMESPACE_TEXT,
    1008           0 :                                             GetXMLToken(eLName) ) );
    1009           0 :                 GetExport().IgnorableWhitespace();
    1010           0 :                 GetExport().StartElement(aElem, sal_False);
    1011             : 
    1012           0 :                 if(!pListElements)
    1013           0 :                     pListElements = new std::vector<rtl::OUString>;
    1014           0 :                 pListElements->push_back(aElem);
    1015             : 
    1016             :                 mpTextListsHelper->PushListOnStack( sListId,
    1017           0 :                                                     sListStyleName );
    1018             : 
    1019             :                 // <text:list-header> or <text:list-item>
    1020           0 :                 GetExport().CheckAttrList();
    1021             : 
    1022             :                 /* Export start value at correct list item (#i97309#) */
    1023           0 :                 if ( nListLevelsToBeOpened == 1 )
    1024             :                 {
    1025           0 :                     if ( rNextInfo.HasStartValue() )
    1026             :                     {
    1027           0 :                         OUStringBuffer aBuffer;
    1028           0 :                         aBuffer.append( (sal_Int32)rNextInfo.GetStartValue() );
    1029           0 :                         GetExport().AddAttribute( XML_NAMESPACE_TEXT, XML_START_VALUE,
    1030           0 :                                       aBuffer.makeStringAndClear() );
    1031             :                     }
    1032           0 :                     else if (bRestartNumberingAtContinuedList)
    1033             :                     {
    1034           0 :                         OUStringBuffer aBuffer;
    1035           0 :                         aBuffer.append( nRestartValueForContinuedList );
    1036           0 :                         GetExport().AddAttribute( XML_NAMESPACE_TEXT,
    1037             :                                                   XML_START_VALUE,
    1038           0 :                                                   aBuffer.makeStringAndClear() );
    1039           0 :                         bRestartNumberingAtContinuedList = false;
    1040             :                     }
    1041             :                 }
    1042             : 
    1043           0 :                 eLName = ( rNextInfo.IsNumbered() || nListLevelsToBeOpened > 1 )
    1044             :                          ? XML_LIST_ITEM
    1045           0 :                          : XML_LIST_HEADER;
    1046           0 :                 aElem = rtl::OUString( GetExport().GetNamespaceMap().GetQNameByKey(
    1047             :                                             XML_NAMESPACE_TEXT,
    1048           0 :                                             GetXMLToken(eLName) ) );
    1049           0 :                 GetExport().IgnorableWhitespace();
    1050           0 :                 GetExport().StartElement(aElem, sal_False);
    1051           0 :                 pListElements->push_back(aElem);
    1052             : 
    1053             :                 // export of <text:number> element for last opened <text:list-item>, if requested
    1054           0 :                 if ( GetExport().exportTextNumberElement() &&
    1055             :                      eLName == XML_LIST_ITEM && nListLevelsToBeOpened == 1 && // last iteration --> last opened <text:list-item>
    1056           0 :                      !rNextInfo.ListLabelString().isEmpty() )
    1057             :                 {
    1058             :                     const ::rtl::OUString aTextNumberElem =
    1059           0 :                             OUString( GetExport().GetNamespaceMap().GetQNameByKey(
    1060             :                                       XML_NAMESPACE_TEXT,
    1061           0 :                                       GetXMLToken(XML_NUMBER) ) );
    1062           0 :                     GetExport().IgnorableWhitespace();
    1063           0 :                     GetExport().StartElement( aTextNumberElem, sal_False );
    1064           0 :                     GetExport().Characters( rNextInfo.ListLabelString() );
    1065           0 :                     GetExport().EndElement( aTextNumberElem, sal_True );
    1066             :                 }
    1067           0 :                 --nListLevelsToBeOpened;
    1068           0 :             } while ( nListLevelsToBeOpened > 0 );
    1069             :         }
    1070             :     }
    1071             : 
    1072          55 :     if ( rNextInfo.GetLevel() > 0 &&
    1073           0 :          rNextInfo.IsNumbered() &&
    1074           0 :          rPrevInfo.BelongsToSameList( rNextInfo ) &&
    1075           0 :          rPrevInfo.GetLevel() >= rNextInfo.GetLevel() )
    1076             :     {
    1077             :         // close previous list-item
    1078             :         DBG_ASSERT( pListElements && pListElements->size() >= 2,
    1079             :                 "SwXMLExport::ExportListChange: list elements missing" );
    1080             : 
    1081           0 :         GetExport().EndElement(pListElements->back(), sal_True );
    1082           0 :         pListElements->pop_back();
    1083             : 
    1084             :         // Only for sub lists (#i103745#)
    1085           0 :         if ( rNextInfo.IsRestart() && !rNextInfo.HasStartValue() &&
    1086           0 :              rNextInfo.GetLevel() != 1 )
    1087             :         {
    1088             :             // start new sub list respectively list on same list level
    1089           0 :             GetExport().EndElement(pListElements->back(), sal_True );
    1090           0 :             GetExport().IgnorableWhitespace();
    1091           0 :             GetExport().StartElement(pListElements->back(), sal_False);
    1092             :         }
    1093             : 
    1094             :         // open new list-item
    1095           0 :         GetExport().CheckAttrList();
    1096           0 :         if( rNextInfo.HasStartValue() )
    1097             :         {
    1098           0 :             OUStringBuffer aBuffer;
    1099           0 :             aBuffer.append( (sal_Int32)rNextInfo.GetStartValue() );
    1100           0 :             GetExport().AddAttribute( XML_NAMESPACE_TEXT, XML_START_VALUE,
    1101           0 :                                       aBuffer.makeStringAndClear() );
    1102             :         }
    1103             :         // Handle restart without start value on list level 1 (#i103745#)
    1104           0 :         else if ( rNextInfo.IsRestart() && /*!rNextInfo.HasStartValue() &&*/
    1105           0 :                   rNextInfo.GetLevel() == 1 )
    1106             :         {
    1107           0 :             OUStringBuffer aBuffer;
    1108           0 :             aBuffer.append( (sal_Int32)rNextInfo.GetListLevelStartValue() );
    1109           0 :             GetExport().AddAttribute( XML_NAMESPACE_TEXT, XML_START_VALUE,
    1110           0 :                                       aBuffer.makeStringAndClear() );
    1111             :         }
    1112           0 :         if ( ( GetExport().getExportFlags() & EXPORT_OASIS ) != 0 &&
    1113           0 :              GetExport().getDefaultVersion() >= SvtSaveOptions::ODFVER_012 )
    1114             :         {
    1115           0 :             const ::rtl::OUString sListStyleName( rNextInfo.GetNumRulesName() );
    1116           0 :             if ( !mpTextListsHelper->EqualsToTopListStyleOnStack( sListStyleName ) )
    1117             :             {
    1118           0 :                 GetExport().AddAttribute( XML_NAMESPACE_TEXT,
    1119             :                                           XML_STYLE_OVERRIDE,
    1120           0 :                                           GetExport().EncodeStyleName( sListStyleName ) );
    1121           0 :             }
    1122             :         }
    1123           0 :         rtl::OUString aElem( GetExport().GetNamespaceMap().GetQNameByKey(
    1124             :                                 XML_NAMESPACE_TEXT,
    1125           0 :                                 GetXMLToken(XML_LIST_ITEM) ) );
    1126           0 :         GetExport().IgnorableWhitespace();
    1127           0 :         GetExport().StartElement(aElem, sal_False );
    1128           0 :         pListElements->push_back(aElem);
    1129             : 
    1130             :         // export of <text:number> element for <text:list-item>, if requested
    1131           0 :         if ( GetExport().exportTextNumberElement() &&
    1132           0 :              !rNextInfo.ListLabelString().isEmpty() )
    1133             :         {
    1134             :             const ::rtl::OUString aTextNumberElem =
    1135           0 :                     OUString( GetExport().GetNamespaceMap().GetQNameByKey(
    1136             :                               XML_NAMESPACE_TEXT,
    1137           0 :                               GetXMLToken(XML_NUMBER) ) );
    1138           0 :             GetExport().IgnorableWhitespace();
    1139           0 :             GetExport().StartElement( aTextNumberElem, sal_False );
    1140           0 :             GetExport().Characters( rNextInfo.ListLabelString() );
    1141           0 :             GetExport().EndElement( aTextNumberElem, sal_True );
    1142           0 :         }
    1143             :     }
    1144          55 : }
    1145             : 
    1146           8 : struct XMLTextParagraphExport::Impl
    1147             : {
    1148             :     typedef ::std::map<Reference<XFormField>, sal_Int32> FieldMarkMap_t;
    1149             :     FieldMarkMap_t m_FieldMarkMap;
    1150             : 
    1151           8 :     explicit Impl() {}
    1152           0 :     sal_Int32 AddFieldMarkStart(Reference<XFormField> const& i_xFieldMark)
    1153             :     {
    1154             :         assert(m_FieldMarkMap.find(i_xFieldMark) == m_FieldMarkMap.end());
    1155           0 :         sal_Int32 const ret(m_FieldMarkMap.size());
    1156           0 :         m_FieldMarkMap.insert(::std::make_pair(i_xFieldMark, ret));
    1157           0 :         return ret;
    1158             :     }
    1159           0 :     sal_Int32 GetFieldMarkIndex(Reference<XFormField> const& i_xFieldMark)
    1160             :     {
    1161             :         FieldMarkMap_t::const_iterator const it(
    1162           0 :                 m_FieldMarkMap.find(i_xFieldMark));
    1163             :         // rely on SwXFieldmark::CreateXFieldmark returning the same instance
    1164             :         // because the Reference in m_FieldMarkMap will keep it alive
    1165             :         assert(it != m_FieldMarkMap.end());
    1166           0 :         return it->second;
    1167             :     }
    1168             : };
    1169             : 
    1170           8 : XMLTextParagraphExport::XMLTextParagraphExport(
    1171             :         SvXMLExport& rExp,
    1172             :         SvXMLAutoStylePoolP & rASP
    1173             :         ) :
    1174             :     XMLStyleExport( rExp, OUString(), &rASP ),
    1175           8 :     m_pImpl(new Impl),
    1176             :     rAutoStylePool( rASP ),
    1177          16 :     pBoundFrameSets(new BoundFrameSets(GetExport().GetModel())),
    1178             :     pFieldExport( 0 ),
    1179             :     pListElements( 0 ),
    1180          16 :     pListAutoPool( new XMLTextListAutoStylePool( this->GetExport() ) ),
    1181             :     pSectionExport( NULL ),
    1182             :     pIndexMarkExport( NULL ),
    1183             :     pRedlineExport( NULL ),
    1184             :     pHeadingStyles( NULL ),
    1185             :     bProgress( sal_False ),
    1186             :     bBlock( sal_False ),
    1187             :     bOpenRuby( sal_False ),
    1188             :     mpTextListsHelper( 0 ),
    1189             :     maTextListsHelperStack(),
    1190             :     sActualSize("ActualSize"),
    1191             :     // Implement Title/Description Elements UI (#i73249#)
    1192             :     sTitle("Title"),
    1193             :     sDescription("Description"),
    1194             :     sAnchorCharStyleName("AnchorCharStyleName"),
    1195             :     sAnchorPageNo("AnchorPageNo"),
    1196             :     sAnchorType("AnchorType"),
    1197             :     sBeginNotice("BeginNotice"),
    1198             :     sBookmark("Bookmark"),
    1199             :     sCategory("Category"),
    1200             :     sChainNextName("ChainNextName"),
    1201             :     sCharStyleName("CharStyleName"),
    1202             :     sCharStyleNames("CharStyleNames"),
    1203             :     sContourPolyPolygon("ContourPolyPolygon"),
    1204             :     sDocumentIndex("DocumentIndex"),
    1205             :     sDocumentIndexMark("DocumentIndexMark"),
    1206             :     sEndNotice("EndNotice"),
    1207             :     sFootnote("Footnote"),
    1208             :     sFootnoteCounting("FootnoteCounting"),
    1209             :     sFrame("Frame"),
    1210             :     sFrameHeightAbsolute("FrameHeightAbsolute"),
    1211             :     sFrameHeightPercent("FrameHeightPercent"),
    1212             :     sFrameStyleName("FrameStyleName"),
    1213             :     sFrameWidthAbsolute("FrameWidthAbsolute"),
    1214             :     sFrameWidthPercent("FrameWidthPercent"),
    1215             :     sGraphicFilter("GraphicFilter"),
    1216             :     sGraphicRotation("GraphicRotation"),
    1217             :     sGraphicURL("GraphicURL"),
    1218             :     sReplacementGraphicURL("ReplacementGraphicURL"),
    1219             :     sHeight("Height"),
    1220             :     sHoriOrient("HoriOrient"),
    1221             :     sHoriOrientPosition("HoriOrientPosition"),
    1222             :     sHyperLinkName("HyperLinkName"),
    1223             :     sHyperLinkTarget("HyperLinkTarget"),
    1224             :     sHyperLinkURL("HyperLinkURL"),
    1225             :     sIsAutomaticContour("IsAutomaticContour"),
    1226             :     sIsCollapsed("IsCollapsed"),
    1227             :     sIsPixelContour("IsPixelContour"),
    1228             :     sIsStart("IsStart"),
    1229             :     sIsSyncHeightToWidth("IsSyncHeightToWidth"),
    1230             :     sIsSyncWidthToHeight("IsSyncWidthToHeight"),
    1231             :     sNumberingRules("NumberingRules"),
    1232             :     sNumberingType("NumberingType"),
    1233             :     sPageDescName("PageDescName"),
    1234             :     sPageStyleName("PageStyleName"),
    1235             :     sParaChapterNumberingLevel("ParaChapterNumberingLevel"),
    1236             :     sParaConditionalStyleName("ParaConditionalStyleName"),
    1237             :     sParagraphService("com.sun.star.text.Paragraph"),
    1238             :     sParaStyleName("ParaStyleName"),
    1239             :     sPositionEndOfDoc("PositionEndOfDoc"),
    1240             :     sPrefix("Prefix"),
    1241             :     sRedline("Redline"),
    1242             :     sReferenceId("ReferenceId"),
    1243             :     sReferenceMark("ReferenceMark"),
    1244             :     sRelativeHeight("RelativeHeight"),
    1245             :     sRelativeWidth("RelativeWidth"),
    1246             :     sRuby("Ruby"),
    1247             :     sRubyAdjust("RubyAdjust"),
    1248             :     sRubyCharStyleName("RubyCharStyleName"),
    1249             :     sRubyText("RubyText"),
    1250             :     sServerMap("ServerMap"),
    1251             :     sShapeService("com.sun.star.drawing.Shape"),
    1252             :     sSizeType("SizeType"),
    1253             :     sSoftPageBreak( "SoftPageBreak"  ),
    1254             :     sStartAt("StartAt"),
    1255             :     sSuffix("Suffix"),
    1256             :     sTableService("com.sun.star.text.TextTable"),
    1257             :     sText("Text"),
    1258             :     sTextContentService("com.sun.star.text.TextContent"),
    1259             :     sTextEmbeddedService("com.sun.star.text.TextEmbeddedObject"),
    1260             :     sTextEndnoteService("com.sun.star.text.Endnote"),
    1261             :     sTextField("TextField"),
    1262             :     sTextFieldService("com.sun.star.text.TextField"),
    1263             :     sTextFrameService("com.sun.star.text.TextFrame"),
    1264             :     sTextGraphicService("com.sun.star.text.TextGraphicObject"),
    1265             :     sTextPortionType("TextPortionType"),
    1266             :     sTextSection("TextSection"),
    1267             :     sUnvisitedCharStyleName("UnvisitedCharStyleName"),
    1268             :     sVertOrient("VertOrient"),
    1269             :     sVertOrientPosition("VertOrientPosition"),
    1270             :     sVisitedCharStyleName("VisitedCharStyleName"),
    1271             :     sWidth("Width"),
    1272             :     sWidthType( "WidthType"  ),
    1273             :     sTextFieldStart( "TextFieldStart"  ),
    1274             :     sTextFieldEnd( "TextFieldEnd"  ),
    1275             :     sTextFieldStartEnd( "TextFieldStartEnd"  ),
    1276          48 :     aCharStyleNamesPropInfoCache( sCharStyleNames )
    1277             : {
    1278           8 :     UniReference < XMLPropertySetMapper > xPropMapper(new XMLTextPropertySetMapper( TEXT_PROP_MAP_PARA ));
    1279             :     xParaPropMapper = new XMLTextExportPropertySetMapper( xPropMapper,
    1280           8 :                                                              GetExport() );
    1281             : 
    1282           8 :     OUString sFamily( GetXMLToken(XML_PARAGRAPH) );
    1283           8 :     OUString aPrefix(static_cast<sal_Unicode>('P'));
    1284             :     rAutoStylePool.AddFamily( XML_STYLE_FAMILY_TEXT_PARAGRAPH, sFamily,
    1285           8 :                               xParaPropMapper, aPrefix );
    1286             : 
    1287           8 :     xPropMapper = new XMLTextPropertySetMapper( TEXT_PROP_MAP_TEXT );
    1288             :     xTextPropMapper = new XMLTextExportPropertySetMapper( xPropMapper,
    1289           8 :                                                              GetExport() );
    1290           8 :     sFamily = OUString( GetXMLToken(XML_TEXT) );
    1291           8 :     aPrefix = OUString(static_cast<sal_Unicode>('T'));
    1292             :     rAutoStylePool.AddFamily( XML_STYLE_FAMILY_TEXT_TEXT, sFamily,
    1293           8 :                               xTextPropMapper, aPrefix );
    1294             : 
    1295           8 :     xPropMapper = new XMLTextPropertySetMapper( TEXT_PROP_MAP_AUTO_FRAME );
    1296             :     xAutoFramePropMapper = new XMLTextExportPropertySetMapper( xPropMapper,
    1297           8 :                                                                   GetExport() );
    1298           8 :     sFamily = OUString( XML_STYLE_FAMILY_SD_GRAPHICS_NAME );
    1299           8 :     aPrefix = OUString( "fr"  );
    1300             :     rAutoStylePool.AddFamily( XML_STYLE_FAMILY_TEXT_FRAME, sFamily,
    1301           8 :                               xAutoFramePropMapper, aPrefix );
    1302             : 
    1303           8 :     xPropMapper = new XMLTextPropertySetMapper( TEXT_PROP_MAP_SECTION );
    1304             :     xSectionPropMapper = new XMLTextExportPropertySetMapper( xPropMapper,
    1305           8 :                                                              GetExport() );
    1306           8 :     sFamily = OUString( GetXMLToken( XML_SECTION ) );
    1307           8 :     aPrefix = OUString( "Sect"  );
    1308             :     rAutoStylePool.AddFamily( XML_STYLE_FAMILY_TEXT_SECTION, sFamily,
    1309           8 :                               xSectionPropMapper, aPrefix );
    1310             : 
    1311           8 :     xPropMapper = new XMLTextPropertySetMapper( TEXT_PROP_MAP_RUBY );
    1312           8 :     xRubyPropMapper = new SvXMLExportPropertyMapper( xPropMapper );
    1313           8 :     sFamily = OUString( GetXMLToken( XML_RUBY ) );
    1314           8 :     aPrefix = OUString( "Ru"  );
    1315             :     rAutoStylePool.AddFamily( XML_STYLE_FAMILY_TEXT_RUBY, sFamily,
    1316           8 :                               xRubyPropMapper, aPrefix );
    1317             : 
    1318           8 :     xPropMapper = new XMLTextPropertySetMapper( TEXT_PROP_MAP_FRAME );
    1319             :     xFramePropMapper = new XMLTextExportPropertySetMapper( xPropMapper,
    1320           8 :                                                               GetExport() );
    1321             : 
    1322           8 :     pSectionExport = new XMLSectionExport( rExp, *this );
    1323           8 :     pIndexMarkExport = new XMLIndexMarkExport( rExp );
    1324             : 
    1325          32 :     if( ! IsBlockMode() &&
    1326          24 :         Reference<XRedlinesSupplier>( GetExport().GetModel(), UNO_QUERY ).is())
    1327           4 :         pRedlineExport = new XMLRedlineExport( rExp );
    1328             : 
    1329             :     // The text field helper needs a pre-constructed XMLPropertyState
    1330             :     // to export the combined characters field. We construct that
    1331             :     // here, because we need the text property mapper to do it.
    1332             : 
    1333             :     // construct Any value, then find index
    1334           8 :     sal_Int32 nIndex = xTextPropMapper->getPropertySetMapper()->FindEntryIndex(
    1335             :                                 "", XML_NAMESPACE_STYLE,
    1336          16 :                                 GetXMLToken(XML_TEXT_COMBINE));
    1337           8 :     pFieldExport = new XMLTextFieldExport( rExp, new XMLPropertyState( nIndex, uno::makeAny(sal_True) ) );
    1338           8 :     PushNewTextListsHelper();
    1339           8 : }
    1340             : 
    1341          20 : XMLTextParagraphExport::~XMLTextParagraphExport()
    1342             : {
    1343           8 :     delete pHeadingStyles;
    1344           8 :     delete pRedlineExport;
    1345           8 :     delete pIndexMarkExport;
    1346           8 :     delete pSectionExport;
    1347           8 :     delete pFieldExport;
    1348           8 :     delete pListElements;
    1349           8 :     delete pListAutoPool;
    1350             : #ifdef DBG_UTIL
    1351             :     txtparae_bContainsIllegalCharacters = sal_False;
    1352             : #endif
    1353           8 :     PopTextListsHelper();
    1354             :     DBG_ASSERT( maTextListsHelperStack.empty(),
    1355             :                 "misusage of text lists helper stack - it is not empty. Serious defect - please inform OD" );
    1356          12 : }
    1357             : 
    1358           4 : SvXMLExportPropertyMapper *XMLTextParagraphExport::CreateShapeExtPropMapper(
    1359             :         SvXMLExport& rExport )
    1360             : {
    1361             :     UniReference < XMLPropertySetMapper > xPropMapper =
    1362           4 :         new XMLTextPropertySetMapper( TEXT_PROP_MAP_SHAPE );
    1363           4 :     return new XMLTextExportPropertySetMapper( xPropMapper, rExport );
    1364             : }
    1365             : 
    1366           2 : SvXMLExportPropertyMapper *XMLTextParagraphExport::CreateCharExtPropMapper(
    1367             :         SvXMLExport& rExport)
    1368             : {
    1369             :     XMLPropertySetMapper *pPropMapper =
    1370           2 :         new XMLTextPropertySetMapper( TEXT_PROP_MAP_TEXT );
    1371           2 :     return new XMLTextExportPropertySetMapper( pPropMapper, rExport );
    1372             : }
    1373             : 
    1374          18 : SvXMLExportPropertyMapper *XMLTextParagraphExport::CreateParaExtPropMapper(
    1375             :         SvXMLExport& rExport)
    1376             : {
    1377             :     XMLPropertySetMapper *pPropMapper =
    1378          18 :         new XMLTextPropertySetMapper( TEXT_PROP_MAP_SHAPE_PARA );
    1379          18 :     return new XMLTextExportPropertySetMapper( pPropMapper, rExport );
    1380             : }
    1381             : 
    1382           2 : SvXMLExportPropertyMapper *XMLTextParagraphExport::CreateParaDefaultExtPropMapper(
    1383             :         SvXMLExport& rExport)
    1384             : {
    1385             :     XMLPropertySetMapper *pPropMapper =
    1386           2 :         new XMLTextPropertySetMapper( TEXT_PROP_MAP_TEXT_ADDITIONAL_DEFAULTS );
    1387           2 :     return new XMLTextExportPropertySetMapper( pPropMapper, rExport );
    1388             : }
    1389             : 
    1390           2 : void XMLTextParagraphExport::exportPageFrames( sal_Bool bAutoStyles,
    1391             :                                                sal_Bool bIsProgress )
    1392             : {
    1393           2 :     const TextContentSet* const pTexts = pBoundFrameSets->GetTexts()->GetPageBoundContents();
    1394           2 :     const TextContentSet* const pGraphics = pBoundFrameSets->GetGraphics()->GetPageBoundContents();
    1395           2 :     const TextContentSet* const pEmbeddeds = pBoundFrameSets->GetEmbeddeds()->GetPageBoundContents();
    1396           2 :     const TextContentSet* const pShapes = pBoundFrameSets->GetShapes()->GetPageBoundContents();
    1397           6 :     for(TextContentSet::const_iterator_t it = pTexts->getBegin();
    1398           4 :         it != pTexts->getEnd();
    1399             :         ++it)
    1400           0 :         exportTextFrame(*it, bAutoStyles, bIsProgress, sal_True);
    1401           6 :     for(TextContentSet::const_iterator_t it = pGraphics->getBegin();
    1402           4 :         it != pGraphics->getEnd();
    1403             :         ++it)
    1404           0 :         exportTextGraphic(*it, bAutoStyles);
    1405           6 :     for(TextContentSet::const_iterator_t it = pEmbeddeds->getBegin();
    1406           4 :         it != pEmbeddeds->getEnd();
    1407             :         ++it)
    1408           0 :         exportTextEmbedded(*it, bAutoStyles);
    1409           6 :     for(TextContentSet::const_iterator_t it = pShapes->getBegin();
    1410           4 :         it != pShapes->getEnd();
    1411             :         ++it)
    1412           0 :         exportShape(*it, bAutoStyles);
    1413           2 : }
    1414             : 
    1415           0 : void XMLTextParagraphExport::exportFrameFrames(
    1416             :         sal_Bool bAutoStyles,
    1417             :         sal_Bool bIsProgress,
    1418             :         const Reference < XTextFrame > *pParentTxtFrame )
    1419             : {
    1420           0 :     const TextContentSet* const pTexts = pBoundFrameSets->GetTexts()->GetFrameBoundContents(*pParentTxtFrame);
    1421           0 :     if(pTexts)
    1422           0 :         for(TextContentSet::const_iterator_t it = pTexts->getBegin();
    1423           0 :             it != pTexts->getEnd();
    1424             :             ++it)
    1425           0 :             exportTextFrame(*it, bAutoStyles, bIsProgress, sal_True);
    1426           0 :     const TextContentSet* const pGraphics = pBoundFrameSets->GetGraphics()->GetFrameBoundContents(*pParentTxtFrame);
    1427           0 :     if(pGraphics)
    1428           0 :         for(TextContentSet::const_iterator_t it = pGraphics->getBegin();
    1429           0 :             it != pGraphics->getEnd();
    1430             :             ++it)
    1431           0 :             exportTextGraphic(*it, bAutoStyles);
    1432           0 :     const TextContentSet* const pEmbeddeds = pBoundFrameSets->GetEmbeddeds()->GetFrameBoundContents(*pParentTxtFrame);
    1433           0 :     if(pEmbeddeds)
    1434           0 :         for(TextContentSet::const_iterator_t it = pEmbeddeds->getBegin();
    1435           0 :             it != pEmbeddeds->getEnd();
    1436             :             ++it)
    1437           0 :             exportTextEmbedded(*it, bAutoStyles);
    1438           0 :     const TextContentSet* const pShapes = pBoundFrameSets->GetShapes()->GetFrameBoundContents(*pParentTxtFrame);
    1439           0 :     if(pShapes)
    1440           0 :         for(TextContentSet::const_iterator_t it = pShapes->getBegin();
    1441           0 :             it != pShapes->getEnd();
    1442             :             ++it)
    1443           0 :             exportShape(*it, bAutoStyles);
    1444           0 : }
    1445             : 
    1446             : // bookmarks, reference marks (and TOC marks) are the same except for the
    1447             : // element names. We use the same method for export and it an array with
    1448             : // the proper element names
    1449             : static const enum XMLTokenEnum lcl_XmlReferenceElements[] = {
    1450             :     XML_REFERENCE_MARK, XML_REFERENCE_MARK_START, XML_REFERENCE_MARK_END };
    1451             : static const enum XMLTokenEnum lcl_XmlBookmarkElements[] = {
    1452             :     XML_BOOKMARK, XML_BOOKMARK_START, XML_BOOKMARK_END };
    1453             : 
    1454             : // This function replaces the text portion iteration during auto style
    1455             : // collection.
    1456           2 : bool XMLTextParagraphExport::collectTextAutoStylesOptimized( sal_Bool bIsProgress )
    1457             : {
    1458           2 :     GetExport().GetShapeExport(); // make sure the graphics styles family is added
    1459             : 
    1460           2 :     const sal_Bool bAutoStyles = sal_True;
    1461           2 :     const sal_Bool bExportContent = sal_False;
    1462             : 
    1463             :     // Export AutoStyles:
    1464           2 :     Reference< XAutoStylesSupplier > xAutoStylesSupp( GetExport().GetModel(), UNO_QUERY );
    1465           2 :     if ( xAutoStylesSupp.is() )
    1466             :     {
    1467           2 :         Reference< XAutoStyles > xAutoStyleFamilies = xAutoStylesSupp->getAutoStyles();
    1468           2 :         OUString sName;
    1469             :         sal_uInt16 nFamily;
    1470             : 
    1471           8 :         for ( int i = 0; i < 3; ++i )
    1472             :         {
    1473           6 :             if ( 0 == i )
    1474             :             {
    1475           2 :                 sName = OUString( "CharacterStyles"  );
    1476           2 :                 nFamily = XML_STYLE_FAMILY_TEXT_TEXT;
    1477             :             }
    1478           4 :             else if ( 1 == i )
    1479             :             {
    1480           2 :                 sName = OUString( "RubyStyles"  );
    1481           2 :                 nFamily = XML_STYLE_FAMILY_TEXT_RUBY;
    1482             :             }
    1483             :             else
    1484             :             {
    1485           2 :                 sName = OUString( "ParagraphStyles"  );
    1486           2 :                 nFamily = XML_STYLE_FAMILY_TEXT_PARAGRAPH;
    1487             :             }
    1488             : 
    1489           6 :             Any aAny = xAutoStyleFamilies->getByName( sName );
    1490           6 :             Reference< XAutoStyleFamily > xAutoStyles = *(Reference<XAutoStyleFamily>*)aAny.getValue();
    1491           6 :             Reference < XEnumeration > xAutoStylesEnum( xAutoStyles->createEnumeration() );
    1492             : 
    1493          15 :             while ( xAutoStylesEnum->hasMoreElements() )
    1494             :             {
    1495           3 :                 aAny = xAutoStylesEnum->nextElement();
    1496           3 :                 Reference< XAutoStyle > xAutoStyle = *(Reference<XAutoStyle>*)aAny.getValue();
    1497           3 :                 Reference < XPropertySet > xPSet( xAutoStyle, uno::UNO_QUERY );
    1498           3 :                 Add( nFamily, xPSet, 0, true );
    1499           3 :             }
    1500           8 :         }
    1501             :     }
    1502             : 
    1503             :     // Export Field AutoStyles:
    1504           2 :     Reference< XTextFieldsSupplier > xTextFieldsSupp( GetExport().GetModel(), UNO_QUERY );
    1505           2 :     if ( xTextFieldsSupp.is() )
    1506             :     {
    1507           2 :         Reference< XEnumerationAccess > xTextFields = xTextFieldsSupp->getTextFields();
    1508           2 :         Reference < XEnumeration > xTextFieldsEnum( xTextFields->createEnumeration() );
    1509             : 
    1510           5 :         while ( xTextFieldsEnum->hasMoreElements() )
    1511             :         {
    1512           1 :             Any aAny = xTextFieldsEnum->nextElement();
    1513           1 :             Reference< XTextField > xTextField = *(Reference<XTextField>*)aAny.getValue();
    1514             :             exportTextField( xTextField, bAutoStyles, bIsProgress,
    1515           1 :                 !xAutoStylesSupp.is() );
    1516             :             try
    1517             :             {
    1518           1 :                 Reference < XPropertySet > xSet( xTextField, UNO_QUERY );
    1519           1 :                 Reference < XText > xText;
    1520           1 :                 Any a = xSet->getPropertyValue( ::rtl::OUString("TextRange") );
    1521           1 :                 a >>= xText;
    1522           1 :                 if ( xText.is() )
    1523             :                 {
    1524           1 :                     exportText( xText, sal_True, bIsProgress, bExportContent );
    1525           1 :                     GetExport().GetTextParagraphExport()
    1526           1 :                         ->collectTextAutoStyles( xText );
    1527           1 :                 }
    1528             :             }
    1529           0 :             catch (Exception&)
    1530             :             {
    1531             :             }
    1532           3 :         }
    1533             :     }
    1534             : 
    1535             :     // Export text frames:
    1536           2 :     Reference<XEnumeration> xTextFramesEnum = pBoundFrameSets->GetTexts()->createEnumeration();
    1537           2 :     if(xTextFramesEnum.is())
    1538           4 :         while(xTextFramesEnum->hasMoreElements())
    1539             :         {
    1540           0 :             Reference<XTextContent> xTxtCntnt(xTextFramesEnum->nextElement(), UNO_QUERY);
    1541           0 :             if(xTxtCntnt.is())
    1542           0 :                 exportTextFrame(xTxtCntnt, bAutoStyles, bIsProgress, bExportContent, 0);
    1543           0 :         }
    1544             : 
    1545             :     // Export graphic objects:
    1546           2 :     Reference<XEnumeration> xGraphicsEnum = pBoundFrameSets->GetGraphics()->createEnumeration();
    1547           2 :     if(xGraphicsEnum.is())
    1548           4 :         while(xGraphicsEnum->hasMoreElements())
    1549             :         {
    1550           0 :             Reference<XTextContent> xTxtCntnt(xGraphicsEnum->nextElement(), UNO_QUERY);
    1551           0 :             if(xTxtCntnt.is())
    1552           0 :                 exportTextGraphic(xTxtCntnt, true, 0);
    1553           0 :         }
    1554             : 
    1555             :     // Export embedded objects:
    1556           2 :     Reference<XEnumeration> xEmbeddedsEnum = pBoundFrameSets->GetEmbeddeds()->createEnumeration();
    1557           2 :     if(xEmbeddedsEnum.is())
    1558           4 :         while(xEmbeddedsEnum->hasMoreElements())
    1559             :         {
    1560           0 :             Reference<XTextContent> xTxtCntnt(xEmbeddedsEnum->nextElement(), UNO_QUERY);
    1561           0 :             if(xTxtCntnt.is())
    1562           0 :                 exportTextEmbedded(xTxtCntnt, true, 0);
    1563           0 :         }
    1564             : 
    1565             :     // Export shapes:
    1566           2 :     Reference<XEnumeration> xShapesEnum = pBoundFrameSets->GetShapes()->createEnumeration();
    1567           2 :     if(xShapesEnum.is())
    1568           4 :         while(xShapesEnum->hasMoreElements())
    1569             :         {
    1570           0 :             Reference<XTextContent> xTxtCntnt(xShapesEnum->nextElement(), UNO_QUERY);
    1571           0 :             if(xTxtCntnt.is())
    1572             :             {
    1573           0 :                 Reference<XServiceInfo> xServiceInfo(xTxtCntnt, UNO_QUERY);
    1574           0 :                 if( xServiceInfo->supportsService(sShapeService))
    1575           0 :                     exportShape(xTxtCntnt, true, 0);
    1576             :             }
    1577           0 :         }
    1578             : 
    1579             :     sal_Int32 nCount;
    1580             :     // AutoStyles for sections
    1581           2 :     Reference< XTextSectionsSupplier > xSectionsSupp( GetExport().GetModel(), UNO_QUERY );
    1582           2 :     if ( xSectionsSupp.is() )
    1583             :     {
    1584           2 :         Reference< XIndexAccess > xSections( xSectionsSupp->getTextSections(), UNO_QUERY );
    1585           2 :         if ( xSections.is() )
    1586             :         {
    1587           2 :             nCount = xSections->getCount();
    1588           2 :             for( sal_Int32 i = 0; i < nCount; ++i )
    1589             :             {
    1590           0 :                 Any aAny = xSections->getByIndex( i );
    1591           0 :                 Reference< XTextSection > xSection = *(Reference<XTextSection>*)aAny.getValue();
    1592           0 :                 Reference < XPropertySet > xPSet( xSection, uno::UNO_QUERY );
    1593           0 :                 Add( XML_STYLE_FAMILY_TEXT_SECTION, xPSet );
    1594           0 :             }
    1595           2 :         }
    1596             :     }
    1597             : 
    1598             :     // AutoStyles for tables (Note: suppress autostyle collection for paragraphs in exportTable)
    1599           2 :     Reference< XTextTablesSupplier > xTablesSupp( GetExport().GetModel(), UNO_QUERY );
    1600           2 :     if ( xTablesSupp.is() )
    1601             :     {
    1602           2 :         Reference< XIndexAccess > xTables( xTablesSupp->getTextTables(), UNO_QUERY );
    1603           2 :         if ( xTables.is() )
    1604             :         {
    1605           2 :             nCount = xTables->getCount();
    1606           2 :             for( sal_Int32 i = 0; i < nCount; ++i )
    1607             :             {
    1608           0 :                 Any aAny = xTables->getByIndex( i );
    1609           0 :                 Reference< XTextTable > xTable = *(Reference<XTextTable>*)aAny.getValue();
    1610           0 :                 Reference < XTextContent > xTextContent( xTable, uno::UNO_QUERY );
    1611           0 :                 exportTable( xTextContent, sal_True, sal_True );
    1612           0 :             }
    1613           2 :         }
    1614             :     }
    1615             : 
    1616           2 :     Reference< XNumberingRulesSupplier > xNumberingRulesSupp( GetExport().GetModel(), UNO_QUERY );
    1617           2 :     if ( xNumberingRulesSupp.is() )
    1618             :     {
    1619           2 :         Reference< XIndexAccess > xNumberingRules = xNumberingRulesSupp->getNumberingRules();
    1620           2 :         nCount = xNumberingRules->getCount();
    1621             :         // Custom outline assignment lost after re-importing sxw (#i73361#)
    1622           2 :         const OUString sNumberingIsOutline( "NumberingIsOutline"  );
    1623           4 :         for( sal_Int32 i = 0; i < nCount; ++i )
    1624             :         {
    1625           2 :             Reference< XIndexReplace > xNumRule( xNumberingRules->getByIndex( i ), UNO_QUERY );
    1626           2 :             if( xNumRule.is() && xNumRule->getCount() )
    1627             :             {
    1628           2 :                 Reference < XNamed > xNamed( xNumRule, UNO_QUERY );
    1629           2 :                 OUString sName;
    1630           2 :                 if( xNamed.is() )
    1631           2 :                     sName = xNamed->getName();
    1632           2 :                 sal_Bool bAdd = sName.isEmpty();
    1633           2 :                 if( !bAdd )
    1634             :                 {
    1635             :                     Reference < XPropertySet > xNumPropSet( xNumRule,
    1636           2 :                                                             UNO_QUERY );
    1637           2 :                     const OUString sIsAutomatic( "IsAutomatic"  );
    1638           8 :                     if( xNumPropSet.is() &&
    1639           2 :                         xNumPropSet->getPropertySetInfo()
    1640           6 :                                    ->hasPropertyByName( sIsAutomatic ) )
    1641             :                     {
    1642           2 :                         bAdd = *(sal_Bool *)xNumPropSet->getPropertyValue( sIsAutomatic ).getValue();
    1643             :                         // Check on outline style (#i73361#)
    1644           8 :                         if ( bAdd &&
    1645           2 :                              xNumPropSet->getPropertySetInfo()
    1646           6 :                                        ->hasPropertyByName( sNumberingIsOutline ) )
    1647             :                         {
    1648           2 :                             bAdd = !(*(sal_Bool *)xNumPropSet->getPropertyValue( sNumberingIsOutline ).getValue());
    1649             :                         }
    1650             :                     }
    1651             :                     else
    1652             :                     {
    1653           0 :                         bAdd = sal_True;
    1654           2 :                     }
    1655             :                 }
    1656           2 :                 if( bAdd )
    1657           0 :                     pListAutoPool->Add( xNumRule );
    1658             :             }
    1659           4 :         }
    1660             :     }
    1661             : 
    1662           2 :     return true;
    1663             : }
    1664             : 
    1665          87 : void XMLTextParagraphExport::exportText(
    1666             :         const Reference < XText > & rText,
    1667             :         sal_Bool bAutoStyles,
    1668             :         sal_Bool bIsProgress,
    1669             :         sal_Bool bExportParagraph )
    1670             : {
    1671          87 :     if( bAutoStyles )
    1672          62 :         GetExport().GetShapeExport(); // make sure the graphics styles family
    1673             :                                       // is added
    1674          87 :     Reference < XEnumerationAccess > xEA( rText, UNO_QUERY );
    1675          87 :     Reference < XEnumeration > xParaEnum(xEA->createEnumeration());
    1676          87 :     Reference < XPropertySet > xPropertySet( rText, UNO_QUERY );
    1677          87 :     Reference < XTextSection > xBaseSection;
    1678             : 
    1679             :     // #97718# footnotes don't supply paragraph enumerations in some cases
    1680             :     // This is always a bug, but at least we don't want to crash.
    1681             :     DBG_ASSERT( xParaEnum.is(), "We need a paragraph enumeration" );
    1682          87 :     if( ! xParaEnum.is() )
    1683          87 :         return;
    1684             : 
    1685          87 :     sal_Bool bExportLevels = sal_True;
    1686             : 
    1687          87 :     if (xPropertySet.is())
    1688             :     {
    1689          29 :         Reference < XPropertySetInfo > xInfo ( xPropertySet->getPropertySetInfo() );
    1690             : 
    1691          29 :         if( xInfo.is() )
    1692             :         {
    1693          29 :             if (xInfo->hasPropertyByName( sTextSection ))
    1694             :             {
    1695           0 :                 xPropertySet->getPropertyValue(sTextSection) >>= xBaseSection ;
    1696             :             }
    1697             : 
    1698             : /* #i35937#
    1699             :             // for applications that use the outliner we need to check if
    1700             :             // the current text object needs the level information exported
    1701             :             if( !bAutoStyles )
    1702             :             {
    1703             :                 // fixme: move string to class member, couldn't do now because
    1704             :                 //        of no incompatible build
    1705             :                 OUString sHasLevels( "HasLevels" );
    1706             :                 if (xInfo->hasPropertyByName( sHasLevels ) )
    1707             :                 {
    1708             :                     xPropertySet->getPropertyValue(sHasLevels) >>= bExportLevels;
    1709             :                 }
    1710             :             }
    1711             : */
    1712          29 :         }
    1713             :     }
    1714             : 
    1715             :     // #96530# Export redlines at start & end of XText before & after
    1716             :     // exporting the text content enumeration
    1717          87 :     if( !bAutoStyles && (pRedlineExport != NULL) )
    1718          15 :         pRedlineExport->ExportStartOrEndRedline( xPropertySet, sal_True );
    1719             :     exportTextContentEnumeration( xParaEnum, bAutoStyles, xBaseSection,
    1720          87 :                                   bIsProgress, bExportParagraph, 0, bExportLevels );
    1721          87 :     if( !bAutoStyles && (pRedlineExport != NULL) )
    1722          15 :         pRedlineExport->ExportStartOrEndRedline( xPropertySet, sal_False );
    1723             : }
    1724             : 
    1725           0 : void XMLTextParagraphExport::exportText(
    1726             :         const Reference < XText > & rText,
    1727             :         const Reference < XTextSection > & rBaseSection,
    1728             :         sal_Bool bAutoStyles,
    1729             :         sal_Bool bIsProgress,
    1730             :         sal_Bool bExportParagraph )
    1731             : {
    1732           0 :     if( bAutoStyles )
    1733           0 :         GetExport().GetShapeExport(); // make sure the graphics styles family
    1734             :                                       // is added
    1735           0 :     Reference < XEnumerationAccess > xEA( rText, UNO_QUERY );
    1736           0 :     Reference < XEnumeration > xParaEnum(xEA->createEnumeration());
    1737             : 
    1738             :     // #98165# don't continue without a paragraph enumeration
    1739           0 :     if( ! xParaEnum.is() )
    1740           0 :         return;
    1741             : 
    1742             :     // #96530# Export redlines at start & end of XText before & after
    1743             :     // exporting the text content enumeration
    1744           0 :     Reference<XPropertySet> xPropertySet;
    1745           0 :     if( !bAutoStyles && (pRedlineExport != NULL) )
    1746             :     {
    1747           0 :         xPropertySet.set(rText, uno::UNO_QUERY );
    1748           0 :         pRedlineExport->ExportStartOrEndRedline( xPropertySet, sal_True );
    1749             :     }
    1750             :     exportTextContentEnumeration( xParaEnum, bAutoStyles, rBaseSection,
    1751           0 :                                   bIsProgress, bExportParagraph );
    1752           0 :     if( !bAutoStyles && (pRedlineExport != NULL) )
    1753           0 :         pRedlineExport->ExportStartOrEndRedline( xPropertySet, sal_False );
    1754             : }
    1755             : 
    1756          87 : sal_Bool XMLTextParagraphExport::exportTextContentEnumeration(
    1757             :         const Reference < XEnumeration > & rContEnum,
    1758             :         sal_Bool bAutoStyles,
    1759             :         const Reference < XTextSection > & rBaseSection,
    1760             :         sal_Bool bIsProgress,
    1761             :         sal_Bool bExportParagraph,
    1762             :         const Reference < XPropertySet > *pRangePropSet,
    1763             :         sal_Bool bExportLevels )
    1764             : {
    1765             :     DBG_ASSERT( rContEnum.is(), "No enumeration to export!" );
    1766          87 :     sal_Bool bHasMoreElements = rContEnum->hasMoreElements();
    1767          87 :     if( !bHasMoreElements )
    1768           0 :         return sal_False;
    1769             : 
    1770          87 :     XMLTextNumRuleInfo aPrevNumInfo;
    1771          87 :     XMLTextNumRuleInfo aNextNumInfo;
    1772             : 
    1773          87 :     sal_Bool bHasContent = sal_False;
    1774          87 :     Reference<XTextSection> xCurrentTextSection(rBaseSection);
    1775             : 
    1776             :     MultiPropertySetHelper aPropSetHelper(
    1777             :                                bAutoStyles ? aParagraphPropertyNamesAuto :
    1778          87 :                                           aParagraphPropertyNames );
    1779             : 
    1780          87 :     sal_Bool bHoldElement = sal_False;
    1781          87 :     Reference < XTextContent > xTxtCntnt;
    1782         266 :     while( bHoldElement || bHasMoreElements )
    1783             :     {
    1784          92 :         if (bHoldElement)
    1785             :         {
    1786           0 :             bHoldElement = sal_False;
    1787             :         }
    1788             :         else
    1789             :         {
    1790          92 :             xTxtCntnt.set(rContEnum->nextElement(), uno::UNO_QUERY);
    1791             : 
    1792          92 :             aPropSetHelper.resetValues();
    1793             : 
    1794             :         }
    1795             : 
    1796          92 :         Reference<XServiceInfo> xServiceInfo( xTxtCntnt, UNO_QUERY );
    1797          92 :         if( xServiceInfo->supportsService( sParagraphService ) )
    1798             :         {
    1799          92 :             if( bExportLevels )
    1800             :             {
    1801          92 :                 if( bAutoStyles )
    1802             :                 {
    1803             :                     exportListAndSectionChange( xCurrentTextSection, xTxtCntnt,
    1804             :                                                 aPrevNumInfo, aNextNumInfo,
    1805          62 :                                                 bAutoStyles );
    1806             :                 }
    1807             :                 else
    1808             :                 {
    1809             :                     /* Pass list auto style pool to <XMLTextNumRuleInfo> instance
    1810             :                        Pass info about request to export <text:number> element
    1811             :                        to <XMLTextNumRuleInfo> instance (#i69627#)
    1812             :                     */
    1813             :                     aNextNumInfo.Set( xTxtCntnt,
    1814          30 :                                       GetExport().writeOutlineStyleAsNormalListStyle(),
    1815          30 :                                       GetListAutoStylePool(),
    1816          60 :                                       GetExport().exportTextNumberElement() );
    1817             : 
    1818             :                     exportListAndSectionChange( xCurrentTextSection, aPropSetHelper,
    1819             :                                                 TEXT_SECTION, xTxtCntnt,
    1820             :                                                 aPrevNumInfo, aNextNumInfo,
    1821          30 :                                                 bAutoStyles );
    1822             :                 }
    1823             :             }
    1824             : 
    1825             :             // if we found a mute section: skip all section content
    1826          92 :             if (pSectionExport->IsMuteSection(xCurrentTextSection))
    1827             :             {
    1828             :                 // Make sure headings are exported anyway.
    1829           0 :                 if( !bAutoStyles )
    1830           0 :                     pSectionExport->ExportMasterDocHeadingDummies();
    1831             : 
    1832           0 :                 while (rContEnum->hasMoreElements() &&
    1833             :                        pSectionExport->IsInSection( xCurrentTextSection,
    1834           0 :                                                     xTxtCntnt, sal_True ))
    1835             :                 {
    1836           0 :                     xTxtCntnt.set(rContEnum->nextElement(), uno::UNO_QUERY);
    1837           0 :                     aPropSetHelper.resetValues();
    1838           0 :                     aNextNumInfo.Reset();
    1839             :                 }
    1840             :                 // the first non-mute element still needs to be processed
    1841             :                 bHoldElement =
    1842             :                     ! pSectionExport->IsInSection( xCurrentTextSection,
    1843           0 :                                                    xTxtCntnt, sal_False );
    1844             :             }
    1845             :             else
    1846             :                 exportParagraph( xTxtCntnt, bAutoStyles, bIsProgress,
    1847          92 :                                  bExportParagraph, aPropSetHelper );
    1848          92 :             bHasContent = sal_True;
    1849             :         }
    1850           0 :         else if( xServiceInfo->supportsService( sTableService ) )
    1851             :         {
    1852           0 :             if( !bAutoStyles )
    1853             :             {
    1854           0 :                 aNextNumInfo.Reset();
    1855             :             }
    1856             : 
    1857             :             exportListAndSectionChange( xCurrentTextSection, xTxtCntnt,
    1858             :                                         aPrevNumInfo, aNextNumInfo,
    1859           0 :                                         bAutoStyles );
    1860             : 
    1861           0 :             if (! pSectionExport->IsMuteSection(xCurrentTextSection))
    1862             :             {
    1863             :                 // export start + end redlines (for wholly redlined tables)
    1864           0 :                 if ((! bAutoStyles) && (NULL != pRedlineExport))
    1865           0 :                     pRedlineExport->ExportStartOrEndRedline(xTxtCntnt, sal_True);
    1866             : 
    1867           0 :                 exportTable( xTxtCntnt, bAutoStyles, bIsProgress  );
    1868             : 
    1869           0 :                 if ((! bAutoStyles) && (NULL != pRedlineExport))
    1870           0 :                     pRedlineExport->ExportStartOrEndRedline(xTxtCntnt, sal_False);
    1871             :             }
    1872           0 :             else if( !bAutoStyles )
    1873             :             {
    1874             :                 // Make sure headings are exported anyway.
    1875           0 :                 pSectionExport->ExportMasterDocHeadingDummies();
    1876             :             }
    1877             : 
    1878           0 :             bHasContent = sal_True;
    1879             :         }
    1880           0 :         else if( xServiceInfo->supportsService( sTextFrameService ) )
    1881             :         {
    1882           0 :             exportTextFrame( xTxtCntnt, bAutoStyles, bIsProgress, sal_True, pRangePropSet );
    1883             :         }
    1884           0 :         else if( xServiceInfo->supportsService( sTextGraphicService ) )
    1885             :         {
    1886           0 :             exportTextGraphic( xTxtCntnt, bAutoStyles, pRangePropSet );
    1887             :         }
    1888           0 :         else if( xServiceInfo->supportsService( sTextEmbeddedService ) )
    1889             :         {
    1890           0 :             exportTextEmbedded( xTxtCntnt, bAutoStyles, pRangePropSet );
    1891             :         }
    1892           0 :         else if( xServiceInfo->supportsService( sShapeService ) )
    1893             :         {
    1894           0 :             exportShape( xTxtCntnt, bAutoStyles, pRangePropSet );
    1895             :         }
    1896             :         else
    1897             :         {
    1898             :             DBG_ASSERT( !xTxtCntnt.is(), "unknown text content" );
    1899             :         }
    1900             : 
    1901          92 :         if( !bAutoStyles )
    1902             :         {
    1903          30 :             aPrevNumInfo = aNextNumInfo;
    1904             :         }
    1905             : 
    1906          92 :         bHasMoreElements = rContEnum->hasMoreElements();
    1907          92 :     }
    1908             : 
    1909          87 :     if( bExportLevels && bHasContent && !bAutoStyles )
    1910             :     {
    1911          25 :         aNextNumInfo.Reset();
    1912             : 
    1913             :         // close open lists and sections; no new styles
    1914             :         exportListAndSectionChange( xCurrentTextSection, rBaseSection,
    1915             :                                     aPrevNumInfo, aNextNumInfo,
    1916          25 :                                     bAutoStyles );
    1917             :     }
    1918             : 
    1919          87 :     return sal_True;
    1920             : }
    1921             : 
    1922          92 : void XMLTextParagraphExport::exportParagraph(
    1923             :         const Reference < XTextContent > & rTextContent,
    1924             :         sal_Bool bAutoStyles, sal_Bool bIsProgress, sal_Bool bExportParagraph,
    1925             :         MultiPropertySetHelper& rPropSetHelper)
    1926             : {
    1927          92 :     sal_Int16 nOutlineLevel = -1;
    1928             : 
    1929          92 :     if( bIsProgress )
    1930             :     {
    1931          32 :         ProgressBarHelper *pProgress = GetExport().GetProgressBarHelper();
    1932          32 :         pProgress->SetValue( pProgress->GetValue()+1 );
    1933             :     }
    1934             : 
    1935             :     // get property set or multi property set and initialize helper
    1936          92 :     Reference<XMultiPropertySet> xMultiPropSet( rTextContent, UNO_QUERY );
    1937          92 :     Reference<XPropertySet> xPropSet( rTextContent, UNO_QUERY );
    1938             : 
    1939             :     // check for supported properties
    1940          92 :     if( !rPropSetHelper.checkedProperties() )
    1941          62 :         rPropSetHelper.hasProperties( xPropSet->getPropertySetInfo() );
    1942             : 
    1943             : //  if( xMultiPropSet.is() )
    1944             : //      rPropSetHelper.getValues( xMultiPropSet );
    1945             : //  else
    1946             : //      rPropSetHelper.getValues( xPropSet );
    1947             : 
    1948          92 :     if( bExportParagraph )
    1949             :     {
    1950          33 :         if( bAutoStyles )
    1951             :         {
    1952          13 :             Add( XML_STYLE_FAMILY_TEXT_PARAGRAPH, rPropSetHelper, xPropSet );
    1953             :         }
    1954             :         else
    1955             :         {
    1956             :             // xml:id for RDF metadata
    1957          20 :             GetExport().AddAttributeXmlId(rTextContent);
    1958          20 :             GetExport().AddAttributesRDFa(rTextContent);
    1959             : 
    1960          20 :             OUString sStyle;
    1961          20 :             if( rPropSetHelper.hasProperty( PARA_STYLE_NAME ) )
    1962             :             {
    1963          19 :                 if( xMultiPropSet.is() )
    1964             :                     rPropSetHelper.getValue( PARA_STYLE_NAME,
    1965          19 :                                                     xMultiPropSet ) >>= sStyle;
    1966             :                 else
    1967             :                     rPropSetHelper.getValue( PARA_STYLE_NAME,
    1968           0 :                                                     xPropSet ) >>= sStyle;
    1969             :             }
    1970             : 
    1971          20 :             Reference< XInterface > xRef( rTextContent, UNO_QUERY );
    1972          20 :             if( xRef.is() )
    1973             :             {
    1974          20 :                 const OUString& rIdentifier = GetExport().getInterfaceToIdentifierMapper().getIdentifier( xRef );
    1975          20 :                 if( !rIdentifier.isEmpty() )
    1976             :                 {
    1977             :                     // FIXME: this is just temporary until EditEngine
    1978             :                     // paragraphs implement XMetadatable.
    1979             :                     // then that must be used and not the mapper, because
    1980             :                     // when both can be used we get two xml:id!
    1981             :                     uno::Reference<rdf::XMetadatable> const xMeta(xRef,
    1982           0 :                         uno::UNO_QUERY);
    1983             :                     OSL_ENSURE(!xMeta.is(), "paragraph that implements "
    1984             :                         "XMetadatable used in interfaceToIdentifierMapper?");
    1985           0 :                     GetExport().AddAttributeIdLegacy(XML_NAMESPACE_TEXT,
    1986           0 :                         rIdentifier);
    1987             :                 }
    1988             :             }
    1989             : 
    1990          20 :             OUString sAutoStyle( sStyle );
    1991          20 :             sAutoStyle = Find( XML_STYLE_FAMILY_TEXT_PARAGRAPH, xPropSet, sStyle );
    1992          20 :             if( !sAutoStyle.isEmpty() )
    1993          19 :                 GetExport().AddAttribute( XML_NAMESPACE_TEXT, XML_STYLE_NAME,
    1994          38 :                               GetExport().EncodeStyleName( sAutoStyle ) );
    1995             : 
    1996          20 :             if( rPropSetHelper.hasProperty( PARA_CONDITIONAL_STYLE_NAME ) )
    1997             :             {
    1998          19 :                 OUString sCondStyle;
    1999          19 :                 if( xMultiPropSet.is() )
    2000             :                     rPropSetHelper.getValue( PARA_CONDITIONAL_STYLE_NAME,
    2001          19 :                                                      xMultiPropSet ) >>= sCondStyle;
    2002             :                 else
    2003             :                     rPropSetHelper.getValue( PARA_CONDITIONAL_STYLE_NAME,
    2004           0 :                                                      xPropSet ) >>= sCondStyle;
    2005          19 :                 if( sCondStyle != sStyle )
    2006             :                 {
    2007             :                     sCondStyle = Find( XML_STYLE_FAMILY_TEXT_PARAGRAPH, xPropSet,
    2008           0 :                                           sCondStyle );
    2009           0 :                     if( !sCondStyle.isEmpty() )
    2010           0 :                         GetExport().AddAttribute( XML_NAMESPACE_TEXT,
    2011             :                                                   XML_COND_STYLE_NAME,
    2012           0 :                               GetExport().EncodeStyleName( sCondStyle ) );
    2013          19 :                 }
    2014             :             }
    2015             : 
    2016          20 :             if( rPropSetHelper.hasProperty( PARA_OUTLINE_LEVEL ) )
    2017             :             {
    2018          19 :                 if( xMultiPropSet.is() )
    2019             :                     rPropSetHelper.getValue( PARA_OUTLINE_LEVEL,
    2020          19 :                                                      xMultiPropSet ) >>= nOutlineLevel;
    2021             :                 else
    2022             :                     rPropSetHelper.getValue( PARA_OUTLINE_LEVEL,
    2023           0 :                                                      xPropSet ) >>= nOutlineLevel;
    2024             : 
    2025          19 :                 if( 0 < nOutlineLevel )
    2026             :                 {
    2027           0 :                     OUStringBuffer sTmp;
    2028           0 :                     sTmp.append( sal_Int32( nOutlineLevel) );
    2029           0 :                     GetExport().AddAttribute( XML_NAMESPACE_TEXT,
    2030             :                                               XML_OUTLINE_LEVEL,
    2031           0 :                                   sTmp.makeStringAndClear() );
    2032             : 
    2033           0 :                     if( rPropSetHelper.hasProperty( NUMBERING_IS_NUMBER ) )
    2034             :                     {
    2035           0 :                         bool bIsNumber = false;
    2036           0 :                         if( xMultiPropSet.is() )
    2037             :                             rPropSetHelper.getValue(
    2038           0 :                                        NUMBERING_IS_NUMBER, xMultiPropSet ) >>= bIsNumber;
    2039             :                         else
    2040             :                             rPropSetHelper.getValue(
    2041           0 :                                        NUMBERING_IS_NUMBER, xPropSet ) >>= bIsNumber;
    2042             : 
    2043           0 :                         OUString sListStyleName;
    2044           0 :                         if( xMultiPropSet.is() )
    2045             :                             rPropSetHelper.getValue(
    2046           0 :                                        PARA_NUMBERING_STYLENAME, xMultiPropSet ) >>= sListStyleName;
    2047             :                         else
    2048             :                             rPropSetHelper.getValue(
    2049           0 :                                        PARA_NUMBERING_STYLENAME, xPropSet ) >>= sListStyleName;
    2050             : 
    2051             : 
    2052             : 
    2053           0 :                         bool bAssignedtoOutlineStyle = false;
    2054             :                         {
    2055           0 :                             Reference< XChapterNumberingSupplier > xCNSupplier( GetExport().GetModel(), UNO_QUERY );
    2056             : 
    2057           0 :                             OUString sOutlineName;
    2058           0 :                             if (xCNSupplier.is())
    2059             :                             {
    2060           0 :                                 Reference< XIndexReplace > xNumRule ( xCNSupplier->getChapterNumberingRules() );
    2061             :                                 DBG_ASSERT( xNumRule.is(), "no chapter numbering rules" );
    2062             : 
    2063           0 :                                 if (xNumRule.is())
    2064             :                                 {
    2065           0 :                                     Reference< XPropertySet > xNumRulePropSet( xNumRule, UNO_QUERY );
    2066           0 :                                     xNumRulePropSet->getPropertyValue(
    2067           0 :                                         OUString("Name") ) >>= sOutlineName;
    2068           0 :                                     bAssignedtoOutlineStyle = ( sListStyleName == sOutlineName );
    2069           0 :                                 }
    2070           0 :                             }
    2071             :                         }
    2072             : 
    2073           0 :                         if( ! bIsNumber && bAssignedtoOutlineStyle )
    2074           0 :                             GetExport().AddAttribute( XML_NAMESPACE_TEXT,
    2075             :                                                       XML_IS_LIST_HEADER,
    2076           0 :                                                       XML_TRUE );
    2077             :                     }
    2078             : 
    2079             :                     {
    2080             :                         rtl::OUString sParaIsNumberingRestart
    2081             :                             (RTL_CONSTASCII_USTRINGPARAM
    2082           0 :                              ("ParaIsNumberingRestart"));
    2083           0 :                         bool bIsRestartNumbering = false;
    2084             : 
    2085             :                         Reference< XPropertySetInfo >
    2086           0 :                         xPropSetInfo(xMultiPropSet.is() ?
    2087           0 :                                      xMultiPropSet->getPropertySetInfo():
    2088           0 :                                      xPropSet->getPropertySetInfo());
    2089             : 
    2090           0 :                         if (xPropSetInfo->
    2091           0 :                             hasPropertyByName(sParaIsNumberingRestart))
    2092             :                         {
    2093           0 :                             xPropSet->getPropertyValue(sParaIsNumberingRestart)
    2094           0 :                                 >>= bIsRestartNumbering;
    2095             :                         }
    2096             : 
    2097           0 :                         if (bIsRestartNumbering)
    2098             :                         {
    2099           0 :                             GetExport().AddAttribute(XML_NAMESPACE_TEXT,
    2100             :                                                      XML_RESTART_NUMBERING,
    2101           0 :                                                      XML_TRUE);
    2102             : 
    2103             :                             rtl::OUString sNumberingStartValue
    2104             :                                 (RTL_CONSTASCII_USTRINGPARAM
    2105           0 :                                  ("NumberingStartValue"));
    2106             : 
    2107             : 
    2108           0 :                             if (xPropSetInfo->
    2109           0 :                                 hasPropertyByName(sNumberingStartValue))
    2110             :                             {
    2111           0 :                                 sal_Int32 nStartValue = 0;
    2112             : 
    2113           0 :                                 xPropSet->getPropertyValue(sNumberingStartValue)
    2114           0 :                                     >>= nStartValue;
    2115             : 
    2116           0 :                                 OUStringBuffer sTmpStartValue;
    2117             : 
    2118           0 :                                 sTmpStartValue.append(nStartValue);
    2119             : 
    2120           0 :                                 GetExport().
    2121             :                                     AddAttribute(XML_NAMESPACE_TEXT,
    2122             :                                                  XML_START_VALUE,
    2123             :                                                  sTmpStartValue.
    2124           0 :                                                  makeStringAndClear());
    2125           0 :                             }
    2126           0 :                         }
    2127           0 :                     }
    2128             :                 }
    2129          20 :             }
    2130             :         }
    2131             :     }
    2132             : 
    2133          92 :     Reference < XEnumerationAccess > xEA( rTextContent, UNO_QUERY );
    2134          92 :     Reference < XEnumeration > xTextEnum;
    2135          92 :     xTextEnum = xEA->createEnumeration();
    2136          92 :     const sal_Bool bHasPortions = xTextEnum.is();
    2137             : 
    2138          92 :     Reference < XEnumeration> xContentEnum;
    2139          92 :     Reference < XContentEnumerationAccess > xCEA( rTextContent, UNO_QUERY );
    2140          92 :     if( xCEA.is() )
    2141          31 :         xContentEnum.set(xCEA->createContentEnumeration( sTextContentService ));
    2142          92 :     const sal_Bool bHasContentEnum = xContentEnum.is() &&
    2143          92 :                                         xContentEnum->hasMoreElements();
    2144             : 
    2145          92 :     Reference < XTextSection > xSection;
    2146          92 :     if( bHasContentEnum )
    2147             :     {
    2148             :         // For the auto styles, the multi property set helper is only used
    2149             :         // if hard attributes are existing. Therfor, it seems to be a better
    2150             :         // strategy to have the TextSection property seperate, because otherwise
    2151             :         // we always retrieve the style names even if they are not required.
    2152           0 :         if( bAutoStyles )
    2153             :         {
    2154           0 :             if( xPropSet->getPropertySetInfo()->hasPropertyByName( sTextSection ) )
    2155             :             {
    2156           0 :                 xSection.set(xPropSet->getPropertyValue( sTextSection ), uno::UNO_QUERY);
    2157             :             }
    2158             :         }
    2159             :         else
    2160             :         {
    2161           0 :             if( rPropSetHelper.hasProperty( TEXT_SECTION ) )
    2162             :             {
    2163           0 :                 xSection.set(rPropSetHelper.getValue( TEXT_SECTION ), uno::UNO_QUERY);
    2164             :             }
    2165             :         }
    2166             :     }
    2167             : 
    2168          92 :     if( bAutoStyles )
    2169             :     {
    2170          62 :         if( bHasContentEnum )
    2171             :             exportTextContentEnumeration(
    2172             :                                     xContentEnum, bAutoStyles, xSection,
    2173           0 :                                     bIsProgress, sal_True, 0, sal_True );
    2174          62 :         if ( bHasPortions )
    2175          62 :             exportTextRangeEnumeration( xTextEnum, bAutoStyles, bIsProgress );
    2176             :     }
    2177             :     else
    2178             :     {
    2179          30 :         sal_Bool bPrevCharIsSpace = sal_True;
    2180             :         enum XMLTokenEnum eElem =
    2181          30 :             0 < nOutlineLevel ? XML_H : XML_P;
    2182          30 :         SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_TEXT, eElem,
    2183          30 :                                   sal_True, sal_False );
    2184          30 :         if( bHasContentEnum )
    2185             :             bPrevCharIsSpace = !exportTextContentEnumeration(
    2186             :                                     xContentEnum, bAutoStyles, xSection,
    2187           0 :                                     bIsProgress );
    2188             :         exportTextRangeEnumeration( xTextEnum, bAutoStyles, bIsProgress,
    2189          30 :                                      bPrevCharIsSpace );
    2190          92 :     }
    2191          92 : }
    2192             : 
    2193          92 : void XMLTextParagraphExport::exportTextRangeEnumeration(
    2194             :         const Reference < XEnumeration > & rTextEnum,
    2195             :         sal_Bool bAutoStyles, sal_Bool bIsProgress,
    2196             :         sal_Bool bPrvChrIsSpc )
    2197             : {
    2198          92 :     static const OUString sMeta("InContentMetadata");
    2199          92 :     static const OUString sFieldMarkName("__FieldMark_");
    2200          92 :     bool bPrevCharIsSpace = bPrvChrIsSpc;
    2201          92 :     bool bAnnotationStarted = false;
    2202             : 
    2203             :     /* This is  used for exporting to strict OpenDocument 1.2, in which case traditional
    2204             :      * bookmarks are used instead of fieldmarks. */
    2205          92 :     FieldmarkType openFieldMark = NONE;
    2206             : 
    2207         317 :     while( rTextEnum->hasMoreElements() )
    2208             :     {
    2209         133 :         Reference<XPropertySet> xPropSet(rTextEnum->nextElement(), UNO_QUERY);
    2210         133 :         Reference < XTextRange > xTxtRange(xPropSet, uno::UNO_QUERY);
    2211         133 :         Reference<XPropertySetInfo> xPropInfo(xPropSet->getPropertySetInfo());
    2212             : 
    2213         133 :         if (xPropInfo->hasPropertyByName(sTextPortionType))
    2214             :         {
    2215         133 :             rtl::OUString sType;
    2216         133 :             xPropSet->getPropertyValue(sTextPortionType) >>= sType;
    2217             : 
    2218         133 :             if( sType.equals(sText))
    2219             :             {
    2220             :                 exportTextRange( xTxtRange, bAutoStyles,
    2221          98 :                                  bPrevCharIsSpace, openFieldMark);
    2222             :             }
    2223          35 :             else if( sType.equals(sTextField))
    2224             :             {
    2225          33 :                 if (bAnnotationStarted)
    2226             :                 {
    2227           1 :                     bAnnotationStarted = false;
    2228             :                 }
    2229             :                 else
    2230             :                 {
    2231          32 :                     exportTextField( xTxtRange, bAutoStyles, bIsProgress );
    2232          32 :                     bPrevCharIsSpace = false;
    2233             :                 }
    2234             :             }
    2235           2 :             else if( sType.equals( sFrame ) )
    2236             :             {
    2237           0 :                 Reference < XEnumeration> xContentEnum;
    2238             :                 Reference < XContentEnumerationAccess > xCEA( xTxtRange,
    2239           0 :                                                               UNO_QUERY );
    2240           0 :                 if( xCEA.is() )
    2241           0 :                     xContentEnum.set(xCEA->createContentEnumeration(
    2242           0 :                                                     sTextContentService ));
    2243             :                 // frames are never in sections
    2244           0 :                 Reference<XTextSection> xSection;
    2245           0 :                 if( xContentEnum.is() )
    2246             :                     exportTextContentEnumeration( xContentEnum,
    2247             :                                                     bAutoStyles,
    2248             :                                                     xSection, bIsProgress, sal_True,
    2249           0 :                                                      &xPropSet  );
    2250             : 
    2251           0 :                 bPrevCharIsSpace = false;
    2252             :             }
    2253           2 :             else if (sType.equals(sFootnote))
    2254             :             {
    2255             :                 exportTextFootnote(xPropSet,
    2256           0 :                                    xTxtRange->getString(),
    2257           0 :                                    bAutoStyles, bIsProgress );
    2258           0 :                 bPrevCharIsSpace = false;
    2259             :             }
    2260           2 :             else if (sType.equals(sBookmark))
    2261             :             {
    2262             :                 exportTextMark(xPropSet,
    2263             :                                sBookmark,
    2264             :                                lcl_XmlBookmarkElements,
    2265           0 :                                bAutoStyles);
    2266             :             }
    2267           2 :             else if (sType.equals(sReferenceMark))
    2268             :             {
    2269             :                 exportTextMark(xPropSet,
    2270             :                                sReferenceMark,
    2271             :                                lcl_XmlReferenceElements,
    2272           0 :                                bAutoStyles);
    2273             :             }
    2274           2 :             else if (sType.equals(sDocumentIndexMark))
    2275             :             {
    2276           0 :                 pIndexMarkExport->ExportIndexMark(xPropSet, bAutoStyles);
    2277             :             }
    2278           2 :             else if (sType.equals(sRedline))
    2279             :             {
    2280           0 :                 if (NULL != pRedlineExport)
    2281           0 :                     pRedlineExport->ExportChange(xPropSet, bAutoStyles);
    2282             :             }
    2283           2 :             else if (sType.equals(sRuby))
    2284             :             {
    2285           0 :                 exportRuby(xPropSet, bAutoStyles);
    2286             :             }
    2287           2 :             else if (sType.equals(sMeta))
    2288             :             {
    2289           0 :                 exportMeta(xPropSet, bAutoStyles, bIsProgress);
    2290             :             }
    2291           2 :             else if (sType.equals(sTextFieldStart))
    2292             :             {
    2293           1 :                 Reference< ::com::sun::star::text::XFormField > xFormField(xPropSet->getPropertyValue(sBookmark), UNO_QUERY);
    2294           1 :                 if (xFormField->getFieldType() == ODF_COMMENTRANGE)
    2295             :                 {
    2296           1 :                     exportTextField( xTxtRange, bAutoStyles, bIsProgress );
    2297           1 :                     bAnnotationStarted = true;
    2298           1 :                     continue;
    2299             :                 }
    2300             : 
    2301             :                 /* As of now, textmarks are a proposed extension to the OpenDocument standard. */
    2302           0 :                 if ( GetExport().getDefaultVersion() > SvtSaveOptions::ODFVER_012 )
    2303             :                 {
    2304           0 :                     Reference<XNamed> xBookmark(xPropSet->getPropertyValue(sBookmark), UNO_QUERY);
    2305           0 :                     if (xBookmark.is())
    2306             :                     {
    2307           0 :                         GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_NAME, xBookmark->getName());
    2308             :                     }
    2309           0 :                     if (xFormField.is())
    2310             :                     {
    2311           0 :                         GetExport().AddAttribute(XML_NAMESPACE_FIELD, XML_TYPE, xFormField->getFieldType());
    2312             :                     }
    2313           0 :                     GetExport().StartElement(XML_NAMESPACE_FIELD, XML_FIELDMARK_START, sal_False);
    2314           0 :                     if (xFormField.is())
    2315             :                     {
    2316           0 :                         FieldParamExporter(&GetExport(), xFormField->getParameters()).Export();
    2317             :                     }
    2318           0 :                     GetExport().EndElement(XML_NAMESPACE_FIELD, XML_FIELDMARK_START, sal_False);
    2319             :                 }
    2320             :                 /* The OpenDocument standard does not include support for TextMarks for now, so use bookmarks instead. */
    2321             :                 else
    2322             :                 {
    2323           0 :                     if (xFormField.is())
    2324             :                     {
    2325           0 :                         OUString sName;
    2326           0 :                         Reference< ::com::sun::star::container::XNameAccess > xParameters(xFormField->getParameters(), UNO_QUERY);
    2327           0 :                         if (xParameters.is() && xParameters->hasByName("Name"))
    2328             :                         {
    2329           0 :                             const Any aValue = xParameters->getByName("Name");
    2330           0 :                             aValue >>= sName;
    2331             :                         }
    2332           0 :                         if (sName.isEmpty())
    2333             :                         {   // name attribute is mandatory, so have to pull a
    2334             :                             // rabbit out of the hat here
    2335             :                             sName = sFieldMarkName + OUString::valueOf(
    2336           0 :                                     m_pImpl->AddFieldMarkStart(xFormField));
    2337             :                         }
    2338           0 :                         GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_NAME,
    2339           0 :                                 sName);
    2340           0 :                         SvXMLElementExport aElem( GetExport(), !bAutoStyles,
    2341             :                             XML_NAMESPACE_TEXT, XML_BOOKMARK_START,
    2342           0 :                             sal_False, sal_False );
    2343           0 :                         const OUString sFieldType = xFormField->getFieldType();
    2344           0 :                         if (sFieldType ==  ODF_FORMTEXT)
    2345             :                         {
    2346           0 :                             openFieldMark = TEXT;
    2347             :                         }
    2348           0 :                         else if (sFieldType == ODF_FORMCHECKBOX)
    2349             :                         {
    2350           0 :                             openFieldMark = CHECK;
    2351             :                         }
    2352             :                         else
    2353             :                         {
    2354           0 :                             openFieldMark = NONE;
    2355           0 :                         }
    2356             :                     }
    2357           1 :                 }
    2358             :             }
    2359           1 :             else if (sType.equals(sTextFieldEnd))
    2360             :             {
    2361           1 :                 if (bAnnotationStarted)
    2362             :                 {
    2363           1 :                     Reference<XNamed> xBookmark(xPropSet->getPropertyValue(sBookmark), UNO_QUERY);
    2364           1 :                     const OUString& rName = xBookmark->getName();
    2365           1 :                     if (!rName.isEmpty())
    2366           1 :                         GetExport().AddAttribute(XML_NAMESPACE_OFFICE, XML_NAME, rName);
    2367           1 :                     SvXMLElementExport aElem( GetExport(), !bAutoStyles,
    2368             :                         XML_NAMESPACE_OFFICE, XML_ANNOTATION_END,
    2369           2 :                         sal_False, sal_False );
    2370           1 :                     continue;
    2371             :                 }
    2372             : 
    2373           0 :                 if ( GetExport().getDefaultVersion() > SvtSaveOptions::ODFVER_012 )
    2374             :                 {
    2375           0 :                     SvXMLElementExport aElem( GetExport(), !bAutoStyles,
    2376             :                         XML_NAMESPACE_FIELD, XML_FIELDMARK_END,
    2377           0 :                         sal_False, sal_False );
    2378             :                 }
    2379             :                 else
    2380             :                 {
    2381           0 :                     Reference< ::com::sun::star::text::XFormField > xFormField(xPropSet->getPropertyValue(sBookmark), UNO_QUERY);
    2382           0 :                     if (xFormField.is())
    2383             :                     {
    2384           0 :                         OUString sName;
    2385           0 :                         Reference< ::com::sun::star::container::XNameAccess > xParameters(xFormField->getParameters(), UNO_QUERY);
    2386           0 :                         if (xParameters.is() && xParameters->hasByName("Name"))
    2387             :                         {
    2388           0 :                             const Any aValue = xParameters->getByName("Name");
    2389           0 :                             aValue >>= sName;
    2390             :                         }
    2391           0 :                         if (sName.isEmpty())
    2392             :                         {   // name attribute is mandatory, so have to pull a
    2393             :                             // rabbit out of the hat here
    2394             :                             sName = sFieldMarkName + OUString::valueOf(
    2395           0 :                                 m_pImpl->GetFieldMarkIndex(xFormField));
    2396             :                         }
    2397           0 :                         GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_NAME,
    2398           0 :                                 sName);
    2399           0 :                         SvXMLElementExport aElem( GetExport(), !bAutoStyles,
    2400             :                             XML_NAMESPACE_TEXT, XML_BOOKMARK_END,
    2401           0 :                             sal_False, sal_False );
    2402           0 :                     }
    2403             :                 }
    2404             :             }
    2405           0 :             else if (sType.equals(sTextFieldStartEnd))
    2406             :             {
    2407           0 :                 if ( GetExport().getDefaultVersion() > SvtSaveOptions::ODFVER_012 )
    2408             :                 {
    2409           0 :                     Reference<XNamed> xBookmark(xPropSet->getPropertyValue(sBookmark), UNO_QUERY);
    2410           0 :                     if (xBookmark.is())
    2411             :                     {
    2412           0 :                         GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_NAME, xBookmark->getName());
    2413             :                     }
    2414           0 :                     Reference< ::com::sun::star::text::XFormField > xFormField(xPropSet->getPropertyValue(sBookmark), UNO_QUERY);
    2415           0 :                     if (xFormField.is())
    2416             :                     {
    2417           0 :                         GetExport().AddAttribute(XML_NAMESPACE_FIELD, XML_TYPE, xFormField->getFieldType());
    2418             :                     }
    2419           0 :                     GetExport().StartElement(XML_NAMESPACE_FIELD, XML_FIELDMARK, sal_False);
    2420           0 :                     if (xFormField.is())
    2421             :                     {
    2422           0 :                         FieldParamExporter(&GetExport(), xFormField->getParameters()).Export();
    2423             :                     }
    2424           0 :                     GetExport().EndElement(XML_NAMESPACE_FIELD, XML_FIELDMARK, sal_False);
    2425             :                 }
    2426             :                 else
    2427             :                 {
    2428           0 :                     Reference<XNamed> xBookmark(xPropSet->getPropertyValue(sBookmark), UNO_QUERY);
    2429           0 :                     if (xBookmark.is())
    2430             :                     {
    2431           0 :                         GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_NAME, xBookmark->getName());
    2432           0 :                         SvXMLElementExport aElem( GetExport(), !bAutoStyles,
    2433             :                             XML_NAMESPACE_TEXT, XML_BOOKMARK,
    2434           0 :                             sal_False, sal_False );
    2435           0 :                     }
    2436             :                 }
    2437             :             }
    2438           0 :             else if (sType.equals(sSoftPageBreak))
    2439             :             {
    2440           0 :                 exportSoftPageBreak(xPropSet,   bAutoStyles);
    2441             :             }
    2442             :             else {
    2443             :                 OSL_FAIL("unknown text portion type");
    2444         133 :             }
    2445             :         }
    2446             :         else
    2447             :         {
    2448           0 :             Reference<XServiceInfo> xServiceInfo( xTxtRange, UNO_QUERY );
    2449           0 :             if( xServiceInfo->supportsService( sTextFieldService ) )
    2450             :             {
    2451           0 :                 exportTextField( xTxtRange, bAutoStyles, bIsProgress );
    2452           0 :                 bPrevCharIsSpace = false;
    2453             :             }
    2454             :             else
    2455             :             {
    2456             :                 // no TextPortionType property -> non-Writer app -> text
    2457           0 :                 exportTextRange( xTxtRange, bAutoStyles, bPrevCharIsSpace, openFieldMark );
    2458           0 :             }
    2459             :         }
    2460         133 :     }
    2461             : 
    2462             : // now that there are nested enumerations for meta(-field), this may be valid!
    2463             : //  DBG_ASSERT( !bOpenRuby, "Red Alert: Ruby still open!" );
    2464          92 : }
    2465             : 
    2466           0 : void XMLTextParagraphExport::exportTable(
    2467             :         const Reference < XTextContent > &,
    2468             :         sal_Bool /*bAutoStyles*/, sal_Bool /*bIsProgress*/ )
    2469             : {
    2470           0 : }
    2471             : 
    2472          33 : void XMLTextParagraphExport::exportTextField(
    2473             :         const Reference < XTextRange > & rTextRange,
    2474             :         sal_Bool bAutoStyles, sal_Bool bIsProgress )
    2475             : {
    2476          33 :     Reference < XPropertySet > xPropSet( rTextRange, UNO_QUERY );
    2477             :     // non-Writer apps need not support Property TextField, so test first
    2478          33 :     if (xPropSet->getPropertySetInfo()->hasPropertyByName( sTextField ))
    2479             :     {
    2480          33 :         Reference < XTextField > xTxtFld(xPropSet->getPropertyValue( sTextField ), uno::UNO_QUERY);
    2481             :         DBG_ASSERT( xTxtFld.is(), "text field missing" );
    2482          33 :         if( xTxtFld.is() )
    2483             :         {
    2484          33 :             exportTextField(xTxtFld, bAutoStyles, bIsProgress, sal_True);
    2485             :         }
    2486             :         else
    2487             :         {
    2488             :             // write only characters
    2489           0 :             GetExport().Characters(rTextRange->getString());
    2490          33 :         }
    2491          33 :     }
    2492          33 : }
    2493             : 
    2494          34 : void XMLTextParagraphExport::exportTextField(
    2495             :         const Reference < XTextField > & xTextField,
    2496             :         const sal_Bool bAutoStyles, const sal_Bool bIsProgress,
    2497             :         const sal_Bool bRecursive )
    2498             : {
    2499          34 :     if ( bAutoStyles )
    2500             :     {
    2501             :         pFieldExport->ExportFieldAutoStyle( xTextField, bIsProgress,
    2502          17 :                 bRecursive );
    2503             :     }
    2504             :     else
    2505             :     {
    2506          17 :         pFieldExport->ExportField( xTextField, bIsProgress );
    2507             :     }
    2508          34 : }
    2509             : 
    2510           0 : void XMLTextParagraphExport::exportSoftPageBreak(
    2511             :     const Reference<XPropertySet> & ,
    2512             :     sal_Bool )
    2513             : {
    2514           0 :     SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_TEXT,
    2515             :                               XML_SOFT_PAGE_BREAK, sal_False,
    2516           0 :                               sal_False );
    2517           0 : }
    2518             : 
    2519           0 : void XMLTextParagraphExport::exportTextMark(
    2520             :     const Reference<XPropertySet> & rPropSet,
    2521             :     const OUString& rProperty,
    2522             :     const enum XMLTokenEnum pElements[],
    2523             :     sal_Bool bAutoStyles)
    2524             : {
    2525             :     // mib said: "Hau wech!"
    2526             :     //
    2527             :     // (Originally, I'd export a span element in case the (book|reference)mark
    2528             :     //  was formatted. This actually makes a difference in case some pervert
    2529             :     //  sets a point reference mark in the document and, say, formats it bold.
    2530             :     //  This basically meaningless formatting will now been thrown away
    2531             :     //  (aka cleaned up), since mib said: ...                   dvo
    2532             : 
    2533           0 :      if (!bAutoStyles)
    2534             :     {
    2535             :         // name element
    2536           0 :         Reference<XNamed> xName(rPropSet->getPropertyValue(rProperty), UNO_QUERY);
    2537           0 :         GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_NAME,
    2538           0 :                                  xName->getName());
    2539             : 
    2540             :         // start, end, or point-reference?
    2541             :         sal_Int8 nElement;
    2542           0 :         if( *(sal_Bool *)rPropSet->getPropertyValue(sIsCollapsed).getValue() )
    2543             :         {
    2544           0 :             nElement = 0;
    2545             :         }
    2546             :         else
    2547             :         {
    2548           0 :             nElement = *(sal_Bool *)rPropSet->getPropertyValue(sIsStart).getValue() ? 1 : 2;
    2549             :         }
    2550             : 
    2551             :         // bookmark, bookmark-start: xml:id and RDFa for RDF metadata
    2552           0 :         if( nElement < 2 ) {
    2553           0 :             GetExport().AddAttributeXmlId(xName);
    2554             :             const uno::Reference<text::XTextContent> xTextContent(
    2555           0 :                     xName, uno::UNO_QUERY_THROW);
    2556           0 :             GetExport().AddAttributesRDFa(xTextContent);
    2557             :         }
    2558             : 
    2559             :         // export element
    2560             :         DBG_ASSERT(pElements != NULL, "illegal element array");
    2561             :         DBG_ASSERT(nElement >= 0, "illegal element number");
    2562             :         DBG_ASSERT(nElement <= 2, "illegal element number");
    2563           0 :         SvXMLElementExport aElem(GetExport(),
    2564           0 :                                  XML_NAMESPACE_TEXT, pElements[nElement],
    2565           0 :                                  sal_False, sal_False);
    2566             :     }
    2567             :     // else: no styles. (see above)
    2568           0 : }
    2569             : 
    2570           0 : static sal_Bool lcl_txtpara_isBoundAsChar(
    2571             :         const Reference < XPropertySet > & rPropSet,
    2572             :         const Reference < XPropertySetInfo > & rPropSetInfo )
    2573             : {
    2574           0 :     sal_Bool bIsBoundAsChar = sal_False;
    2575           0 :     OUString sAnchorType( "AnchorType"  );
    2576           0 :     if( rPropSetInfo->hasPropertyByName( sAnchorType ) )
    2577             :     {
    2578             :         TextContentAnchorType eAnchor;
    2579           0 :         rPropSet->getPropertyValue( sAnchorType ) >>= eAnchor;
    2580           0 :         bIsBoundAsChar = TextContentAnchorType_AS_CHARACTER == eAnchor;
    2581             :     }
    2582             : 
    2583           0 :     return bIsBoundAsChar;
    2584             : }
    2585             : 
    2586           0 : sal_Int32 XMLTextParagraphExport::addTextFrameAttributes(
    2587             :     const Reference < XPropertySet >& rPropSet,
    2588             :     sal_Bool bShape,
    2589             :     OUString *pMinHeightValue,
    2590             :     OUString *pMinWidthValue)
    2591             : {
    2592           0 :     sal_Int32 nShapeFeatures = SEF_DEFAULT;
    2593             : 
    2594             :     // draw:name (#97662#: not for shapes, since those names will be
    2595             :     // treated in the shape export)
    2596           0 :     if( !bShape )
    2597             :     {
    2598           0 :         Reference < XNamed > xNamed( rPropSet, UNO_QUERY );
    2599           0 :         if( xNamed.is() )
    2600             :         {
    2601           0 :             OUString sName( xNamed->getName() );
    2602           0 :             if( !sName.isEmpty() )
    2603           0 :                 GetExport().AddAttribute( XML_NAMESPACE_DRAW, XML_NAME,
    2604           0 :                                           xNamed->getName() );
    2605           0 :         }
    2606             :     }
    2607             : 
    2608           0 :     OUStringBuffer sValue;
    2609             : 
    2610             :     // text:anchor-type
    2611           0 :     TextContentAnchorType eAnchor = TextContentAnchorType_AT_PARAGRAPH;
    2612           0 :     rPropSet->getPropertyValue( sAnchorType ) >>= eAnchor;
    2613             :     {
    2614           0 :         XMLAnchorTypePropHdl aAnchorTypeHdl;
    2615           0 :         OUString sTmp;
    2616             :         aAnchorTypeHdl.exportXML( sTmp, uno::makeAny(eAnchor),
    2617           0 :                                   GetExport().GetMM100UnitConverter() );
    2618           0 :         GetExport().AddAttribute( XML_NAMESPACE_TEXT, XML_ANCHOR_TYPE, sTmp );
    2619             :     }
    2620             : 
    2621             :     // text:anchor-page-number
    2622           0 :     if( TextContentAnchorType_AT_PAGE == eAnchor )
    2623             :     {
    2624           0 :         sal_Int16 nPage = 0;
    2625           0 :         rPropSet->getPropertyValue( sAnchorPageNo ) >>= nPage;
    2626             :         SAL_WARN_IF(nPage <= 0, "xmloff",
    2627             :                 "ERROR: writing invalid anchor-page-number 0");
    2628           0 :         ::sax::Converter::convertNumber( sValue, (sal_Int32)nPage );
    2629           0 :         GetExport().AddAttribute( XML_NAMESPACE_TEXT, XML_ANCHOR_PAGE_NUMBER,
    2630           0 :                                   sValue.makeStringAndClear() );
    2631             :     }
    2632             :     else
    2633             :     {
    2634             :         // #92210#
    2635           0 :         nShapeFeatures |= SEF_EXPORT_NO_WS;
    2636             :     }
    2637             : 
    2638             :     // OD 2004-06-01 #i27691# - correction: no export of svg:x, if object
    2639             :     // is anchored as-character.
    2640           0 :     if ( !bShape &&
    2641             :          eAnchor != TextContentAnchorType_AS_CHARACTER )
    2642             :     {
    2643             :         // svg:x
    2644           0 :         sal_Int16 nHoriOrient =  HoriOrientation::NONE;
    2645           0 :         rPropSet->getPropertyValue( sHoriOrient ) >>= nHoriOrient;
    2646           0 :         if( HoriOrientation::NONE == nHoriOrient )
    2647             :         {
    2648           0 :             sal_Int32 nPos = 0;
    2649           0 :             rPropSet->getPropertyValue( sHoriOrientPosition ) >>= nPos;
    2650           0 :             GetExport().GetMM100UnitConverter().convertMeasureToXML(
    2651           0 :                     sValue, nPos );
    2652           0 :             GetExport().AddAttribute( XML_NAMESPACE_SVG, XML_X,
    2653           0 :                                       sValue.makeStringAndClear() );
    2654           0 :         }
    2655             :     }
    2656           0 :     else if( TextContentAnchorType_AS_CHARACTER == eAnchor )
    2657           0 :         nShapeFeatures = (nShapeFeatures & ~SEF_EXPORT_X);
    2658             : 
    2659           0 :     if( !bShape || TextContentAnchorType_AS_CHARACTER == eAnchor  )
    2660             :     {
    2661             :         // svg:y
    2662           0 :         sal_Int16 nVertOrient =  VertOrientation::NONE;
    2663           0 :         rPropSet->getPropertyValue( sVertOrient ) >>= nVertOrient;
    2664           0 :         if( VertOrientation::NONE == nVertOrient )
    2665             :         {
    2666           0 :             sal_Int32 nPos = 0;
    2667           0 :             rPropSet->getPropertyValue( sVertOrientPosition ) >>= nPos;
    2668           0 :             GetExport().GetMM100UnitConverter().convertMeasureToXML(
    2669           0 :                     sValue, nPos );
    2670           0 :             GetExport().AddAttribute( XML_NAMESPACE_SVG, XML_Y,
    2671           0 :                                       sValue.makeStringAndClear() );
    2672             :         }
    2673           0 :         if( bShape )
    2674           0 :             nShapeFeatures = (nShapeFeatures & ~SEF_EXPORT_Y);
    2675             :     }
    2676             : 
    2677             : 
    2678           0 :     Reference< XPropertySetInfo > xPropSetInfo(rPropSet->getPropertySetInfo());
    2679             : 
    2680             :     // svg:width
    2681           0 :     sal_Int16 nWidthType = SizeType::FIX;
    2682           0 :     if( xPropSetInfo->hasPropertyByName( sWidthType ) )
    2683             :     {
    2684           0 :         rPropSet->getPropertyValue( sWidthType ) >>= nWidthType;
    2685             :     }
    2686           0 :     if( xPropSetInfo->hasPropertyByName( sWidth ) )
    2687             :     {
    2688           0 :         sal_Int32 nWidth =  0;
    2689             :         // VAR size will be written as zero min-size
    2690           0 :         if( SizeType::VARIABLE != nWidthType )
    2691             :         {
    2692           0 :             rPropSet->getPropertyValue( sWidth ) >>= nWidth;
    2693             :         }
    2694           0 :         GetExport().GetMM100UnitConverter().convertMeasureToXML(sValue, nWidth);
    2695           0 :         if( SizeType::FIX != nWidthType )
    2696             :         {
    2697             :             assert(pMinWidthValue);
    2698           0 :             if (pMinWidthValue)
    2699             :             {
    2700           0 :                 *pMinWidthValue = sValue.makeStringAndClear();
    2701             :             }
    2702             :         }
    2703             :         else
    2704           0 :             GetExport().AddAttribute( XML_NAMESPACE_SVG, XML_WIDTH,
    2705           0 :                                       sValue.makeStringAndClear() );
    2706             :     }
    2707           0 :     sal_Bool bSyncWidth = sal_False;
    2708           0 :     if( xPropSetInfo->hasPropertyByName( sIsSyncWidthToHeight ) )
    2709             :     {
    2710           0 :         bSyncWidth = *(sal_Bool *)rPropSet->getPropertyValue( sIsSyncWidthToHeight ).getValue();
    2711           0 :         if( bSyncWidth )
    2712           0 :             GetExport().AddAttribute( XML_NAMESPACE_STYLE, XML_REL_WIDTH,
    2713           0 :                                       XML_SCALE );
    2714             :     }
    2715           0 :     if( !bSyncWidth && xPropSetInfo->hasPropertyByName( sRelativeWidth ) )
    2716             :     {
    2717           0 :         sal_Int16 nRelWidth =  0;
    2718           0 :         rPropSet->getPropertyValue( sRelativeWidth ) >>= nRelWidth;
    2719             :         DBG_ASSERT( nRelWidth >= 0 && nRelWidth <= 254,
    2720             :                     "Got illegal relative width from API" );
    2721           0 :         if( nRelWidth > 0 )
    2722             :         {
    2723           0 :             ::sax::Converter::convertPercent( sValue, nRelWidth );
    2724           0 :             GetExport().AddAttribute( XML_NAMESPACE_STYLE, XML_REL_WIDTH,
    2725           0 :                                       sValue.makeStringAndClear() );
    2726             :         }
    2727             :     }
    2728             : 
    2729             :     // svg:height, fo:min-height or style:rel-height
    2730           0 :     sal_Int16 nSizeType = SizeType::FIX;
    2731           0 :     if( xPropSetInfo->hasPropertyByName( sSizeType ) )
    2732             :     {
    2733           0 :         rPropSet->getPropertyValue( sSizeType ) >>= nSizeType;
    2734             :     }
    2735           0 :     sal_Bool bSyncHeight = sal_False;
    2736           0 :     if( xPropSetInfo->hasPropertyByName( sIsSyncHeightToWidth ) )
    2737             :     {
    2738           0 :         bSyncHeight = *(sal_Bool *)rPropSet->getPropertyValue( sIsSyncHeightToWidth ).getValue();
    2739             :     }
    2740           0 :     sal_Int16 nRelHeight =  0;
    2741           0 :     if( !bSyncHeight && xPropSetInfo->hasPropertyByName( sRelativeHeight ) )
    2742             :     {
    2743           0 :         rPropSet->getPropertyValue( sRelativeHeight ) >>= nRelHeight;
    2744             :     }
    2745           0 :     if( xPropSetInfo->hasPropertyByName( sHeight ) )
    2746             :     {
    2747           0 :         sal_Int32 nHeight =  0;
    2748           0 :         if( SizeType::VARIABLE != nSizeType )
    2749             :         {
    2750           0 :             rPropSet->getPropertyValue( sHeight ) >>= nHeight;
    2751             :         }
    2752           0 :         GetExport().GetMM100UnitConverter().convertMeasureToXML( sValue,
    2753           0 :                                                             nHeight );
    2754           0 :         if( SizeType::FIX != nSizeType && 0==nRelHeight && !bSyncHeight &&
    2755             :              pMinHeightValue )
    2756           0 :             *pMinHeightValue = sValue.makeStringAndClear();
    2757             :         else
    2758           0 :             GetExport().AddAttribute( XML_NAMESPACE_SVG, XML_HEIGHT,
    2759           0 :                                       sValue.makeStringAndClear() );
    2760             :     }
    2761           0 :     if( bSyncHeight )
    2762             :     {
    2763           0 :         GetExport().AddAttribute( XML_NAMESPACE_STYLE, XML_REL_HEIGHT,
    2764           0 :                 SizeType::MIN == nSizeType ? XML_SCALE_MIN : XML_SCALE );
    2765             : 
    2766             :     }
    2767           0 :     else if( nRelHeight > 0 )
    2768             :     {
    2769           0 :         ::sax::Converter::convertPercent( sValue, nRelHeight );
    2770           0 :         if( SizeType::MIN == nSizeType )
    2771             :         {
    2772             :             assert(pMinHeightValue);
    2773           0 :             if (pMinHeightValue)
    2774             :             {
    2775           0 :                 *pMinHeightValue = sValue.makeStringAndClear();
    2776             :             }
    2777             :         }
    2778             :         else
    2779           0 :             GetExport().AddAttribute( XML_NAMESPACE_STYLE, XML_REL_HEIGHT,
    2780           0 :                                       sValue.makeStringAndClear() );
    2781             :     }
    2782             : 
    2783           0 :     OUString sZOrder( "ZOrder"  );
    2784           0 :     if( xPropSetInfo->hasPropertyByName( sZOrder ) )
    2785             :     {
    2786           0 :         sal_Int32 nZIndex = 0;
    2787           0 :         rPropSet->getPropertyValue( sZOrder ) >>= nZIndex;
    2788           0 :         if( -1 != nZIndex )
    2789             :         {
    2790           0 :             ::sax::Converter::convertNumber( sValue, nZIndex );
    2791           0 :             GetExport().AddAttribute( XML_NAMESPACE_DRAW, XML_ZINDEX,
    2792           0 :                                       sValue.makeStringAndClear() );
    2793             :         }
    2794             :     }
    2795             : 
    2796           0 :     return nShapeFeatures;
    2797             : }
    2798             : 
    2799           0 : void XMLTextParagraphExport::exportAnyTextFrame(
    2800             :         const Reference < XTextContent > & rTxtCntnt,
    2801             :         FrameType eType,
    2802             :         sal_Bool bAutoStyles,
    2803             :         sal_Bool bIsProgress,
    2804             :         sal_Bool bExportContent,
    2805             :         const Reference < XPropertySet > *pRangePropSet)
    2806             : {
    2807           0 :     Reference < XPropertySet > xPropSet( rTxtCntnt, UNO_QUERY );
    2808             : 
    2809           0 :     if( bAutoStyles )
    2810             :     {
    2811           0 :         if( FT_EMBEDDED == eType )
    2812           0 :             _collectTextEmbeddedAutoStyles( xPropSet );
    2813             :         // No text frame style for shapes (#i28745#)
    2814           0 :         else if ( FT_SHAPE != eType )
    2815           0 :             Add( XML_STYLE_FAMILY_TEXT_FRAME, xPropSet );
    2816             : 
    2817           0 :         if( pRangePropSet && lcl_txtpara_isBoundAsChar( xPropSet,
    2818           0 :                                             xPropSet->getPropertySetInfo() ) )
    2819           0 :             Add( XML_STYLE_FAMILY_TEXT_TEXT, *pRangePropSet );
    2820             : 
    2821           0 :         switch( eType )
    2822             :         {
    2823             :         case FT_TEXT:
    2824             :             {
    2825             :                 // frame bound frames
    2826           0 :                 if ( bExportContent )
    2827             :                 {
    2828           0 :                     Reference < XTextFrame > xTxtFrame( rTxtCntnt, UNO_QUERY );
    2829           0 :                     Reference < XText > xTxt(xTxtFrame->getText());
    2830           0 :                     exportFrameFrames( sal_True, bIsProgress, &xTxtFrame );
    2831           0 :                     exportText( xTxt, bAutoStyles, bIsProgress, sal_True );
    2832             :                 }
    2833             :             }
    2834           0 :             break;
    2835             :         case FT_SHAPE:
    2836             :             {
    2837           0 :                 Reference < XShape > xShape( rTxtCntnt, UNO_QUERY );
    2838           0 :                 GetExport().GetShapeExport()->collectShapeAutoStyles( xShape );
    2839             :             }
    2840           0 :             break;
    2841             :         default:
    2842           0 :             break;
    2843             :         }
    2844             :     }
    2845             :     else
    2846             :     {
    2847           0 :         Reference< XPropertySetInfo > xPropSetInfo(xPropSet->getPropertySetInfo());
    2848           0 :         Reference< XPropertyState > xPropState( xPropSet, UNO_QUERY );
    2849             :         {
    2850             :             sal_Bool bAddCharStyles = pRangePropSet &&
    2851           0 :                 lcl_txtpara_isBoundAsChar( xPropSet, xPropSetInfo );
    2852             : 
    2853             :             sal_Bool bIsUICharStyle;
    2854           0 :             sal_Bool bHasAutoStyle = sal_False;
    2855             :             sal_Bool bDummy;
    2856             : 
    2857           0 :             OUString sStyle;
    2858             : 
    2859           0 :             if( bAddCharStyles )
    2860           0 :                    sStyle = FindTextStyleAndHyperlink( *pRangePropSet, bDummy, bIsUICharStyle, bHasAutoStyle );
    2861             :             else
    2862           0 :                 bIsUICharStyle = sal_False;
    2863             : 
    2864             :             XMLTextCharStyleNamesElementExport aCharStylesExport(
    2865           0 :                 GetExport(), bIsUICharStyle &&
    2866             :                              aCharStyleNamesPropInfoCache.hasProperty(
    2867           0 :                                             *pRangePropSet ), bHasAutoStyle,
    2868           0 :                 *pRangePropSet, sCharStyleNames );
    2869             : 
    2870           0 :             if( !sStyle.isEmpty() )
    2871           0 :                 GetExport().AddAttribute( XML_NAMESPACE_TEXT, XML_STYLE_NAME,
    2872           0 :                                   GetExport().EncodeStyleName( sStyle ) );
    2873             :             {
    2874           0 :                 SvXMLElementExport aElem( GetExport(), !sStyle.isEmpty(),
    2875           0 :                     XML_NAMESPACE_TEXT, XML_SPAN, sal_False, sal_False );
    2876             :                 {
    2877           0 :                     SvXMLElementExport aElement( GetExport(),
    2878             :                         FT_SHAPE != eType &&
    2879             :                         addHyperlinkAttributes( xPropSet,
    2880           0 :                                                 xPropState,xPropSetInfo ),
    2881           0 :                         XML_NAMESPACE_DRAW, XML_A, sal_False, sal_False );
    2882           0 :                     switch( eType )
    2883             :                     {
    2884             :                     case FT_TEXT:
    2885           0 :                         _exportTextFrame( xPropSet, xPropSetInfo, bIsProgress );
    2886           0 :                         break;
    2887             :                     case FT_GRAPHIC:
    2888           0 :                         _exportTextGraphic( xPropSet, xPropSetInfo );
    2889           0 :                         break;
    2890             :                     case FT_EMBEDDED:
    2891           0 :                         _exportTextEmbedded( xPropSet, xPropSetInfo );
    2892           0 :                         break;
    2893             :                     case FT_SHAPE:
    2894             :                         {
    2895           0 :                             Reference < XShape > xShape( rTxtCntnt, UNO_QUERY );
    2896             :                             sal_Int32 nFeatures =
    2897           0 :                                 addTextFrameAttributes( xPropSet, sal_True );
    2898           0 :                             GetExport().GetShapeExport()
    2899           0 :                                 ->exportShape( xShape, nFeatures );
    2900             :                         }
    2901           0 :                         break;
    2902           0 :                     }
    2903           0 :                 }
    2904           0 :             }
    2905           0 :         }
    2906           0 :     }
    2907           0 : }
    2908             : 
    2909           0 : void XMLTextParagraphExport::_exportTextFrame(
    2910             :         const Reference < XPropertySet > & rPropSet,
    2911             :         const Reference < XPropertySetInfo > & rPropSetInfo,
    2912             :         sal_Bool bIsProgress )
    2913             : {
    2914           0 :     Reference < XTextFrame > xTxtFrame( rPropSet, UNO_QUERY );
    2915           0 :     Reference < XText > xTxt(xTxtFrame->getText());
    2916             : 
    2917           0 :     OUString sStyle;
    2918           0 :     if( rPropSetInfo->hasPropertyByName( sFrameStyleName ) )
    2919             :     {
    2920           0 :         rPropSet->getPropertyValue( sFrameStyleName ) >>= sStyle;
    2921             :     }
    2922             : 
    2923           0 :     OUString sAutoStyle( sStyle );
    2924           0 :     OUString aMinHeightValue;
    2925           0 :     OUString sMinWidthValue;
    2926           0 :     sAutoStyle = Find( XML_STYLE_FAMILY_TEXT_FRAME, rPropSet, sStyle );
    2927           0 :     if( !sAutoStyle.isEmpty() )
    2928           0 :         GetExport().AddAttribute( XML_NAMESPACE_DRAW, XML_STYLE_NAME,
    2929           0 :                               GetExport().EncodeStyleName( sAutoStyle ) );
    2930           0 :     addTextFrameAttributes(rPropSet, false, &aMinHeightValue, &sMinWidthValue);
    2931             : 
    2932           0 :     SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_DRAW,
    2933           0 :                               XML_FRAME, sal_False, sal_True );
    2934             : 
    2935           0 :     if( !aMinHeightValue.isEmpty() )
    2936           0 :         GetExport().AddAttribute( XML_NAMESPACE_FO, XML_MIN_HEIGHT,
    2937           0 :                                   aMinHeightValue );
    2938             : 
    2939           0 :     if (!sMinWidthValue.isEmpty())
    2940             :     {
    2941           0 :         GetExport().AddAttribute( XML_NAMESPACE_FO, XML_MIN_WIDTH,
    2942           0 :                                   sMinWidthValue );
    2943             :     }
    2944             : 
    2945             :     // draw:chain-next-name
    2946           0 :     if( rPropSetInfo->hasPropertyByName( sChainNextName ) )
    2947             :     {
    2948           0 :         OUString sNext;
    2949           0 :         if( (rPropSet->getPropertyValue( sChainNextName ) >>= sNext) && !sNext.isEmpty() )
    2950           0 :             GetExport().AddAttribute( XML_NAMESPACE_DRAW,
    2951             :                                       XML_CHAIN_NEXT_NAME,
    2952           0 :                                       sNext );
    2953             :     }
    2954             : 
    2955             :     {
    2956           0 :         SvXMLElementExport aElement( GetExport(), XML_NAMESPACE_DRAW,
    2957           0 :                                   XML_TEXT_BOX, sal_True, sal_True );
    2958             : 
    2959             :         // frame bound frames
    2960           0 :         exportFramesBoundToFrame( xTxtFrame, bIsProgress );
    2961             : 
    2962           0 :         exportText( xTxt, sal_False, bIsProgress, sal_True );
    2963             :     }
    2964             : 
    2965             :     // script:events
    2966           0 :     Reference<XEventsSupplier> xEventsSupp( xTxtFrame, UNO_QUERY );
    2967           0 :     GetExport().GetEventExport().Export(xEventsSupp);
    2968             : 
    2969             :     // image map
    2970           0 :     GetExport().GetImageMapExport().Export( rPropSet );
    2971             : 
    2972             :     // svg:title and svg:desc (#i73249#)
    2973           0 :     exportTitleAndDescription( rPropSet, rPropSetInfo );
    2974           0 : }
    2975             : 
    2976           0 : void XMLTextParagraphExport::exportContour(
    2977             :         const Reference < XPropertySet > & rPropSet,
    2978             :         const Reference < XPropertySetInfo > & rPropSetInfo )
    2979             : {
    2980           0 :     if( !rPropSetInfo->hasPropertyByName( sContourPolyPolygon ) )
    2981             :         return;
    2982             : 
    2983           0 :     PointSequenceSequence aSourcePolyPolygon;
    2984           0 :     rPropSet->getPropertyValue( sContourPolyPolygon ) >>= aSourcePolyPolygon;
    2985             : 
    2986           0 :     if( !aSourcePolyPolygon.getLength() )
    2987             :         return;
    2988             : 
    2989           0 :     awt::Point aPoint( 0, 0 );
    2990           0 :     awt::Size aSize( 0, 0 );
    2991           0 :     sal_Int32 nPolygons = aSourcePolyPolygon.getLength();
    2992           0 :     const PointSequence *pPolygons = aSourcePolyPolygon.getConstArray();
    2993           0 :     while( nPolygons-- )
    2994             :     {
    2995           0 :         sal_Int32 nPoints = pPolygons->getLength();
    2996           0 :         const awt::Point *pPoints = pPolygons->getConstArray();
    2997           0 :         while( nPoints-- )
    2998             :         {
    2999           0 :             if( aSize.Width < pPoints->X )
    3000           0 :                 aSize.Width = pPoints->X;
    3001           0 :             if( aSize.Height < pPoints->Y )
    3002           0 :                 aSize.Height = pPoints->Y;
    3003           0 :             pPoints++;
    3004             :         }
    3005           0 :         pPolygons++;
    3006             :     }
    3007             : 
    3008           0 :     sal_Bool bPixel = sal_False;
    3009           0 :     if( rPropSetInfo->hasPropertyByName( sIsPixelContour ) )
    3010             :     {
    3011           0 :         bPixel = *(sal_Bool *)rPropSet->getPropertyValue( sIsPixelContour ).getValue();
    3012             :     }
    3013             : 
    3014             :     // svg: width
    3015           0 :     OUStringBuffer aStringBuffer( 10 );
    3016           0 :     if( bPixel )
    3017             :     {
    3018           0 :         ::sax::Converter::convertMeasurePx(aStringBuffer, aSize.Width);
    3019             :     }
    3020             :     else
    3021             :     {
    3022           0 :         GetExport().GetMM100UnitConverter().convertMeasureToXML(
    3023           0 :                 aStringBuffer, aSize.Width);
    3024             :     }
    3025           0 :     GetExport().AddAttribute( XML_NAMESPACE_SVG, XML_WIDTH,
    3026           0 :                               aStringBuffer.makeStringAndClear() );
    3027             : 
    3028             :     // svg: height
    3029           0 :     if( bPixel )
    3030             :     {
    3031           0 :         ::sax::Converter::convertMeasurePx(aStringBuffer, aSize.Height);
    3032             :     }
    3033             :     else
    3034             :     {
    3035           0 :         GetExport().GetMM100UnitConverter().convertMeasureToXML(
    3036           0 :                 aStringBuffer, aSize.Height);
    3037             :     }
    3038           0 :     GetExport().AddAttribute( XML_NAMESPACE_SVG, XML_HEIGHT,
    3039           0 :                               aStringBuffer.makeStringAndClear() );
    3040             : 
    3041             :     // svg:viewbox
    3042           0 :     SdXMLImExViewBox aViewBox(0, 0, aSize.Width, aSize.Height);
    3043           0 :     GetExport().AddAttribute(XML_NAMESPACE_SVG, XML_VIEWBOX,
    3044           0 :                 aViewBox.GetExportString());
    3045             : 
    3046           0 :     sal_Int32 nOuterCnt( aSourcePolyPolygon.getLength() );
    3047             : 
    3048           0 :     enum XMLTokenEnum eElem = XML_TOKEN_INVALID;
    3049           0 :     if( 1L == nOuterCnt )
    3050             :     {
    3051             :         // simple polygon shape, can be written as svg:points sequence
    3052             :         /*const*/ PointSequence* pSequence =
    3053           0 :                             (PointSequence*)aSourcePolyPolygon.getConstArray();
    3054             : 
    3055           0 :         SdXMLImExPointsElement aPoints( pSequence, aViewBox, aPoint, aSize );
    3056             : 
    3057             :         // write point array
    3058           0 :         GetExport().AddAttribute( XML_NAMESPACE_DRAW, XML_POINTS,
    3059           0 :                                       aPoints.GetExportString());
    3060           0 :         eElem = XML_CONTOUR_POLYGON;
    3061             :     }
    3062             :     else
    3063             :     {
    3064             :         // polypolygon, needs to be written as a svg:path sequence
    3065             :         /*const*/ PointSequence* pOuterSequence =
    3066           0 :                         (PointSequence*)aSourcePolyPolygon.getConstArray();
    3067           0 :         if(pOuterSequence)
    3068             :         {
    3069             :             // prepare svx:d element export
    3070           0 :             SdXMLImExSvgDElement aSvgDElement( aViewBox, GetExport() );
    3071             : 
    3072           0 :             for(sal_Int32 a(0L); a < nOuterCnt; a++)
    3073             :             {
    3074           0 :                 /*const*/ PointSequence* pSequence = pOuterSequence++;
    3075           0 :                 if(pSequence)
    3076             :                 {
    3077             :                     aSvgDElement.AddPolygon(pSequence, 0L, aPoint,
    3078           0 :                         aSize, sal_True );
    3079             :                 }
    3080             :             }
    3081             : 
    3082             :             // write point array
    3083           0 :             GetExport().AddAttribute( XML_NAMESPACE_SVG, XML_D,
    3084           0 :                                       aSvgDElement.GetExportString());
    3085           0 :             eElem = XML_CONTOUR_PATH;
    3086             :         }
    3087             :     }
    3088             : 
    3089           0 :     if( rPropSetInfo->hasPropertyByName( sIsAutomaticContour ) )
    3090             :     {
    3091           0 :         sal_Bool bTmp = *(sal_Bool *)rPropSet->getPropertyValue(
    3092           0 :                                             sIsAutomaticContour ).getValue();
    3093           0 :         GetExport().AddAttribute( XML_NAMESPACE_DRAW,
    3094           0 :                       XML_RECREATE_ON_EDIT, bTmp ? XML_TRUE : XML_FALSE );
    3095             :     }
    3096             : 
    3097             :     // write object now
    3098           0 :     SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_DRAW, eElem,
    3099           0 :                               sal_True, sal_True );
    3100             : }
    3101             : 
    3102           0 : void XMLTextParagraphExport::_exportTextGraphic(
    3103             :         const Reference < XPropertySet > & rPropSet,
    3104             :         const Reference < XPropertySetInfo > & rPropSetInfo )
    3105             : {
    3106           0 :     OUString sStyle;
    3107           0 :     if( rPropSetInfo->hasPropertyByName( sFrameStyleName ) )
    3108             :     {
    3109           0 :         rPropSet->getPropertyValue( sFrameStyleName ) >>= sStyle;
    3110             :     }
    3111             : 
    3112           0 :     OUString sAutoStyle( sStyle );
    3113           0 :     sAutoStyle = Find( XML_STYLE_FAMILY_TEXT_FRAME, rPropSet, sStyle );
    3114           0 :     if( !sAutoStyle.isEmpty() )
    3115           0 :         GetExport().AddAttribute( XML_NAMESPACE_DRAW, XML_STYLE_NAME,
    3116           0 :                                   GetExport().EncodeStyleName( sAutoStyle ) );
    3117           0 :     addTextFrameAttributes( rPropSet, sal_False );
    3118             : 
    3119             :     // svg:transform
    3120           0 :     sal_Int16 nVal = 0;
    3121           0 :     rPropSet->getPropertyValue( sGraphicRotation ) >>= nVal;
    3122           0 :     if( nVal != 0 )
    3123             :     {
    3124           0 :         OUStringBuffer sRet( GetXMLToken(XML_ROTATE).getLength()+4 );
    3125           0 :         sRet.append( GetXMLToken(XML_ROTATE));
    3126           0 :         sRet.append( (sal_Unicode)'(' );
    3127           0 :         ::sax::Converter::convertNumber( sRet, (sal_Int32)nVal );
    3128           0 :         sRet.append( (sal_Unicode)')' );
    3129           0 :         GetExport().AddAttribute( XML_NAMESPACE_SVG, XML_TRANSFORM,
    3130           0 :                                   sRet.makeStringAndClear() );
    3131             :     }
    3132             : 
    3133             :     // original content
    3134           0 :     SvXMLElementExport aElem(GetExport(), XML_NAMESPACE_DRAW, XML_FRAME, sal_False, sal_True);
    3135             : 
    3136             :     // replacement graphic for backwards compatibility, but
    3137             :     // only for SVG currently
    3138           0 :     OUString sReplacementOrigURL;
    3139           0 :     rPropSet->getPropertyValue( sReplacementGraphicURL ) >>= sReplacementOrigURL;
    3140             : 
    3141           0 :     if(sReplacementOrigURL.getLength())
    3142             :     {
    3143           0 :         const OUString sReplacementURL(GetExport().AddEmbeddedGraphicObject( sReplacementOrigURL ));
    3144             : 
    3145             :         // If there is no url, then then graphic is empty
    3146           0 :         if(sReplacementURL.getLength())
    3147             :         {
    3148           0 :             GetExport().AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, sReplacementURL);
    3149           0 :             GetExport().AddAttribute(XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE);
    3150           0 :             GetExport().AddAttribute(XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED);
    3151           0 :             GetExport().AddAttribute(XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD);
    3152             : 
    3153             :             // xlink:href for replacement, only written for Svg content
    3154           0 :             SvXMLElementExport aElement(GetExport(), XML_NAMESPACE_DRAW, XML_IMAGE, sal_False, sal_True);
    3155             : 
    3156             :             // optional office:binary-data
    3157           0 :             GetExport().AddEmbeddedGraphicObjectAsBase64(sReplacementURL);
    3158           0 :         }
    3159             :     }
    3160             : 
    3161             :     // xlink:href
    3162           0 :     OUString sOrigURL;
    3163           0 :     rPropSet->getPropertyValue( sGraphicURL ) >>= sOrigURL;
    3164           0 :     OUString sURL(GetExport().AddEmbeddedGraphicObject( sOrigURL ));
    3165           0 :     setTextEmbeddedGraphicURL( rPropSet, sURL );
    3166             : 
    3167             :     // If there still is no url, then then graphic is empty
    3168           0 :     if( !sURL.isEmpty() )
    3169             :     {
    3170           0 :         GetExport().AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, sURL );
    3171           0 :         GetExport().AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
    3172           0 :         GetExport().AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
    3173           0 :         GetExport().AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE,
    3174           0 :                                                        XML_ONLOAD );
    3175             :     }
    3176             : 
    3177             :     // draw:filter-name
    3178           0 :     OUString sGrfFilter;
    3179           0 :     rPropSet->getPropertyValue( sGraphicFilter ) >>= sGrfFilter;
    3180           0 :     if( !sGrfFilter.isEmpty() )
    3181           0 :         GetExport().AddAttribute( XML_NAMESPACE_DRAW, XML_FILTER_NAME,
    3182           0 :                                   sGrfFilter );
    3183             : 
    3184             :     {
    3185           0 :         SvXMLElementExport aElement( GetExport(), XML_NAMESPACE_DRAW,
    3186           0 :                                   XML_IMAGE, sal_False, sal_True );
    3187             : 
    3188             :         // optional office:binary-data
    3189           0 :         GetExport().AddEmbeddedGraphicObjectAsBase64( sOrigURL );
    3190             :     }
    3191             : 
    3192             :     // script:events
    3193           0 :     Reference<XEventsSupplier> xEventsSupp( rPropSet, UNO_QUERY );
    3194           0 :     GetExport().GetEventExport().Export(xEventsSupp);
    3195             : 
    3196             :     // image map
    3197           0 :     GetExport().GetImageMapExport().Export( rPropSet );
    3198             : 
    3199             :     // svg:title and svg:desc (#i73249#)
    3200           0 :     exportTitleAndDescription( rPropSet, rPropSetInfo );
    3201             : 
    3202             :     // draw:contour
    3203           0 :     exportContour( rPropSet, rPropSetInfo );
    3204           0 : }
    3205             : 
    3206           0 : void XMLTextParagraphExport::_collectTextEmbeddedAutoStyles(const Reference < XPropertySet > & )
    3207             : {
    3208             :     DBG_ASSERT( !this, "no API implementation avialable" );
    3209           0 : }
    3210             : 
    3211           0 : void XMLTextParagraphExport::_exportTextEmbedded(
    3212             :         const Reference < XPropertySet > &,
    3213             :         const Reference < XPropertySetInfo > & )
    3214             : {
    3215             :     DBG_ASSERT( !this, "no API implementation avialable" );
    3216           0 : }
    3217             : 
    3218           0 : void XMLTextParagraphExport::exportEvents( const Reference < XPropertySet > & rPropSet )
    3219             : {
    3220             :     // script:events
    3221           0 :     Reference<XEventsSupplier> xEventsSupp( rPropSet, UNO_QUERY );
    3222           0 :     GetExport().GetEventExport().Export(xEventsSupp);
    3223             : 
    3224             :     // image map
    3225           0 :     OUString sImageMap("ImageMap");
    3226           0 :     if (rPropSet->getPropertySetInfo()->hasPropertyByName(sImageMap))
    3227           0 :         GetExport().GetImageMapExport().Export( rPropSet );
    3228           0 : }
    3229             : 
    3230             : // Implement Title/Description Elements UI (#i73249#)
    3231           0 : void XMLTextParagraphExport::exportTitleAndDescription(
    3232             :         const Reference < XPropertySet > & rPropSet,
    3233             :         const Reference < XPropertySetInfo > & rPropSetInfo )
    3234             : {
    3235             :     // svg:title
    3236           0 :     if( rPropSetInfo->hasPropertyByName( sTitle ) )
    3237             :     {
    3238           0 :         OUString sObjTitle;
    3239           0 :         rPropSet->getPropertyValue( sTitle ) >>= sObjTitle;
    3240           0 :         if( !sObjTitle.isEmpty() )
    3241             :         {
    3242           0 :             SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_SVG,
    3243           0 :                                       XML_TITLE, sal_True, sal_False );
    3244           0 :             GetExport().Characters( sObjTitle );
    3245           0 :         }
    3246             :     }
    3247             : 
    3248             :     // svg:description
    3249           0 :     if( rPropSetInfo->hasPropertyByName( sDescription ) )
    3250             :     {
    3251           0 :         OUString sObjDesc;
    3252           0 :         rPropSet->getPropertyValue( sDescription ) >>= sObjDesc;
    3253           0 :         if( !sObjDesc.isEmpty() )
    3254             :         {
    3255           0 :             SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_SVG,
    3256           0 :                                       XML_DESC, sal_True, sal_False );
    3257           0 :             GetExport().Characters( sObjDesc );
    3258           0 :         }
    3259             :     }
    3260           0 : }
    3261             : 
    3262           0 : void XMLTextParagraphExport::setTextEmbeddedGraphicURL(
    3263             :     const Reference < XPropertySet >&,
    3264             :     OUString& /*rStreamName*/ ) const
    3265             : {
    3266           0 : }
    3267             : 
    3268           0 : sal_Bool XMLTextParagraphExport::addHyperlinkAttributes(
    3269             :         const Reference < XPropertySet > & rPropSet,
    3270             :         const Reference < XPropertyState > & rPropState,
    3271             :         const Reference < XPropertySetInfo > & rPropSetInfo )
    3272             : {
    3273           0 :     sal_Bool bExport = sal_False;
    3274           0 :     OUString sHRef, sName, sTargetFrame, sUStyleName, sVStyleName;
    3275           0 :     sal_Bool bServerMap = sal_False;
    3276             : 
    3277           0 :     if( rPropSetInfo->hasPropertyByName( sHyperLinkURL ) &&
    3278           0 :         ( !rPropState.is() || PropertyState_DIRECT_VALUE ==
    3279           0 :                     rPropState->getPropertyState( sHyperLinkURL ) ) )
    3280             :     {
    3281           0 :         rPropSet->getPropertyValue( sHyperLinkURL ) >>= sHRef;
    3282             : 
    3283           0 :         if( !sHRef.isEmpty() )
    3284           0 :             bExport = sal_True;
    3285             :     }
    3286             : 
    3287           0 :     if( rPropSetInfo->hasPropertyByName( sHyperLinkName ) &&
    3288           0 :         ( !rPropState.is() || PropertyState_DIRECT_VALUE ==
    3289           0 :                     rPropState->getPropertyState( sHyperLinkName ) ) )
    3290             :     {
    3291           0 :         rPropSet->getPropertyValue( sHyperLinkName ) >>= sName;
    3292           0 :         if( !sName.isEmpty() )
    3293           0 :             bExport = sal_True;
    3294             :     }
    3295             : 
    3296           0 :     if( rPropSetInfo->hasPropertyByName( sHyperLinkTarget ) &&
    3297           0 :         ( !rPropState.is() || PropertyState_DIRECT_VALUE ==
    3298           0 :                     rPropState->getPropertyState( sHyperLinkTarget ) ) )
    3299             :     {
    3300           0 :         rPropSet->getPropertyValue( sHyperLinkTarget ) >>= sTargetFrame;
    3301           0 :         if( !sTargetFrame.isEmpty() )
    3302           0 :             bExport = sal_True;
    3303             :     }
    3304             : 
    3305           0 :     if( rPropSetInfo->hasPropertyByName( sServerMap ) &&
    3306           0 :         ( !rPropState.is() || PropertyState_DIRECT_VALUE ==
    3307           0 :                     rPropState->getPropertyState( sServerMap ) ) )
    3308             :     {
    3309           0 :         bServerMap = *(sal_Bool *)rPropSet->getPropertyValue( sServerMap ).getValue();
    3310           0 :         if( bServerMap  )
    3311           0 :             bExport = sal_True;
    3312             :     }
    3313             : 
    3314           0 :     if( rPropSetInfo->hasPropertyByName( sUnvisitedCharStyleName ) &&
    3315           0 :         ( !rPropState.is() || PropertyState_DIRECT_VALUE ==
    3316           0 :             rPropState->getPropertyState( sUnvisitedCharStyleName ) ) )
    3317             :     {
    3318           0 :         rPropSet->getPropertyValue( sUnvisitedCharStyleName ) >>= sUStyleName;
    3319           0 :         if( !sUStyleName.isEmpty() )
    3320           0 :             bExport = sal_True;
    3321             :     }
    3322             : 
    3323           0 :     if( rPropSetInfo->hasPropertyByName( sVisitedCharStyleName ) &&
    3324           0 :         ( !rPropState.is() || PropertyState_DIRECT_VALUE ==
    3325           0 :             rPropState->getPropertyState( sVisitedCharStyleName ) ) )
    3326             :     {
    3327           0 :         rPropSet->getPropertyValue( sVisitedCharStyleName ) >>= sVStyleName;
    3328           0 :         if( !sVStyleName.isEmpty() )
    3329           0 :             bExport = sal_True;
    3330             :     }
    3331             : 
    3332           0 :     if( bExport )
    3333             :     {
    3334           0 :         GetExport().AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
    3335           0 :         GetExport().AddAttribute( XML_NAMESPACE_XLINK, XML_HREF, GetExport().GetRelativeReference( sHRef ) );
    3336             : 
    3337           0 :         if( !sName.isEmpty() )
    3338           0 :             GetExport().AddAttribute( XML_NAMESPACE_OFFICE, XML_NAME, sName );
    3339             : 
    3340           0 :         if( !sTargetFrame.isEmpty() )
    3341             :         {
    3342           0 :             GetExport().AddAttribute( XML_NAMESPACE_OFFICE,
    3343           0 :                                       XML_TARGET_FRAME_NAME, sTargetFrame );
    3344             :             enum XMLTokenEnum eTok =
    3345           0 :                 sTargetFrame.equalsAsciiL( "_blank", sizeof("_blank")-1 )
    3346           0 :                     ? XML_NEW : XML_REPLACE;
    3347           0 :             GetExport().AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, eTok );
    3348             :         }
    3349             : 
    3350           0 :         if( bServerMap  )
    3351           0 :             GetExport().AddAttribute( XML_NAMESPACE_OFFICE,
    3352           0 :                                       XML_SERVER_MAP, XML_TRUE );
    3353             : 
    3354           0 :         if( !sUStyleName.isEmpty() )
    3355           0 :             GetExport().AddAttribute( XML_NAMESPACE_TEXT,
    3356           0 :               XML_STYLE_NAME, GetExport().EncodeStyleName( sUStyleName ) );
    3357             : 
    3358           0 :         if( !sVStyleName.isEmpty() )
    3359           0 :             GetExport().AddAttribute( XML_NAMESPACE_TEXT,
    3360           0 :               XML_VISITED_STYLE_NAME, GetExport().EncodeStyleName( sVStyleName ) );
    3361             :     }
    3362             : 
    3363           0 :     return bExport;
    3364             : }
    3365             : 
    3366          98 : void XMLTextParagraphExport::exportTextRange(
    3367             :         const Reference < XTextRange > & rTextRange,
    3368             :         sal_Bool bAutoStyles,
    3369             :         bool& rPrevCharIsSpace,
    3370             :         FieldmarkType& openFieldMark )
    3371             : {
    3372          98 :     Reference < XPropertySet > xPropSet( rTextRange, UNO_QUERY );
    3373          98 :     if( bAutoStyles )
    3374             :     {
    3375          64 :         Add( XML_STYLE_FAMILY_TEXT_TEXT, xPropSet );
    3376             :     }
    3377             :     else
    3378             :     {
    3379          34 :         sal_Bool bHyperlink = sal_False;
    3380          34 :         sal_Bool bIsUICharStyle = sal_False;
    3381          34 :         sal_Bool bHasAutoStyle = sal_False;
    3382             : 
    3383             :         OUString sStyle(FindTextStyleAndHyperlink( xPropSet, bHyperlink,
    3384          34 :                                                         bIsUICharStyle, bHasAutoStyle ));
    3385             : 
    3386          34 :         Reference < XPropertySetInfo > xPropSetInfo;
    3387          34 :         if( bHyperlink )
    3388             :         {
    3389           0 :             Reference< XPropertyState > xPropState( xPropSet, UNO_QUERY );
    3390           0 :             xPropSetInfo.set(xPropSet->getPropertySetInfo());
    3391           0 :             bHyperlink = addHyperlinkAttributes( xPropSet, xPropState, xPropSetInfo );
    3392             :         }
    3393          34 :         SvXMLElementExport aElem( GetExport(), bHyperlink, XML_NAMESPACE_TEXT,
    3394          68 :                                   XML_A, sal_False, sal_False );
    3395          34 :         if( bHyperlink )
    3396             :         {
    3397             :             // export events (if supported)
    3398             :             OUString sHyperLinkEvents(
    3399           0 :                 "HyperLinkEvents");
    3400           0 :             if (xPropSetInfo->hasPropertyByName(sHyperLinkEvents))
    3401             :             {
    3402           0 :                 Reference<XNameReplace> xName(xPropSet->getPropertyValue(sHyperLinkEvents), uno::UNO_QUERY);
    3403           0 :                 GetExport().GetEventExport().Export(xName, sal_False);
    3404           0 :             }
    3405             :         }
    3406             : 
    3407             :         {
    3408             :             XMLTextCharStyleNamesElementExport aCharStylesExport(
    3409          34 :                 GetExport(), bIsUICharStyle &&
    3410             :                              aCharStyleNamesPropInfoCache.hasProperty(
    3411           0 :                                                     xPropSet, xPropSetInfo ), bHasAutoStyle,
    3412          68 :                 xPropSet, sCharStyleNames );
    3413             : 
    3414          34 :             OUString aText(rTextRange->getString());
    3415          34 :             if( !sStyle.isEmpty() )
    3416           0 :                 GetExport().AddAttribute( XML_NAMESPACE_TEXT, XML_STYLE_NAME,
    3417           0 :                           GetExport().EncodeStyleName( sStyle ) );
    3418             :             {
    3419             :                 // in a block to make sure it is destroyed before the text:a element
    3420          68 :                 SvXMLElementExport aElement( GetExport(), !sStyle.isEmpty(),
    3421             :                                           XML_NAMESPACE_TEXT, XML_SPAN, sal_False,
    3422          68 :                                           sal_False );
    3423             : 
    3424          34 :                 SvXMLElementExport aElem2( GetExport(), TEXT == openFieldMark,
    3425             :                     XML_NAMESPACE_TEXT, XML_TEXT_INPUT,
    3426          68 :                     sal_False, sal_False );
    3427          34 :                 exportText( aText, rPrevCharIsSpace );
    3428          34 :                 openFieldMark = NONE;
    3429          34 :             }
    3430          34 :         }
    3431          98 :     }
    3432          98 : }
    3433             : 
    3434          36 : void XMLTextParagraphExport::exportText( const OUString& rText,
    3435             :                                            bool& rPrevCharIsSpace )
    3436             : {
    3437          36 :     sal_Int32 nExpStartPos = 0;
    3438          36 :     sal_Int32 nEndPos = rText.getLength();
    3439          36 :     sal_Int32 nSpaceChars = 0;
    3440         250 :     for( sal_Int32 nPos = 0; nPos < nEndPos; nPos++ )
    3441             :     {
    3442         214 :         sal_Unicode cChar = rText[nPos];
    3443         214 :         sal_Bool bExpCharAsText = sal_True;
    3444         214 :         sal_Bool bExpCharAsElement = sal_False;
    3445         214 :         sal_Bool bCurrCharIsSpace = sal_False;
    3446         214 :         switch( cChar )
    3447             :         {
    3448             :         case 0x0009:    // Tab
    3449             :         case 0x000A:    // LF
    3450             :             // These characters are exported as text.
    3451           0 :             bExpCharAsElement = sal_True;
    3452           0 :             bExpCharAsText = sal_False;
    3453           0 :             break;
    3454             :         case 0x000D:
    3455           0 :             break;  // legal character
    3456             :         case 0x0020:    // Blank
    3457          27 :             if( rPrevCharIsSpace )
    3458             :             {
    3459             :                 // If the previous character is a space character,
    3460             :                 // too, export a special space element.
    3461           0 :                 bExpCharAsText = sal_False;
    3462             :             }
    3463          27 :             bCurrCharIsSpace = sal_True;
    3464          27 :             break;
    3465             :         default:
    3466         187 :             if( cChar < 0x0020 )
    3467             :             {
    3468             : #ifdef DBG_UTIL
    3469             :                 OSL_ENSURE( txtparae_bContainsIllegalCharacters ||
    3470             :                             cChar >= 0x0020,
    3471             :                             "illegal character in text content" );
    3472             :                 txtparae_bContainsIllegalCharacters = sal_True;
    3473             : #endif
    3474           0 :                 bExpCharAsText = sal_False;
    3475             :             }
    3476         187 :             break;
    3477             :         }
    3478             : 
    3479             :         // If the current character is not exported as text
    3480             :            // the text that has not been exported by now has to be exported now.
    3481         214 :         if( nPos > nExpStartPos && !bExpCharAsText )
    3482             :         {
    3483             :             DBG_ASSERT( 0==nSpaceChars, "pending spaces" );
    3484           0 :             OUString sExp( rText.copy( nExpStartPos, nPos - nExpStartPos ) );
    3485           0 :             GetExport().Characters( sExp );
    3486           0 :             nExpStartPos = nPos;
    3487             :         }
    3488             : 
    3489             :         // If there are spaces left that have not been exported and the
    3490             :         // current chracter is not a space , the pending spaces have to be
    3491             :         // exported now.
    3492         214 :         if( nSpaceChars > 0 && !bCurrCharIsSpace )
    3493             :         {
    3494             :             DBG_ASSERT( nExpStartPos == nPos, " pending characters" );
    3495             : 
    3496           0 :             if( nSpaceChars > 1 )
    3497             :             {
    3498           0 :                 OUStringBuffer sTmp;
    3499           0 :                 sTmp.append( (sal_Int32)nSpaceChars );
    3500           0 :                 GetExport().AddAttribute( XML_NAMESPACE_TEXT, XML_C,
    3501           0 :                               sTmp.makeStringAndClear() );
    3502             :             }
    3503             : 
    3504           0 :             SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_TEXT,
    3505           0 :                                       XML_S, sal_False, sal_False );
    3506             : 
    3507           0 :             nSpaceChars = 0;
    3508             :         }
    3509             : 
    3510             :         // If the current character has to be exported as a special
    3511             :         // element, the elemnt will be exported now.
    3512         214 :         if( bExpCharAsElement )
    3513             :         {
    3514           0 :             switch( cChar )
    3515             :             {
    3516             :             case 0x0009:    // Tab
    3517             :                 {
    3518           0 :                     SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_TEXT,
    3519             :                                               XML_TAB, sal_False,
    3520           0 :                                               sal_False );
    3521             :                 }
    3522           0 :                 break;
    3523             :             case 0x000A:    // LF
    3524             :                 {
    3525           0 :                     SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_TEXT,
    3526             :                                               XML_LINE_BREAK, sal_False,
    3527           0 :                                               sal_False );
    3528             :                 }
    3529           0 :                 break;
    3530             :             }
    3531             :         }
    3532             : 
    3533             :         // If the current character is a space, and the previous one
    3534             :         // is a space, too, the number of pending spaces is incremented
    3535             :         // only.
    3536         214 :         if( bCurrCharIsSpace && rPrevCharIsSpace )
    3537           0 :             nSpaceChars++;
    3538         214 :         rPrevCharIsSpace = bCurrCharIsSpace;
    3539             : 
    3540             :         // If the currect character is not exported as text, the start
    3541             :         // position for text is the position behind the current position.
    3542         214 :         if( !bExpCharAsText )
    3543             :         {
    3544             :             DBG_ASSERT( nExpStartPos == nPos, "wrong export start pos" );
    3545           0 :             nExpStartPos = nPos+1;
    3546             :         }
    3547             :     }
    3548             : 
    3549          36 :     if( nExpStartPos < nEndPos )
    3550             :     {
    3551             :         DBG_ASSERT( 0==nSpaceChars, " pending spaces " );
    3552          30 :         OUString sExp( rText.copy( nExpStartPos, nEndPos - nExpStartPos ) );
    3553          30 :         GetExport().Characters( sExp );
    3554             :     }
    3555             : 
    3556             :     // If there are some spaces left, they have to be exported now.
    3557          36 :     if( nSpaceChars > 0 )
    3558             :     {
    3559           0 :         if( nSpaceChars > 1 )
    3560             :         {
    3561           0 :             OUStringBuffer sTmp;
    3562           0 :             sTmp.append( (sal_Int32)nSpaceChars );
    3563           0 :             GetExport().AddAttribute( XML_NAMESPACE_TEXT, XML_C,
    3564           0 :                           sTmp.makeStringAndClear() );
    3565             :         }
    3566             : 
    3567           0 :         SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_TEXT, XML_S,
    3568           0 :                                   sal_False, sal_False );
    3569             :     }
    3570          36 : }
    3571             : 
    3572           2 : void XMLTextParagraphExport::exportTextDeclarations()
    3573             : {
    3574           2 :     pFieldExport->ExportFieldDeclarations();
    3575             : 
    3576             :     // get XPropertySet from the document and ask for AutoMarkFileURL.
    3577             :     // If it exists, export the auto-mark-file element.
    3578           2 :     Reference<XPropertySet> xPropertySet( GetExport().GetModel(), UNO_QUERY );
    3579           2 :     if (xPropertySet.is())
    3580             :     {
    3581           2 :         OUString sUrl;
    3582             :         OUString sIndexAutoMarkFileURL(
    3583           2 :             "IndexAutoMarkFileURL");
    3584           4 :         if (xPropertySet->getPropertySetInfo()->hasPropertyByName(
    3585           2 :             sIndexAutoMarkFileURL))
    3586             :         {
    3587           2 :             xPropertySet->getPropertyValue(sIndexAutoMarkFileURL) >>= sUrl;
    3588           2 :             if (!sUrl.isEmpty())
    3589             :             {
    3590           0 :                 GetExport().AddAttribute( XML_NAMESPACE_XLINK, XML_HREF,
    3591           0 :                                           GetExport().GetRelativeReference(sUrl) );
    3592             :                 SvXMLElementExport aAutoMarkElement(
    3593           0 :                     GetExport(), XML_NAMESPACE_TEXT,
    3594             :                     XML_ALPHABETICAL_INDEX_AUTO_MARK_FILE,
    3595           0 :                     sal_True, sal_True );
    3596             :             }
    3597           2 :         }
    3598           2 :     }
    3599           2 : }
    3600             : 
    3601          22 : void XMLTextParagraphExport::exportTextDeclarations(
    3602             :     const Reference<XText> & rText )
    3603             : {
    3604          22 :     pFieldExport->ExportFieldDeclarations(rText);
    3605          22 : }
    3606             : 
    3607           2 : void XMLTextParagraphExport::exportUsedDeclarations( sal_Bool bOnlyUsed )
    3608             : {
    3609           2 :     pFieldExport->SetExportOnlyUsedFieldDeclarations( bOnlyUsed );
    3610           2 : }
    3611             : 
    3612             : 
    3613           4 : void XMLTextParagraphExport::exportTrackedChanges(sal_Bool bAutoStyles)
    3614             : {
    3615           4 :     if (NULL != pRedlineExport)
    3616           4 :         pRedlineExport->ExportChangesList( bAutoStyles );
    3617           4 : }
    3618             : 
    3619          24 : void XMLTextParagraphExport::exportTrackedChanges(
    3620             :     const Reference<XText> & rText,
    3621             :     sal_Bool bAutoStyle)
    3622             : {
    3623          24 :     if (NULL != pRedlineExport)
    3624          24 :         pRedlineExport->ExportChangesList(rText, bAutoStyle);
    3625          24 : }
    3626             : 
    3627          24 : void XMLTextParagraphExport::recordTrackedChangesForXText(
    3628             :     const Reference<XText> & rText )
    3629             : {
    3630          24 :     if (NULL != pRedlineExport)
    3631          24 :         pRedlineExport->SetCurrentXText(rText);
    3632          24 : }
    3633             : 
    3634          24 : void XMLTextParagraphExport::recordTrackedChangesNoXText()
    3635             : {
    3636          24 :     if (NULL != pRedlineExport)
    3637          24 :         pRedlineExport->SetCurrentXText();
    3638          24 : }
    3639             : 
    3640             : 
    3641           8 : void XMLTextParagraphExport::exportTextAutoStyles()
    3642             : {
    3643           8 :     GetAutoStylePool().exportXML( XML_STYLE_FAMILY_TEXT_PARAGRAPH,
    3644           8 :                                    GetExport().GetDocHandler(),
    3645           8 :                                    GetExport().GetMM100UnitConverter(),
    3646          16 :                                    GetExport().GetNamespaceMap() );
    3647             : 
    3648           8 :     GetAutoStylePool().exportXML( XML_STYLE_FAMILY_TEXT_TEXT,
    3649           8 :                                    GetExport().GetDocHandler(),
    3650           8 :                                    GetExport().GetMM100UnitConverter(),
    3651          16 :                                    GetExport().GetNamespaceMap() );
    3652             : 
    3653           8 :     GetAutoStylePool().exportXML( XML_STYLE_FAMILY_TEXT_FRAME,
    3654           8 :                                    GetExport().GetDocHandler(),
    3655           8 :                                    GetExport().GetMM100UnitConverter(),
    3656          16 :                                    GetExport().GetNamespaceMap() );
    3657             : 
    3658           8 :     GetAutoStylePool().exportXML( XML_STYLE_FAMILY_TEXT_SECTION,
    3659           8 :                                   GetExport().GetDocHandler(),
    3660           8 :                                   GetExport().GetMM100UnitConverter(),
    3661          16 :                                   GetExport().GetNamespaceMap() );
    3662             : 
    3663           8 :     GetAutoStylePool().exportXML( XML_STYLE_FAMILY_TEXT_RUBY,
    3664           8 :                                   GetExport().GetDocHandler(),
    3665           8 :                                   GetExport().GetMM100UnitConverter(),
    3666          16 :                                   GetExport().GetNamespaceMap() );
    3667             : 
    3668           8 :     pListAutoPool->exportXML();
    3669           8 : }
    3670             : 
    3671           0 : void XMLTextParagraphExport::exportRuby(
    3672             :     const Reference<XPropertySet> & rPropSet,
    3673             :     sal_Bool bAutoStyles )
    3674             : {
    3675             :     // early out: a collapsed ruby makes no sense
    3676           0 :     if (*(sal_Bool*)rPropSet->getPropertyValue(sIsCollapsed).getValue())
    3677           0 :         return;
    3678             : 
    3679             :     // start value ?
    3680           0 :     sal_Bool bStart = (*(sal_Bool*)rPropSet->getPropertyValue(sIsStart).getValue());
    3681             : 
    3682           0 :     if (bAutoStyles)
    3683             :     {
    3684             :         // ruby auto styles
    3685           0 :         if (bStart)
    3686           0 :             Add( XML_STYLE_FAMILY_TEXT_RUBY, rPropSet );
    3687             :     }
    3688             :     else
    3689             :     {
    3690           0 :         if (bStart)
    3691             :         {
    3692             :             // ruby start
    3693             : 
    3694             :             // we can only start a ruby if none is open
    3695             :             DBG_ASSERT(! bOpenRuby, "Can't open a ruby inside of ruby!");
    3696           0 :             if( bOpenRuby )
    3697             :                 return;
    3698             : 
    3699             :             // save ruby text + ruby char style
    3700           0 :             rPropSet->getPropertyValue(sRubyText) >>= sOpenRubyText;
    3701           0 :             rPropSet->getPropertyValue(sRubyCharStyleName) >>= sOpenRubyCharStyle;
    3702             : 
    3703             :             // ruby style
    3704           0 :             GetExport().CheckAttrList();
    3705           0 :             OUString sEmpty;
    3706             :             OUString sStyleName(Find( XML_STYLE_FAMILY_TEXT_RUBY, rPropSet,
    3707           0 :                                         sEmpty ));
    3708             :             DBG_ASSERT(!sStyleName.isEmpty(), "I can't find the style!");
    3709           0 :             GetExport().AddAttribute(XML_NAMESPACE_TEXT,
    3710           0 :                                      XML_STYLE_NAME, sStyleName);
    3711             : 
    3712             :             // export <text:ruby> and <text:ruby-base> start elements
    3713           0 :             GetExport().StartElement( XML_NAMESPACE_TEXT, XML_RUBY, sal_False);
    3714           0 :             GetExport().ClearAttrList();
    3715           0 :             GetExport().StartElement( XML_NAMESPACE_TEXT, XML_RUBY_BASE,
    3716           0 :                                       sal_False );
    3717           0 :             bOpenRuby = sal_True;
    3718             :         }
    3719             :         else
    3720             :         {
    3721             :             // ruby end
    3722             : 
    3723             :             // check for an open ruby
    3724             :             DBG_ASSERT(bOpenRuby, "Can't close a ruby if none is open!");
    3725           0 :             if( !bOpenRuby )
    3726           0 :                 return;
    3727             : 
    3728             :             // close <text:ruby-base>
    3729           0 :             GetExport().EndElement(XML_NAMESPACE_TEXT, XML_RUBY_BASE,
    3730           0 :                                    sal_False);
    3731             : 
    3732             :             // write the ruby text (with char style)
    3733             :             {
    3734           0 :                 if (!sOpenRubyCharStyle.isEmpty())
    3735           0 :                     GetExport().AddAttribute(
    3736             :                         XML_NAMESPACE_TEXT, XML_STYLE_NAME,
    3737           0 :                         GetExport().EncodeStyleName( sOpenRubyCharStyle) );
    3738             : 
    3739             :                 SvXMLElementExport aRubyElement(
    3740           0 :                     GetExport(), XML_NAMESPACE_TEXT, XML_RUBY_TEXT,
    3741           0 :                     sal_False, sal_False);
    3742             : 
    3743           0 :                 GetExport().Characters(sOpenRubyText);
    3744             :             }
    3745             : 
    3746             :             // and finally, close the ruby
    3747           0 :             GetExport().EndElement(XML_NAMESPACE_TEXT, XML_RUBY, sal_False);
    3748           0 :             bOpenRuby = sal_False;
    3749             :         }
    3750             :     }
    3751             : }
    3752             : 
    3753           0 : void XMLTextParagraphExport::exportMeta(
    3754             :     const Reference<XPropertySet> & i_xPortion,
    3755             :     sal_Bool i_bAutoStyles, sal_Bool i_isProgress)
    3756             : {
    3757           0 :     static OUString sMeta("InContentMetadata");
    3758             : 
    3759           0 :     bool doExport(!i_bAutoStyles); // do not export element if autostyles
    3760             :     // check version >= 1.2
    3761           0 :     switch (GetExport().getDefaultVersion()) {
    3762             :         case SvtSaveOptions::ODFVER_011: // fall thru
    3763           0 :         case SvtSaveOptions::ODFVER_010: doExport = false; break;
    3764           0 :         default: break;
    3765             :     }
    3766             : 
    3767             :     const Reference< XTextContent > xTextContent(
    3768           0 :             i_xPortion->getPropertyValue(sMeta), UNO_QUERY_THROW);
    3769           0 :     const Reference< XEnumerationAccess > xEA( xTextContent, UNO_QUERY_THROW );
    3770           0 :     const Reference< XEnumeration > xTextEnum( xEA->createEnumeration() );
    3771             : 
    3772           0 :     if (doExport)
    3773             :     {
    3774           0 :         const Reference<rdf::XMetadatable> xMeta(xTextContent, UNO_QUERY_THROW);
    3775             : 
    3776             :         // text:meta with neither xml:id nor RDFa is invalid
    3777           0 :         xMeta->ensureMetadataReference();
    3778             : 
    3779             :         // xml:id and RDFa for RDF metadata
    3780           0 :         GetExport().AddAttributeXmlId(xMeta);
    3781           0 :         GetExport().AddAttributesRDFa(xTextContent);
    3782             :     }
    3783             : 
    3784           0 :     SvXMLElementExport aElem( GetExport(), doExport,
    3785           0 :         XML_NAMESPACE_TEXT, XML_META, sal_False, sal_False );
    3786             : 
    3787             :     // recurse to export content
    3788           0 :     exportTextRangeEnumeration( xTextEnum, i_bAutoStyles, i_isProgress );
    3789           0 : }
    3790             : 
    3791             : 
    3792           2 : void XMLTextParagraphExport::PreventExportOfControlsInMuteSections(
    3793             :     const Reference<XIndexAccess> & rShapes,
    3794             :     UniReference<xmloff::OFormLayerXMLExport> xFormExport   )
    3795             : {
    3796             :     // check parameters ad pre-conditions
    3797           2 :     if( ( ! rShapes.is() ) || ( ! xFormExport.is() ) )
    3798             :     {
    3799             :         // if we don't have shapes or a form export, there's nothing to do
    3800             :         return;
    3801             :     }
    3802             :     DBG_ASSERT( pSectionExport != NULL, "We need the section export." );
    3803             : 
    3804           2 :     Reference<XEnumeration> xShapesEnum = pBoundFrameSets->GetShapes()->createEnumeration();
    3805           2 :     if(!xShapesEnum.is())
    3806             :         return;
    3807           4 :     while( xShapesEnum->hasMoreElements() )
    3808             :     {
    3809             :         // now we need to check
    3810             :         // 1) if this is a control shape, and
    3811             :         // 2) if it's in a mute section
    3812             :         // if both answers are 'yes', notify the form layer export
    3813             : 
    3814             :         // we join accessing the shape and testing for control
    3815           0 :         Reference<XControlShape> xControlShape(xShapesEnum->nextElement(), UNO_QUERY);
    3816           0 :         if( xControlShape.is() )
    3817             :         {
    3818             :             //            Reference<XPropertySet> xPropSet( xControlShape, UNO_QUERY );
    3819             :             //            Reference<XTextContent> xTextContent;
    3820             :             //            xPropSet->getPropertyValue( OUString( "TextRange"  ) ) >>= xTextContent;
    3821             : 
    3822           0 :             Reference<XTextContent> xTextContent( xControlShape, UNO_QUERY );
    3823           0 :             if( xTextContent.is() )
    3824             :             {
    3825           0 :                 if( pSectionExport->IsMuteSection( xTextContent, sal_False ) )
    3826             :                 {
    3827             :                     // Ah, we've found a shape that
    3828             :                     // 1) is a control shape
    3829             :                     // 2) is anchored in a mute section
    3830             :                     // so: don't export it!
    3831             :                     xFormExport->excludeFromExport(
    3832           0 :                         xControlShape->getControl() );
    3833             :                 }
    3834             :                 // else: not in mute section -> should be exported -> nothing
    3835             :                 // to do
    3836           0 :             }
    3837             :             // else: no anchor -> ignore
    3838             :         }
    3839             :         // else: no control shape -> nothing to do
    3840           2 :     }
    3841             : }
    3842             : 
    3843           8 : void XMLTextParagraphExport::PushNewTextListsHelper()
    3844             : {
    3845           8 :     mpTextListsHelper = new XMLTextListsHelper();
    3846           8 :     maTextListsHelperStack.push_back( mpTextListsHelper );
    3847           8 : }
    3848             : 
    3849           8 : void XMLTextParagraphExport::PopTextListsHelper()
    3850             : {
    3851           8 :     delete mpTextListsHelper;
    3852           8 :     mpTextListsHelper = 0;
    3853           8 :     maTextListsHelperStack.pop_back();
    3854           8 :     if ( !maTextListsHelperStack.empty() )
    3855             :     {
    3856           0 :         mpTextListsHelper = maTextListsHelperStack.back();
    3857             :     }
    3858           8 : }
    3859             : 
    3860             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10