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