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