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