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