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