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