Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <unosection.hxx>
21 :
22 : #include <com/sun/star/beans/PropertyAttribute.hpp>
23 : #include <com/sun/star/text/SectionFileLink.hpp>
24 :
25 : #include <cppuhelper/interfacecontainer.h>
26 : #include <cppuhelper/supportsservice.hxx>
27 :
28 : #include <cmdid.h>
29 : #include <hintids.hxx>
30 : #include <svl/urihelper.hxx>
31 : #include <editeng/brushitem.hxx>
32 : #include <editeng/xmlcnitm.hxx>
33 : #include <sfx2/linkmgr.hxx>
34 : #include <sfx2/lnkbase.hxx>
35 : #include <osl/mutex.hxx>
36 : #include <vcl/svapp.hxx>
37 : #include <fmtclds.hxx>
38 : #include <unotextrange.hxx>
39 : #include <TextCursorHelper.hxx>
40 : #include <unoport.hxx>
41 : #include <redline.hxx>
42 : #include <unomap.hxx>
43 : #include <unocrsr.hxx>
44 : #include <section.hxx>
45 : #include <doc.hxx>
46 : #include <IDocumentUndoRedo.hxx>
47 : #include <docsh.hxx>
48 : #include <sfx2/docfile.hxx>
49 : #include <docary.hxx>
50 : #include <swundo.hxx>
51 : #include <hints.hxx>
52 : #include <tox.hxx>
53 : #include <unoidx.hxx>
54 : #include <doctxm.hxx>
55 : #include <fmtftntx.hxx>
56 : #include <fmtclbl.hxx>
57 : #include <editeng/frmdiritem.hxx>
58 : #include <fmtcntnt.hxx>
59 : #include <editeng/lrspitem.hxx>
60 : #include <comphelper/servicehelper.hxx>
61 : #include <comphelper/string.hxx>
62 :
63 : using namespace ::com::sun::star;
64 :
65 204 : struct SwTextSectionProperties_Impl
66 : {
67 : uno::Sequence<sal_Int8> m_Password;
68 : OUString m_sCondition;
69 : OUString m_sLinkFileName;
70 : OUString m_sSectionFilter;
71 : OUString m_sSectionRegion;
72 :
73 : ::std::unique_ptr<SwFormatCol> m_pColItem;
74 : ::std::unique_ptr<SvxBrushItem> m_pBrushItem;
75 : ::std::unique_ptr<SwFormatFootnoteAtTextEnd> m_pFootnoteItem;
76 : ::std::unique_ptr<SwFormatEndAtTextEnd> m_pEndItem;
77 : ::std::unique_ptr<SvXMLAttrContainerItem> m_pXMLAttr;
78 : ::std::unique_ptr<SwFormatNoBalancedColumns> m_pNoBalanceItem;
79 : ::std::unique_ptr<SvxFrameDirectionItem> m_pFrameDirItem;
80 : ::std::unique_ptr<SvxLRSpaceItem> m_pLRSpaceItem;
81 :
82 : bool m_bDDE;
83 : bool m_bHidden;
84 : bool m_bCondHidden;
85 : bool m_bProtect;
86 : bool m_bEditInReadonly;
87 : bool m_bUpdateType;
88 :
89 204 : SwTextSectionProperties_Impl()
90 : : m_bDDE(false)
91 : , m_bHidden(false)
92 : , m_bCondHidden(false)
93 : , m_bProtect(false)
94 : , m_bEditInReadonly(false)
95 204 : , m_bUpdateType(true)
96 : {
97 204 : }
98 :
99 : };
100 :
101 590 : class SwXTextSection::Impl
102 : : public SwClient
103 : {
104 : private:
105 : ::osl::Mutex m_Mutex; // just for OInterfaceContainerHelper
106 :
107 : public:
108 : SwXTextSection & m_rThis;
109 : uno::WeakReference<uno::XInterface> m_wThis;
110 : const SfxItemPropertySet & m_rPropSet;
111 : ::cppu::OInterfaceContainerHelper m_EventListeners;
112 : const bool m_bIndexHeader;
113 : bool m_bIsDescriptor;
114 : OUString m_sName;
115 : ::std::unique_ptr<SwTextSectionProperties_Impl> m_pProps;
116 :
117 295 : Impl( SwXTextSection & rThis,
118 : SwSectionFormat *const pFormat, const bool bIndexHeader)
119 : : SwClient(pFormat)
120 : , m_rThis(rThis)
121 295 : , m_rPropSet(*aSwMapProvider.GetPropertySet(PROPERTY_MAP_SECTION))
122 : , m_EventListeners(m_Mutex)
123 : , m_bIndexHeader(bIndexHeader)
124 295 : , m_bIsDescriptor(0 == pFormat)
125 885 : , m_pProps((pFormat) ? 0 : new SwTextSectionProperties_Impl())
126 : {
127 295 : }
128 :
129 1135 : SwSectionFormat * GetSectionFormat() const
130 : {
131 : return static_cast<SwSectionFormat*>(const_cast<SwModify*>(
132 1135 : GetRegisteredIn()));
133 : }
134 :
135 76 : SwSectionFormat & GetSectionFormatOrThrow() const {
136 76 : SwSectionFormat *const pFormat( GetSectionFormat() );
137 76 : if (!pFormat) {
138 0 : throw uno::RuntimeException("SwXTextSection: disposed or invalid", 0);
139 : }
140 76 : return *pFormat;
141 : }
142 :
143 : void SAL_CALL SetPropertyValues_Impl(
144 : const uno::Sequence< OUString >& rPropertyNames,
145 : const uno::Sequence< uno::Any >& aValues)
146 : throw (beans::UnknownPropertyException, beans::PropertyVetoException,
147 : lang::IllegalArgumentException, lang::WrappedTargetException,
148 : uno::RuntimeException);
149 : uno::Sequence< uno::Any > SAL_CALL
150 : GetPropertyValues_Impl(
151 : const uno::Sequence< OUString >& rPropertyNames)
152 : throw (beans::UnknownPropertyException, lang::WrappedTargetException,
153 : uno::RuntimeException);
154 : protected:
155 : // SwClient
156 : virtual void Modify(const SfxPoolItem *pOld, const SfxPoolItem *pNew) SAL_OVERRIDE;
157 :
158 : };
159 :
160 342 : void SwXTextSection::Impl::Modify( const SfxPoolItem *pOld, const SfxPoolItem *pNew)
161 : {
162 342 : ClientModify(this, pOld, pNew);
163 342 : if (GetRegisteredIn())
164 : {
165 610 : return; // core object still alive
166 : }
167 :
168 37 : uno::Reference<uno::XInterface> const xThis(m_wThis);
169 37 : if (!xThis.is())
170 : { // fdo#72695: if UNO object is already dead, don't revive it with event
171 0 : return;
172 : }
173 74 : lang::EventObject const ev(xThis);
174 74 : m_EventListeners.disposeAndClear(ev);
175 : }
176 :
177 12 : SwSectionFormat * SwXTextSection::GetFormat() const
178 : {
179 12 : return m_pImpl->GetSectionFormat();
180 : }
181 :
182 : uno::Reference< text::XTextSection >
183 456 : SwXTextSection::CreateXTextSection(
184 : SwSectionFormat *const pFormat, const bool bIndexHeader)
185 : {
186 : // re-use existing SwXTextSection
187 : // #i105557#: do not iterate over the registered clients: race condition
188 456 : uno::Reference< text::XTextSection > xSection;
189 456 : if (pFormat)
190 : {
191 252 : xSection.set(pFormat->GetXTextSection());
192 : }
193 456 : if ( !xSection.is() )
194 : {
195 295 : SwXTextSection *const pNew = new SwXTextSection(pFormat, bIndexHeader);
196 295 : xSection.set(pNew);
197 295 : if (pFormat)
198 : {
199 91 : pFormat->SetXTextSection(xSection);
200 : }
201 : // need a permanent Reference to initialize m_wThis
202 295 : pNew->m_pImpl->m_wThis = xSection;
203 : }
204 456 : return xSection;
205 : }
206 :
207 295 : SwXTextSection::SwXTextSection(
208 : SwSectionFormat *const pFormat, const bool bIndexHeader)
209 295 : : m_pImpl( new SwXTextSection::Impl(*this, pFormat, bIndexHeader) )
210 : {
211 295 : }
212 :
213 590 : SwXTextSection::~SwXTextSection()
214 : {
215 590 : }
216 :
217 : namespace
218 : {
219 : class theSwXTextSectionUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theSwXTextSectionUnoTunnelId > {};
220 : }
221 :
222 11027 : const uno::Sequence< sal_Int8 > & SwXTextSection::getUnoTunnelId()
223 : {
224 11027 : return theSwXTextSectionUnoTunnelId::get().getSeq();
225 : }
226 :
227 : sal_Int64 SAL_CALL
228 526 : SwXTextSection::getSomething(const uno::Sequence< sal_Int8 >& rId)
229 : throw (uno::RuntimeException, std::exception)
230 : {
231 526 : return ::sw::UnoTunnelImpl<SwXTextSection>(rId, this);
232 : }
233 :
234 : uno::Reference< text::XTextSection > SAL_CALL
235 76 : SwXTextSection::getParentSection() throw (uno::RuntimeException, std::exception)
236 : {
237 76 : SolarMutexGuard aGuard;
238 :
239 76 : SwSectionFormat & rSectionFormat( m_pImpl->GetSectionFormatOrThrow() );
240 :
241 76 : SwSectionFormat *const pParentFormat = rSectionFormat.GetParent();
242 : const uno::Reference< text::XTextSection > xRet =
243 76 : (pParentFormat) ? CreateXTextSection(pParentFormat) : 0;
244 76 : return xRet;
245 : }
246 :
247 : uno::Sequence< uno::Reference< text::XTextSection > > SAL_CALL
248 0 : SwXTextSection::getChildSections() throw (uno::RuntimeException, std::exception)
249 : {
250 0 : SolarMutexGuard aGuard;
251 :
252 0 : SwSectionFormat & rSectionFormat( m_pImpl->GetSectionFormatOrThrow() );
253 :
254 0 : SwSections aChildren;
255 0 : rSectionFormat.GetChildSections(aChildren, SORTSECT_NOT, false);
256 0 : uno::Sequence<uno::Reference<text::XTextSection> > aSeq(aChildren.size());
257 0 : uno::Reference< text::XTextSection > * pArray = aSeq.getArray();
258 0 : for (size_t i = 0; i < aChildren.size(); ++i)
259 : {
260 0 : SwSectionFormat *const pChild = aChildren[i]->GetFormat();
261 0 : pArray[i] = CreateXTextSection(pChild);
262 : }
263 0 : return aSeq;
264 : }
265 :
266 : void SAL_CALL
267 198 : SwXTextSection::attach(const uno::Reference< text::XTextRange > & xTextRange)
268 : throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception)
269 : {
270 198 : SolarMutexGuard g;
271 :
272 198 : if (!m_pImpl->m_bIsDescriptor)
273 : {
274 0 : throw uno::RuntimeException();
275 : }
276 :
277 396 : uno::Reference<lang::XUnoTunnel> xRangeTunnel( xTextRange, uno::UNO_QUERY);
278 198 : SwXTextRange* pRange = 0;
279 198 : OTextCursorHelper* pCursor = 0;
280 198 : if(xRangeTunnel.is())
281 : {
282 198 : pRange = ::sw::UnoTunnelGetImplementation<SwXTextRange>(xRangeTunnel);
283 : pCursor =
284 198 : ::sw::UnoTunnelGetImplementation<OTextCursorHelper>(xRangeTunnel);
285 : }
286 :
287 : SwDoc *const pDoc =
288 198 : (pRange) ? pRange->GetDoc() : ((pCursor) ? pCursor->GetDoc() : 0);
289 198 : if (!pDoc)
290 : {
291 0 : throw lang::IllegalArgumentException();
292 : }
293 :
294 396 : SwUnoInternalPaM aPam(*pDoc);
295 : //das muss jetzt true liefern
296 198 : ::sw::XTextRangeToSwPaM(aPam, xTextRange);
297 396 : UnoActionContext aCont(pDoc);
298 198 : pDoc->GetIDocumentUndoRedo().StartUndo( UNDO_INSSECTION, NULL );
299 :
300 198 : if (m_pImpl->m_sName.isEmpty())
301 : {
302 117 : m_pImpl->m_sName = "TextSection";
303 : }
304 198 : SectionType eType(FILE_LINK_SECTION);
305 198 : if( m_pImpl->m_pProps->m_bDDE )
306 0 : eType = DDE_LINK_SECTION;
307 198 : else if( m_pImpl->m_pProps->m_sLinkFileName.isEmpty() && m_pImpl->m_pProps->m_sSectionRegion.isEmpty() )
308 198 : eType = CONTENT_SECTION;
309 : // index header section?
310 198 : if (m_pImpl->m_bIndexHeader)
311 : {
312 : // caller wants an index header section, but will only
313 : // give him one if a) we are inside an index, and b) said
314 : // index doesn't yet have a header section.
315 22 : const SwTOXBase* pBase = SwDoc::GetCurTOX(*aPam.Start());
316 :
317 : // are we inside an index?
318 22 : if (pBase)
319 : {
320 : // get all child sections
321 22 : SwSections aSectionsArr;
322 : static_cast<const SwTOXBaseSection*>(pBase)->GetFormat()->
323 22 : GetChildSections(aSectionsArr);
324 :
325 : // and search for current header section
326 22 : const size_t nCount = aSectionsArr.size();
327 22 : bool bHeaderPresent = false;
328 22 : for(size_t i = 0; i < nCount; ++i)
329 : {
330 0 : if (aSectionsArr[i]->GetType() == TOX_HEADER_SECTION)
331 0 : bHeaderPresent = true;
332 : }
333 22 : if (! bHeaderPresent)
334 : {
335 22 : eType = TOX_HEADER_SECTION;
336 22 : }
337 : }
338 : }
339 :
340 396 : SwSectionData aSect(eType, pDoc->GetUniqueSectionName(&m_pImpl->m_sName));
341 198 : aSect.SetCondition(m_pImpl->m_pProps->m_sCondition);
342 594 : aSect.SetLinkFileName(m_pImpl->m_pProps->m_sLinkFileName +
343 990 : OUString(sfx2::cTokenSeparator) +
344 594 : m_pImpl->m_pProps->m_sSectionFilter +
345 792 : OUString(sfx2::cTokenSeparator) +
346 396 : m_pImpl->m_pProps->m_sSectionRegion);
347 :
348 198 : aSect.SetHidden(m_pImpl->m_pProps->m_bHidden);
349 198 : aSect.SetProtectFlag(m_pImpl->m_pProps->m_bProtect);
350 198 : aSect.SetEditInReadonlyFlag(m_pImpl->m_pProps->m_bEditInReadonly);
351 :
352 198 : SfxItemSet aSet(pDoc->GetAttrPool(),
353 : RES_COL, RES_COL,
354 : RES_BACKGROUND, RES_BACKGROUND,
355 : RES_FTN_AT_TXTEND, RES_FRAMEDIR,
356 : RES_LR_SPACE, RES_LR_SPACE,
357 : RES_UNKNOWNATR_CONTAINER,RES_UNKNOWNATR_CONTAINER,
358 396 : 0);
359 198 : if (m_pImpl->m_pProps->m_pBrushItem.get())
360 : {
361 14 : aSet.Put(*m_pImpl->m_pProps->m_pBrushItem);
362 : }
363 198 : if (m_pImpl->m_pProps->m_pColItem.get())
364 : {
365 81 : aSet.Put(*m_pImpl->m_pProps->m_pColItem);
366 : }
367 198 : if (m_pImpl->m_pProps->m_pFootnoteItem.get())
368 : {
369 2 : aSet.Put(*m_pImpl->m_pProps->m_pFootnoteItem);
370 : }
371 198 : if (m_pImpl->m_pProps->m_pEndItem.get())
372 : {
373 2 : aSet.Put(*m_pImpl->m_pProps->m_pEndItem);
374 : }
375 198 : if (m_pImpl->m_pProps->m_pXMLAttr.get())
376 : {
377 0 : aSet.Put(*m_pImpl->m_pProps->m_pXMLAttr);
378 : }
379 198 : if (m_pImpl->m_pProps->m_pNoBalanceItem.get())
380 : {
381 10 : aSet.Put(*m_pImpl->m_pProps->m_pNoBalanceItem);
382 : }
383 198 : if (m_pImpl->m_pProps->m_pFrameDirItem.get())
384 : {
385 0 : aSet.Put(*m_pImpl->m_pProps->m_pFrameDirItem);
386 : }
387 198 : if (m_pImpl->m_pProps->m_pLRSpaceItem.get())
388 : {
389 9 : aSet.Put(*m_pImpl->m_pProps->m_pLRSpaceItem);
390 : }
391 : // section password
392 198 : if (m_pImpl->m_pProps->m_Password.getLength() > 0)
393 : {
394 2 : aSect.SetPassword(m_pImpl->m_pProps->m_Password);
395 : }
396 :
397 : SwSection *const pRet =
398 198 : pDoc->InsertSwSection( aPam, aSect, 0, aSet.Count() ? &aSet : 0 );
399 198 : if (!pRet) // fdo#42450 text range could parially overlap existing section
400 : {
401 : // shouldn't have created an undo object yet
402 0 : pDoc->GetIDocumentUndoRedo().EndUndo( UNDO_INSSECTION, NULL );
403 : throw lang::IllegalArgumentException(
404 : "SwXTextSection::attach(): invalid TextRange",
405 0 : static_cast< ::cppu::OWeakObject*>(this), 0);
406 : }
407 198 : pRet->GetFormat()->Add(m_pImpl.get());
408 198 : pRet->GetFormat()->SetXObject(static_cast< ::cppu::OWeakObject*>(this));
409 :
410 : // XML import must hide sections depending on their old
411 : // condition status
412 198 : if (!m_pImpl->m_pProps->m_sCondition.isEmpty())
413 : {
414 5 : pRet->SetCondHidden(m_pImpl->m_pProps->m_bCondHidden);
415 : }
416 :
417 : // set update type if DDE link (and connect, if necessary)
418 198 : if (m_pImpl->m_pProps->m_bDDE)
419 : {
420 0 : if (! pRet->IsConnected())
421 : {
422 0 : pRet->CreateLink(CREATE_CONNECT);
423 : }
424 0 : pRet->SetUpdateType( m_pImpl->m_pProps->m_bUpdateType ?
425 0 : SfxLinkUpdateMode::ALWAYS : SfxLinkUpdateMode::ONCALL );
426 : }
427 :
428 : // Undo-Klammerung hier beenden
429 198 : pDoc->GetIDocumentUndoRedo().EndUndo( UNDO_INSSECTION, NULL );
430 198 : m_pImpl->m_pProps.reset();
431 396 : m_pImpl->m_bIsDescriptor = false;
432 198 : }
433 :
434 : uno::Reference< text::XTextRange > SAL_CALL
435 0 : SwXTextSection::getAnchor() throw (uno::RuntimeException, std::exception)
436 : {
437 0 : SolarMutexGuard aGuard;
438 :
439 0 : uno::Reference< text::XTextRange > xRet;
440 0 : SwSectionFormat *const pSectFormat = m_pImpl->GetSectionFormat();
441 0 : if(pSectFormat)
442 : {
443 : const SwNodeIndex* pIdx;
444 0 : if( 0 != ( pSectFormat->GetSection() ) &&
445 0 : 0 != ( pIdx = pSectFormat->GetContent().GetContentIdx() ) &&
446 0 : pIdx->GetNode().GetNodes().IsDocNodes() )
447 : {
448 0 : SwPaM aPaM(*pIdx);
449 0 : aPaM.Move( fnMoveForward, fnGoContent );
450 :
451 0 : const SwEndNode* pEndNode = pIdx->GetNode().EndOfSectionNode();
452 0 : SwPaM aEnd(*pEndNode);
453 0 : aEnd.Move( fnMoveBackward, fnGoContent );
454 0 : xRet = SwXTextRange::CreateXTextRange(*pSectFormat->GetDoc(),
455 0 : *aPaM.Start(), aEnd.Start());
456 : }
457 : }
458 0 : return xRet;
459 : }
460 :
461 2 : void SAL_CALL SwXTextSection::dispose() throw (uno::RuntimeException, std::exception)
462 : {
463 2 : SolarMutexGuard aGuard;
464 :
465 2 : SwSectionFormat *const pSectFormat = m_pImpl->GetSectionFormat();
466 2 : if (pSectFormat)
467 : {
468 2 : pSectFormat->GetDoc()->DelSectionFormat( pSectFormat );
469 2 : }
470 2 : }
471 :
472 0 : void SAL_CALL SwXTextSection::addEventListener(
473 : const uno::Reference< lang::XEventListener > & xListener)
474 : throw (uno::RuntimeException, std::exception)
475 : {
476 : // no need to lock here as m_pImpl is const and container threadsafe
477 0 : m_pImpl->m_EventListeners.addInterface(xListener);
478 0 : }
479 :
480 0 : void SAL_CALL SwXTextSection::removeEventListener(
481 : const uno::Reference< lang::XEventListener > & xListener)
482 : throw (uno::RuntimeException, std::exception)
483 : {
484 : // no need to lock here as m_pImpl is const and container threadsafe
485 0 : m_pImpl->m_EventListeners.removeInterface(xListener);
486 0 : }
487 :
488 : uno::Reference< beans::XPropertySetInfo > SAL_CALL
489 294 : SwXTextSection::getPropertySetInfo() throw (uno::RuntimeException, std::exception)
490 : {
491 294 : SolarMutexGuard g;
492 :
493 : static const uno::Reference< beans::XPropertySetInfo > aRef =
494 294 : m_pImpl->m_rPropSet.getPropertySetInfo();
495 294 : return aRef;
496 : }
497 :
498 : static void
499 0 : lcl_UpdateLinkType(SwSection & rSection, bool const bLinkUpdateAlways = true)
500 : {
501 0 : if (rSection.GetType() == DDE_LINK_SECTION)
502 : {
503 : // set update type; needs an established link
504 0 : if (!rSection.IsConnected())
505 : {
506 0 : rSection.CreateLink(CREATE_CONNECT);
507 : }
508 : rSection.SetUpdateType( bLinkUpdateAlways
509 0 : ? SfxLinkUpdateMode::ALWAYS : SfxLinkUpdateMode::ONCALL );
510 : }
511 0 : }
512 :
513 : static void
514 300 : lcl_UpdateSection(SwSectionFormat *const pFormat,
515 : ::std::unique_ptr<SwSectionData> const& pSectionData,
516 : ::std::unique_ptr<SfxItemSet> const& pItemSet,
517 : bool const bLinkModeChanged, bool const bLinkUpdateAlways = true)
518 : {
519 300 : if (pFormat)
520 : {
521 69 : SwSection & rSection = *pFormat->GetSection();
522 69 : SwDoc *const pDoc = pFormat->GetDoc();
523 69 : SwSectionFormats const& rFormats = pDoc->GetSections();
524 69 : UnoActionContext aContext(pDoc);
525 116 : for (size_t i = 0; i < rFormats.size(); ++i)
526 : {
527 348 : if (rFormats[i]->GetSection()->GetSectionName()
528 348 : == rSection.GetSectionName())
529 : {
530 69 : pDoc->UpdateSection(i, *pSectionData, pItemSet.get(),
531 138 : pDoc->IsInReading());
532 : {
533 : // temporarily remove actions to allow cursor update
534 69 : UnoActionRemoveContext aRemoveContext( pDoc );
535 : }
536 :
537 69 : if (bLinkModeChanged)
538 : {
539 0 : lcl_UpdateLinkType(rSection, bLinkUpdateAlways);
540 : }
541 : // section found and processed: break from loop
542 69 : break;
543 : }
544 69 : }
545 : }
546 300 : }
547 :
548 300 : void SwXTextSection::Impl::SetPropertyValues_Impl(
549 : const uno::Sequence< OUString >& rPropertyNames,
550 : const uno::Sequence< uno::Any >& rValues)
551 : throw (beans::UnknownPropertyException, beans::PropertyVetoException,
552 : lang::IllegalArgumentException, lang::WrappedTargetException,
553 : uno::RuntimeException)
554 : {
555 300 : if(rPropertyNames.getLength() != rValues.getLength())
556 : {
557 0 : throw lang::IllegalArgumentException();
558 : }
559 300 : SwSectionFormat *const pFormat = GetSectionFormat();
560 300 : if (!pFormat && !m_bIsDescriptor)
561 : {
562 0 : throw uno::RuntimeException();
563 : }
564 :
565 : ::std::unique_ptr<SwSectionData> const pSectionData(
566 300 : (pFormat) ? new SwSectionData(*pFormat->GetSection()) : 0);
567 :
568 300 : OUString const*const pPropertyNames = rPropertyNames.getConstArray();
569 300 : uno::Any const*const pValues = rValues.getConstArray();
570 600 : ::std::unique_ptr<SfxItemSet> pItemSet;
571 300 : bool bLinkModeChanged = false;
572 300 : bool bLinkMode = false;
573 :
574 792 : for (sal_Int32 nProperty = 0; nProperty < rPropertyNames.getLength();
575 : nProperty++)
576 : {
577 : SfxItemPropertySimpleEntry const*const pEntry =
578 492 : m_rPropSet.getPropertyMap().getByName(pPropertyNames[nProperty]);
579 492 : if (!pEntry)
580 : {
581 : throw beans::UnknownPropertyException(
582 0 : "Unknown property: " + pPropertyNames[nProperty],
583 0 : static_cast<cppu::OWeakObject *>(& m_rThis));
584 : }
585 492 : if (pEntry->nFlags & beans::PropertyAttribute::READONLY)
586 : {
587 : throw beans::PropertyVetoException(
588 0 : "Property is read-only: " + pPropertyNames[nProperty],
589 0 : static_cast<cppu::OWeakObject *>(& m_rThis));
590 : }
591 492 : switch (pEntry->nWID)
592 : {
593 : case WID_SECT_CONDITION:
594 : {
595 5 : OUString uTmp;
596 5 : pValues[nProperty] >>= uTmp;
597 5 : if (m_bIsDescriptor)
598 : {
599 5 : m_pProps->m_sCondition = uTmp;
600 : }
601 : else
602 : {
603 0 : pSectionData->SetCondition(uTmp);
604 5 : }
605 : }
606 5 : break;
607 : case WID_SECT_DDE_TYPE:
608 : case WID_SECT_DDE_FILE:
609 : case WID_SECT_DDE_ELEMENT:
610 : {
611 0 : OUString sTmp;
612 0 : pValues[nProperty] >>= sTmp;
613 0 : if (m_bIsDescriptor)
614 : {
615 0 : if (!m_pProps->m_bDDE)
616 : {
617 0 : m_pProps->m_sLinkFileName =
618 0 : OUString(sfx2::cTokenSeparator) + OUString(sfx2::cTokenSeparator);
619 0 : m_pProps->m_bDDE = true;
620 : }
621 0 : m_pProps->m_sLinkFileName = comphelper::string::setToken(
622 0 : m_pProps->m_sLinkFileName,
623 0 : pEntry->nWID - WID_SECT_DDE_TYPE, sfx2::cTokenSeparator, sTmp);
624 : }
625 : else
626 : {
627 0 : OUString sLinkFileName(pSectionData->GetLinkFileName());
628 0 : if (pSectionData->GetType() != DDE_LINK_SECTION)
629 : {
630 0 : sLinkFileName = OUString(sfx2::cTokenSeparator) + OUString(sfx2::cTokenSeparator);
631 0 : pSectionData->SetType(DDE_LINK_SECTION);
632 : }
633 0 : sLinkFileName = comphelper::string::setToken(sLinkFileName,
634 : pEntry->nWID - WID_SECT_DDE_TYPE,
635 0 : sfx2::cTokenSeparator, sTmp);
636 0 : pSectionData->SetLinkFileName(sLinkFileName);
637 0 : }
638 : }
639 0 : break;
640 : case WID_SECT_DDE_AUTOUPDATE:
641 : {
642 0 : bool bVal(false);
643 0 : if (!(pValues[nProperty] >>= bVal))
644 : {
645 0 : throw lang::IllegalArgumentException();
646 : }
647 0 : if (m_bIsDescriptor)
648 : {
649 0 : m_pProps->m_bUpdateType = bVal;
650 : }
651 : else
652 : {
653 0 : bLinkModeChanged = true;
654 0 : bLinkMode = bVal;
655 : }
656 : }
657 0 : break;
658 : case WID_SECT_LINK:
659 : {
660 2 : text::SectionFileLink aLink;
661 2 : if (!(pValues[nProperty] >>= aLink))
662 : {
663 0 : throw lang::IllegalArgumentException();
664 : }
665 2 : if (m_bIsDescriptor)
666 : {
667 0 : m_pProps->m_bDDE = false;
668 0 : m_pProps->m_sLinkFileName = aLink.FileURL;
669 0 : m_pProps->m_sSectionFilter = aLink.FilterName;
670 : }
671 : else
672 : {
673 4 : if (pSectionData->GetType() != FILE_LINK_SECTION &&
674 2 : !aLink.FileURL.isEmpty())
675 : {
676 2 : pSectionData->SetType(FILE_LINK_SECTION);
677 : }
678 2 : const OUString sTmp(!aLink.FileURL.isEmpty()
679 : ? URIHelper::SmartRel2Abs(
680 2 : pFormat->GetDoc()->GetDocShell()->GetMedium()->GetURLObject(),
681 : aLink.FileURL, URIHelper::GetMaybeFileHdl())
682 4 : : OUString());
683 : const OUString sFileName(
684 4 : sTmp + OUString(sfx2::cTokenSeparator) +
685 8 : aLink.FilterName + OUString(sfx2::cTokenSeparator) +
686 8 : pSectionData->GetLinkFileName().getToken(2, sfx2::cTokenSeparator));
687 2 : pSectionData->SetLinkFileName(sFileName);
688 2 : if (sFileName.getLength() < 3)
689 : {
690 0 : pSectionData->SetType(CONTENT_SECTION);
691 2 : }
692 2 : }
693 : }
694 2 : break;
695 : case WID_SECT_REGION:
696 : {
697 2 : OUString sLink;
698 2 : pValues[nProperty] >>= sLink;
699 2 : if (m_bIsDescriptor)
700 : {
701 0 : m_pProps->m_bDDE = false;
702 0 : m_pProps->m_sSectionRegion = sLink;
703 : }
704 : else
705 : {
706 2 : if (pSectionData->GetType() != FILE_LINK_SECTION &&
707 0 : !sLink.isEmpty())
708 : {
709 0 : pSectionData->SetType(FILE_LINK_SECTION);
710 : }
711 2 : OUString sSectLink(pSectionData->GetLinkFileName());
712 2 : for (sal_Int32 i = comphelper::string::getTokenCount(sSectLink, sfx2::cTokenSeparator);
713 : i < 3; ++i)
714 : {
715 0 : sSectLink += OUString(sfx2::cTokenSeparator);
716 : }
717 2 : sSectLink = comphelper::string::setToken(sSectLink, 2, sfx2::cTokenSeparator, sLink);
718 2 : pSectionData->SetLinkFileName(sSectLink);
719 2 : if (sSectLink.getLength() < 3)
720 : {
721 0 : pSectionData->SetType(CONTENT_SECTION);
722 2 : }
723 2 : }
724 : }
725 2 : break;
726 : case WID_SECT_VISIBLE:
727 : {
728 60 : bool bVal(false);
729 60 : if (!(pValues[nProperty] >>= bVal))
730 : {
731 0 : throw lang::IllegalArgumentException();
732 : }
733 60 : if (m_bIsDescriptor)
734 : {
735 60 : m_pProps->m_bHidden = !bVal;
736 : }
737 : else
738 : {
739 0 : pSectionData->SetHidden(!bVal);
740 : }
741 : }
742 60 : break;
743 : case WID_SECT_CURRENTLY_VISIBLE:
744 : {
745 2 : bool bVal(false);
746 2 : if (!(pValues[nProperty] >>= bVal))
747 : {
748 0 : throw lang::IllegalArgumentException();
749 : }
750 2 : if (m_bIsDescriptor)
751 : {
752 2 : m_pProps->m_bCondHidden = !bVal;
753 : }
754 : else
755 : {
756 0 : if (!pSectionData->GetCondition().isEmpty())
757 : {
758 0 : pSectionData->SetCondHidden(!bVal);
759 : }
760 : }
761 : }
762 2 : break;
763 : case WID_SECT_PROTECTED:
764 : {
765 81 : bool bVal(false);
766 81 : if (!(pValues[nProperty] >>= bVal))
767 : {
768 0 : throw lang::IllegalArgumentException();
769 : }
770 81 : if (m_bIsDescriptor)
771 : {
772 81 : m_pProps->m_bProtect = bVal;
773 : }
774 : else
775 : {
776 0 : pSectionData->SetProtectFlag(bVal);
777 : }
778 : }
779 81 : break;
780 : case WID_SECT_EDIT_IN_READONLY:
781 : {
782 66 : bool bVal(false);
783 66 : if (!(pValues[nProperty] >>= bVal))
784 : {
785 0 : throw lang::IllegalArgumentException();
786 : }
787 66 : if (m_bIsDescriptor)
788 : {
789 66 : m_pProps->m_bEditInReadonly = bVal;
790 : }
791 : else
792 : {
793 0 : pSectionData->SetEditInReadonlyFlag(bVal);
794 : }
795 : }
796 66 : break;
797 : case WID_SECT_PASSWORD:
798 : {
799 2 : uno::Sequence<sal_Int8> aSeq;
800 2 : pValues[nProperty] >>= aSeq;
801 2 : if (m_bIsDescriptor)
802 : {
803 2 : m_pProps->m_Password = aSeq;
804 : }
805 : else
806 : {
807 0 : pSectionData->SetPassword(aSeq);
808 2 : }
809 : }
810 2 : break;
811 : default:
812 : {
813 272 : if (pFormat)
814 : {
815 65 : const SfxItemSet& rOldAttrSet = pFormat->GetAttrSet();
816 65 : pItemSet.reset( new SfxItemSet(*rOldAttrSet.GetPool(), pEntry->nWID, pEntry->nWID));
817 65 : pItemSet->Put(rOldAttrSet);
818 : m_rPropSet.setPropertyValue(*pEntry,
819 65 : pValues[nProperty], *pItemSet);
820 : }
821 : else
822 : {
823 207 : SfxPoolItem* pPutItem = 0;
824 207 : if (RES_COL == pEntry->nWID)
825 : {
826 81 : if (!m_pProps->m_pColItem.get())
827 : {
828 81 : m_pProps->m_pColItem.reset(new SwFormatCol);
829 : }
830 81 : pPutItem = m_pProps->m_pColItem.get();
831 : }
832 126 : else if (RES_BACKGROUND == pEntry->nWID)
833 : {
834 70 : if (!m_pProps->m_pBrushItem.get())
835 : {
836 14 : m_pProps->m_pBrushItem.reset(
837 28 : new SvxBrushItem(RES_BACKGROUND));
838 : }
839 70 : pPutItem = m_pProps->m_pBrushItem.get();
840 : }
841 56 : else if (RES_FTN_AT_TXTEND == pEntry->nWID)
842 : {
843 14 : if (!m_pProps->m_pFootnoteItem.get())
844 : {
845 2 : m_pProps->m_pFootnoteItem.reset(new SwFormatFootnoteAtTextEnd);
846 : }
847 14 : pPutItem = m_pProps->m_pFootnoteItem.get();
848 : }
849 42 : else if (RES_END_AT_TXTEND == pEntry->nWID)
850 : {
851 14 : if (!m_pProps->m_pEndItem.get())
852 : {
853 2 : m_pProps->m_pEndItem.reset(new SwFormatEndAtTextEnd);
854 : }
855 14 : pPutItem = m_pProps->m_pEndItem.get();
856 : }
857 28 : else if (RES_UNKNOWNATR_CONTAINER== pEntry->nWID)
858 : {
859 0 : if (!m_pProps->m_pXMLAttr.get())
860 : {
861 0 : m_pProps->m_pXMLAttr.reset(
862 : new SvXMLAttrContainerItem(
863 0 : RES_UNKNOWNATR_CONTAINER));
864 : }
865 0 : pPutItem = m_pProps->m_pXMLAttr.get();
866 : }
867 28 : else if (RES_COLUMNBALANCE== pEntry->nWID)
868 : {
869 10 : if (!m_pProps->m_pNoBalanceItem.get())
870 : {
871 10 : m_pProps->m_pNoBalanceItem.reset(
872 20 : new SwFormatNoBalancedColumns(true));
873 : }
874 10 : pPutItem = m_pProps->m_pNoBalanceItem.get();
875 : }
876 18 : else if (RES_FRAMEDIR == pEntry->nWID)
877 : {
878 0 : if (!m_pProps->m_pFrameDirItem.get())
879 : {
880 0 : m_pProps->m_pFrameDirItem.reset(
881 : new SvxFrameDirectionItem(
882 0 : FRMDIR_HORI_LEFT_TOP, RES_FRAMEDIR));
883 : }
884 0 : pPutItem = m_pProps->m_pFrameDirItem.get();
885 : }
886 18 : else if (RES_LR_SPACE == pEntry->nWID)
887 : {
888 18 : if (!m_pProps->m_pLRSpaceItem.get())
889 : {
890 9 : m_pProps->m_pLRSpaceItem.reset(
891 18 : new SvxLRSpaceItem( RES_LR_SPACE ));
892 : }
893 18 : pPutItem = m_pProps->m_pLRSpaceItem.get();
894 : }
895 207 : if (pPutItem)
896 : {
897 207 : pPutItem->PutValue(pValues[nProperty],
898 414 : pEntry->nMemberId);
899 : }
900 : }
901 : }
902 : }
903 : }
904 :
905 : lcl_UpdateSection(pFormat, pSectionData, pItemSet, bLinkModeChanged,
906 600 : bLinkMode);
907 300 : }
908 :
909 : void SAL_CALL
910 81 : SwXTextSection::setPropertyValues(
911 : const uno::Sequence< OUString >& rPropertyNames,
912 : const uno::Sequence< uno::Any >& rValues)
913 : throw (beans::PropertyVetoException, lang::IllegalArgumentException,
914 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
915 : {
916 81 : SolarMutexGuard aGuard;
917 :
918 : // workaround for bad designed API
919 : try
920 : {
921 81 : m_pImpl->SetPropertyValues_Impl( rPropertyNames, rValues );
922 : }
923 0 : catch (const beans::UnknownPropertyException &rException)
924 : {
925 : // wrap the original (here not allowed) exception in
926 : // a WrappedTargetException that gets thrown instead.
927 0 : lang::WrappedTargetException aWExc;
928 0 : aWExc.TargetException <<= rException;
929 0 : throw aWExc;
930 81 : }
931 81 : }
932 :
933 219 : void SwXTextSection::setPropertyValue(
934 : const OUString& rPropertyName, const uno::Any& rValue)
935 : throw (beans::UnknownPropertyException, beans::PropertyVetoException,
936 : lang::IllegalArgumentException, lang::WrappedTargetException,
937 : uno::RuntimeException, std::exception )
938 : {
939 219 : SolarMutexGuard aGuard;
940 :
941 438 : uno::Sequence< OUString > aPropertyNames(1);
942 219 : aPropertyNames.getArray()[0] = rPropertyName;
943 438 : uno::Sequence< uno::Any > aValues(1);
944 219 : aValues.getArray()[0] = rValue;
945 438 : m_pImpl->SetPropertyValues_Impl( aPropertyNames, aValues );
946 219 : }
947 :
948 : uno::Sequence< uno::Any >
949 469 : SwXTextSection::Impl::GetPropertyValues_Impl(
950 : const uno::Sequence< OUString > & rPropertyNames )
951 : throw (beans::UnknownPropertyException, lang::WrappedTargetException,
952 : uno::RuntimeException)
953 : {
954 469 : SwSectionFormat *const pFormat = GetSectionFormat();
955 469 : if (!pFormat && !m_bIsDescriptor)
956 : {
957 0 : throw uno::RuntimeException();
958 : }
959 :
960 469 : uno::Sequence< uno::Any > aRet(rPropertyNames.getLength());
961 469 : uno::Any* pRet = aRet.getArray();
962 469 : SwSection *const pSect = (pFormat) ? pFormat->GetSection() : 0;
963 469 : const OUString* pPropertyNames = rPropertyNames.getConstArray();
964 :
965 1014 : for (sal_Int32 nProperty = 0; nProperty < rPropertyNames.getLength();
966 : nProperty++)
967 : {
968 : SfxItemPropertySimpleEntry const*const pEntry =
969 545 : m_rPropSet.getPropertyMap().getByName(pPropertyNames[nProperty]);
970 545 : if (!pEntry)
971 : {
972 : throw beans::UnknownPropertyException(
973 0 : "Unknown property: " + pPropertyNames[nProperty],
974 0 : static_cast<cppu::OWeakObject *>(& m_rThis));
975 : }
976 545 : switch(pEntry->nWID)
977 : {
978 : case WID_SECT_CONDITION:
979 : {
980 : const OUString uTmp( (m_bIsDescriptor)
981 1 : ? m_pProps->m_sCondition
982 25 : : pSect->GetCondition());
983 24 : pRet[nProperty] <<= uTmp;
984 : }
985 24 : break;
986 : case WID_SECT_DDE_TYPE:
987 : case WID_SECT_DDE_FILE:
988 : case WID_SECT_DDE_ELEMENT:
989 : {
990 63 : OUString sRet;
991 63 : if (m_bIsDescriptor)
992 : {
993 0 : if (m_pProps->m_bDDE)
994 : {
995 0 : sRet = m_pProps->m_sLinkFileName;
996 : }
997 : }
998 63 : else if (DDE_LINK_SECTION == pSect->GetType())
999 : {
1000 0 : sRet = pSect->GetLinkFileName();
1001 : }
1002 126 : pRet[nProperty] <<= sRet.getToken(pEntry->nWID - WID_SECT_DDE_TYPE,
1003 126 : sfx2::cTokenSeparator);
1004 : }
1005 63 : break;
1006 : case WID_SECT_DDE_AUTOUPDATE:
1007 : {
1008 : // GetUpdateType() returns .._ALWAYS or .._ONCALL
1009 0 : if (pSect && pSect->IsLinkType() && pSect->IsConnected()) // #i73247#
1010 : {
1011 : const bool bTemp =
1012 0 : (pSect->GetUpdateType() == SfxLinkUpdateMode::ALWAYS);
1013 0 : pRet[nProperty] <<= bTemp;
1014 : }
1015 : }
1016 0 : break;
1017 : case WID_SECT_LINK :
1018 : {
1019 21 : text::SectionFileLink aLink;
1020 21 : if (m_bIsDescriptor)
1021 : {
1022 0 : if (!m_pProps->m_bDDE)
1023 : {
1024 0 : aLink.FileURL = m_pProps->m_sLinkFileName;
1025 0 : aLink.FilterName = m_pProps->m_sSectionFilter;
1026 : }
1027 : }
1028 21 : else if (FILE_LINK_SECTION == pSect->GetType())
1029 : {
1030 0 : const OUString sRet( pSect->GetLinkFileName() );
1031 0 : sal_Int32 nIndex(0);
1032 0 : aLink.FileURL =
1033 0 : sRet.getToken(0, sfx2::cTokenSeparator, nIndex);
1034 0 : aLink.FilterName =
1035 0 : sRet.getToken(0, sfx2::cTokenSeparator, nIndex);
1036 : }
1037 21 : pRet[nProperty] <<= aLink;
1038 : }
1039 21 : break;
1040 : case WID_SECT_REGION :
1041 : {
1042 21 : OUString sRet;
1043 21 : if (m_bIsDescriptor)
1044 : {
1045 0 : sRet = m_pProps->m_sSectionRegion;
1046 : }
1047 21 : else if (FILE_LINK_SECTION == pSect->GetType())
1048 : {
1049 0 : sRet = pSect->GetLinkFileName().getToken(2,
1050 0 : sfx2::cTokenSeparator);
1051 : }
1052 21 : pRet[nProperty] <<= sRet;
1053 : }
1054 21 : break;
1055 : case WID_SECT_VISIBLE :
1056 : {
1057 : const bool bTemp = (m_bIsDescriptor)
1058 22 : ? !m_pProps->m_bHidden : !pSect->IsHidden();
1059 22 : pRet[nProperty] <<= bTemp;
1060 : }
1061 22 : break;
1062 : case WID_SECT_CURRENTLY_VISIBLE:
1063 : {
1064 : const bool bTemp = (m_bIsDescriptor)
1065 1 : ? !m_pProps->m_bCondHidden : !pSect->IsCondHidden();
1066 1 : pRet[nProperty] <<= bTemp;
1067 : }
1068 1 : break;
1069 : case WID_SECT_PROTECTED:
1070 : {
1071 : const bool bTemp = (m_bIsDescriptor)
1072 21 : ? m_pProps->m_bProtect : pSect->IsProtect();
1073 21 : pRet[nProperty] <<= bTemp;
1074 : }
1075 21 : break;
1076 : case WID_SECT_EDIT_IN_READONLY:
1077 : {
1078 : const bool bTemp = (m_bIsDescriptor)
1079 76 : ? m_pProps->m_bEditInReadonly : pSect->IsEditInReadonly();
1080 76 : pRet[nProperty] <<= bTemp;
1081 : }
1082 76 : break;
1083 : case FN_PARAM_LINK_DISPLAY_NAME:
1084 : {
1085 0 : if (pFormat)
1086 : {
1087 0 : pRet[nProperty] <<= pFormat->GetSection()->GetSectionName();
1088 : }
1089 : }
1090 0 : break;
1091 : case WID_SECT_DOCUMENT_INDEX:
1092 : {
1093 : // search enclosing index
1094 76 : SwSection* pEnclosingSection = pSect;
1095 302 : while ((pEnclosingSection != NULL) &&
1096 92 : (TOX_CONTENT_SECTION != pEnclosingSection->GetType()))
1097 : {
1098 58 : pEnclosingSection = pEnclosingSection->GetParent();
1099 : }
1100 : SwTOXBaseSection* const pTOXBaseSect = pEnclosingSection ?
1101 76 : PTR_CAST(SwTOXBaseSection, pEnclosingSection) : NULL;
1102 76 : if (pTOXBaseSect)
1103 : {
1104 : // convert section to TOXBase and get SwXDocumentIndex
1105 : const uno::Reference<text::XDocumentIndex> xIndex =
1106 : SwXDocumentIndex::CreateXDocumentIndex(
1107 34 : *pTOXBaseSect->GetFormat()->GetDoc(), pTOXBaseSect);
1108 34 : pRet[nProperty] <<= xIndex;
1109 : }
1110 : // else: no enclosing index found -> empty return value
1111 : }
1112 76 : break;
1113 : case WID_SECT_IS_GLOBAL_DOC_SECTION:
1114 : {
1115 0 : const bool bRet = pFormat && (NULL != pFormat->GetGlobalDocSection());
1116 0 : pRet[nProperty] <<= bRet;
1117 : }
1118 0 : break;
1119 : case FN_UNO_ANCHOR_TYPES:
1120 : case FN_UNO_TEXT_WRAP:
1121 : case FN_UNO_ANCHOR_TYPE:
1122 : ::sw::GetDefaultTextContentValue(
1123 0 : pRet[nProperty], OUString(), pEntry->nWID);
1124 0 : break;
1125 : case FN_UNO_REDLINE_NODE_START:
1126 : case FN_UNO_REDLINE_NODE_END:
1127 : {
1128 76 : if (!pFormat)
1129 0 : break; // #i73247#
1130 76 : SwNode* pSectNode = pFormat->GetSectionNode();
1131 76 : if (FN_UNO_REDLINE_NODE_END == pEntry->nWID)
1132 : {
1133 38 : pSectNode = pSectNode->EndOfSectionNode();
1134 : }
1135 : const SwRedlineTable& rRedTable =
1136 76 : pFormat->GetDoc()->getIDocumentRedlineAccess().GetRedlineTable();
1137 76 : for (size_t nRed = 0; nRed < rRedTable.size(); ++nRed)
1138 : {
1139 0 : const SwRangeRedline* pRedline = rRedTable[nRed];
1140 0 : const SwNode& rRedPointNode = pRedline->GetNode(true);
1141 0 : const SwNode& rRedMarkNode = pRedline->GetNode(false);
1142 0 : if ((&rRedPointNode == pSectNode) ||
1143 : (&rRedMarkNode == pSectNode))
1144 : {
1145 : const SwNode& rStartOfRedline =
1146 0 : (SwNodeIndex(rRedPointNode) <=
1147 : SwNodeIndex(rRedMarkNode))
1148 0 : ? rRedPointNode : rRedMarkNode;
1149 0 : const bool bIsStart = (&rStartOfRedline == pSectNode);
1150 0 : pRet[nProperty] <<=
1151 : SwXRedlinePortion::CreateRedlineProperties(
1152 0 : *pRedline, bIsStart);
1153 0 : break;
1154 : }
1155 : }
1156 : }
1157 76 : break;
1158 : case WID_SECT_PASSWORD:
1159 : {
1160 21 : pRet[nProperty] <<= (m_bIsDescriptor)
1161 21 : ? m_pProps->m_Password : pSect->GetPassword();
1162 : }
1163 21 : break;
1164 : default:
1165 : {
1166 123 : if (pFormat)
1167 : {
1168 : m_rPropSet.getPropertyValue(*pEntry,
1169 123 : pFormat->GetAttrSet(), pRet[nProperty]);
1170 : }
1171 : else
1172 : {
1173 0 : const SfxPoolItem* pQueryItem = 0;
1174 0 : if (RES_COL == pEntry->nWID)
1175 : {
1176 0 : if (!m_pProps->m_pColItem.get())
1177 : {
1178 0 : m_pProps->m_pColItem.reset(new SwFormatCol);
1179 : }
1180 0 : pQueryItem = m_pProps->m_pColItem.get();
1181 : }
1182 0 : else if (RES_BACKGROUND == pEntry->nWID)
1183 : {
1184 0 : if (!m_pProps->m_pBrushItem.get())
1185 : {
1186 0 : m_pProps->m_pBrushItem.reset(
1187 0 : new SvxBrushItem(RES_BACKGROUND));
1188 : }
1189 0 : pQueryItem = m_pProps->m_pBrushItem.get();
1190 : }
1191 0 : else if (RES_FTN_AT_TXTEND == pEntry->nWID)
1192 : {
1193 0 : if (!m_pProps->m_pFootnoteItem.get())
1194 : {
1195 0 : m_pProps->m_pFootnoteItem.reset(new SwFormatFootnoteAtTextEnd);
1196 : }
1197 0 : pQueryItem = m_pProps->m_pFootnoteItem.get();
1198 : }
1199 0 : else if (RES_END_AT_TXTEND == pEntry->nWID)
1200 : {
1201 0 : if (!m_pProps->m_pEndItem.get())
1202 : {
1203 0 : m_pProps->m_pEndItem.reset(new SwFormatEndAtTextEnd);
1204 : }
1205 0 : pQueryItem = m_pProps->m_pEndItem.get();
1206 : }
1207 0 : else if (RES_UNKNOWNATR_CONTAINER== pEntry->nWID)
1208 : {
1209 0 : if (!m_pProps->m_pXMLAttr.get())
1210 : {
1211 0 : m_pProps->m_pXMLAttr.reset(
1212 0 : new SvXMLAttrContainerItem);
1213 : }
1214 0 : pQueryItem = m_pProps->m_pXMLAttr.get();
1215 : }
1216 0 : else if (RES_COLUMNBALANCE== pEntry->nWID)
1217 : {
1218 0 : if (!m_pProps->m_pNoBalanceItem.get())
1219 : {
1220 0 : m_pProps->m_pNoBalanceItem.reset(
1221 0 : new SwFormatNoBalancedColumns);
1222 : }
1223 0 : pQueryItem = m_pProps->m_pNoBalanceItem.get();
1224 : }
1225 0 : else if (RES_FRAMEDIR == pEntry->nWID)
1226 : {
1227 0 : if (!m_pProps->m_pFrameDirItem.get())
1228 : {
1229 0 : m_pProps->m_pFrameDirItem.reset(
1230 : new SvxFrameDirectionItem(
1231 0 : FRMDIR_ENVIRONMENT, RES_FRAMEDIR));
1232 : }
1233 0 : pQueryItem = m_pProps->m_pFrameDirItem.get();
1234 : }
1235 0 : else if (RES_LR_SPACE == pEntry->nWID)
1236 : {
1237 0 : if (!m_pProps->m_pLRSpaceItem.get())
1238 : {
1239 0 : m_pProps->m_pLRSpaceItem.reset(
1240 0 : new SvxLRSpaceItem( RES_LR_SPACE ));
1241 : }
1242 0 : pQueryItem = m_pProps->m_pLRSpaceItem.get();
1243 : }
1244 0 : if (pQueryItem)
1245 : {
1246 0 : pQueryItem->QueryValue(pRet[nProperty],
1247 0 : pEntry->nMemberId);
1248 : }
1249 : }
1250 : }
1251 : }
1252 : }
1253 469 : return aRet;
1254 : }
1255 :
1256 : uno::Sequence< uno::Any > SAL_CALL
1257 76 : SwXTextSection::getPropertyValues(
1258 : const uno::Sequence< OUString >& rPropertyNames)
1259 : throw (uno::RuntimeException, std::exception)
1260 : {
1261 76 : SolarMutexGuard aGuard;
1262 76 : uno::Sequence< uno::Any > aValues;
1263 :
1264 : // workaround for bad designed API
1265 : try
1266 : {
1267 76 : aValues = m_pImpl->GetPropertyValues_Impl( rPropertyNames );
1268 : }
1269 0 : catch (beans::UnknownPropertyException &)
1270 : {
1271 : throw uno::RuntimeException("Unknown property exception caught",
1272 0 : static_cast<cppu::OWeakObject *>(this));
1273 : }
1274 0 : catch (lang::WrappedTargetException &)
1275 : {
1276 : throw uno::RuntimeException("WrappedTargetException caught",
1277 0 : static_cast<cppu::OWeakObject *>(this));
1278 : }
1279 :
1280 76 : return aValues;
1281 : }
1282 :
1283 : uno::Any SAL_CALL
1284 393 : SwXTextSection::getPropertyValue(const OUString& rPropertyName)
1285 : throw (beans::UnknownPropertyException, lang::WrappedTargetException,
1286 : uno::RuntimeException, std::exception)
1287 : {
1288 393 : SolarMutexGuard aGuard;
1289 :
1290 786 : uno::Sequence< OUString > aPropertyNames(1);
1291 393 : aPropertyNames.getArray()[0] = rPropertyName;
1292 786 : return m_pImpl->GetPropertyValues_Impl(aPropertyNames).getConstArray()[0];
1293 : }
1294 :
1295 0 : void SAL_CALL SwXTextSection::addPropertiesChangeListener(
1296 : const uno::Sequence< OUString >& /*aPropertyNames*/,
1297 : const uno::Reference< beans::XPropertiesChangeListener >& /*xListener*/ )
1298 : throw (uno::RuntimeException, std::exception)
1299 : {
1300 : OSL_FAIL("SwXTextSection::addPropertiesChangeListener(): not implemented");
1301 0 : }
1302 :
1303 0 : void SAL_CALL SwXTextSection::removePropertiesChangeListener(
1304 : const uno::Reference< beans::XPropertiesChangeListener >& /*xListener*/ )
1305 : throw (uno::RuntimeException, std::exception)
1306 : {
1307 : OSL_FAIL("SwXTextSection::removePropertiesChangeListener(): not implemented");
1308 0 : }
1309 :
1310 0 : void SAL_CALL SwXTextSection::firePropertiesChangeEvent(
1311 : const uno::Sequence< OUString >& /*aPropertyNames*/,
1312 : const uno::Reference< beans::XPropertiesChangeListener >& /*xListener*/ )
1313 : throw(uno::RuntimeException, std::exception)
1314 : {
1315 : OSL_FAIL("SwXTextSection::firePropertiesChangeEvent(): not implemented");
1316 0 : }
1317 :
1318 : void SAL_CALL
1319 0 : SwXTextSection::addPropertyChangeListener(
1320 : const OUString& /*rPropertyName*/,
1321 : const uno::Reference< beans::XPropertyChangeListener >& /*xListener*/)
1322 : throw (beans::UnknownPropertyException, lang::WrappedTargetException,
1323 : uno::RuntimeException, std::exception)
1324 : {
1325 : OSL_FAIL("SwXTextSection::addPropertyChangeListener(): not implemented");
1326 0 : }
1327 :
1328 : void SAL_CALL
1329 0 : SwXTextSection::removePropertyChangeListener(
1330 : const OUString& /*rPropertyName*/,
1331 : const uno::Reference< beans::XPropertyChangeListener >& /*xListener*/)
1332 : throw (beans::UnknownPropertyException, lang::WrappedTargetException,
1333 : uno::RuntimeException, std::exception)
1334 : {
1335 : OSL_FAIL("SwXTextSection::removePropertyChangeListener(): not implemented");
1336 0 : }
1337 :
1338 : void SAL_CALL
1339 0 : SwXTextSection::addVetoableChangeListener(
1340 : const OUString& /*rPropertyName*/,
1341 : const uno::Reference< beans::XVetoableChangeListener >& /*xListener*/)
1342 : throw (beans::UnknownPropertyException, lang::WrappedTargetException,
1343 : uno::RuntimeException, std::exception)
1344 : {
1345 : OSL_FAIL("SwXTextSection::addVetoableChangeListener(): not implemented");
1346 0 : }
1347 :
1348 : void SAL_CALL
1349 0 : SwXTextSection::removeVetoableChangeListener(
1350 : const OUString& /*rPropertyName*/,
1351 : const uno::Reference< beans::XVetoableChangeListener >& /*xListener*/)
1352 : throw (beans::UnknownPropertyException, lang::WrappedTargetException,
1353 : uno::RuntimeException, std::exception)
1354 : {
1355 : OSL_FAIL("SwXTextSection::removeVetoableChangeListener(): not implemented");
1356 0 : }
1357 :
1358 : beans::PropertyState SAL_CALL
1359 0 : SwXTextSection::getPropertyState(const OUString& rPropertyName)
1360 : throw (beans::UnknownPropertyException, uno::RuntimeException, std::exception)
1361 : {
1362 0 : SolarMutexGuard aGuard;
1363 :
1364 0 : uno::Sequence< OUString > aNames(1);
1365 0 : aNames.getArray()[0] = rPropertyName;
1366 0 : return getPropertyStates(aNames).getConstArray()[0];
1367 : }
1368 :
1369 : uno::Sequence< beans::PropertyState > SAL_CALL
1370 76 : SwXTextSection::getPropertyStates(
1371 : const uno::Sequence< OUString >& rPropertyNames)
1372 : throw (beans::UnknownPropertyException, uno::RuntimeException, std::exception)
1373 : {
1374 76 : SolarMutexGuard aGuard;
1375 :
1376 76 : SwSectionFormat *const pFormat = m_pImpl->GetSectionFormat();
1377 76 : if (!pFormat && !m_pImpl->m_bIsDescriptor)
1378 : {
1379 0 : throw uno::RuntimeException();
1380 : }
1381 :
1382 76 : uno::Sequence< beans::PropertyState > aStates(rPropertyNames.getLength());
1383 76 : beans::PropertyState *const pStates = aStates.getArray();
1384 76 : const OUString* pNames = rPropertyNames.getConstArray();
1385 2052 : for (sal_Int32 i = 0; i < rPropertyNames.getLength(); i++)
1386 : {
1387 1976 : pStates[i] = beans::PropertyState_DEFAULT_VALUE;
1388 : SfxItemPropertySimpleEntry const*const pEntry =
1389 1976 : m_pImpl->m_rPropSet.getPropertyMap().getByName( pNames[i]);
1390 1976 : if (!pEntry)
1391 : {
1392 : throw beans::UnknownPropertyException(
1393 0 : "Unknown property: " + pNames[i],
1394 0 : static_cast< cppu::OWeakObject* >(this));
1395 : }
1396 1976 : switch (pEntry->nWID)
1397 : {
1398 : case WID_SECT_CONDITION:
1399 : case WID_SECT_DDE_TYPE:
1400 : case WID_SECT_DDE_FILE:
1401 : case WID_SECT_DDE_ELEMENT:
1402 : case WID_SECT_DDE_AUTOUPDATE:
1403 : case WID_SECT_LINK:
1404 : case WID_SECT_REGION :
1405 : case WID_SECT_VISIBLE:
1406 : case WID_SECT_PROTECTED:
1407 : case WID_SECT_EDIT_IN_READONLY:
1408 : case FN_PARAM_LINK_DISPLAY_NAME:
1409 : case FN_UNO_ANCHOR_TYPES:
1410 : case FN_UNO_TEXT_WRAP:
1411 : case FN_UNO_ANCHOR_TYPE:
1412 76 : pStates[i] = beans::PropertyState_DIRECT_VALUE;
1413 76 : break;
1414 : default:
1415 : {
1416 1900 : if (pFormat)
1417 : {
1418 3800 : pStates[i] = m_pImpl->m_rPropSet.getPropertyState(
1419 3800 : pNames[i], pFormat->GetAttrSet());
1420 : }
1421 : else
1422 : {
1423 0 : if (RES_COL == pEntry->nWID)
1424 : {
1425 0 : if (!m_pImpl->m_pProps->m_pColItem.get())
1426 : {
1427 0 : pStates[i] = beans::PropertyState_DEFAULT_VALUE;
1428 : }
1429 : else
1430 : {
1431 0 : pStates[i] = beans::PropertyState_DIRECT_VALUE;
1432 : }
1433 : }
1434 : else
1435 : {
1436 0 : if (!m_pImpl->m_pProps->m_pBrushItem.get())
1437 : {
1438 0 : pStates[i] = beans::PropertyState_DEFAULT_VALUE;
1439 : }
1440 : else
1441 : {
1442 0 : pStates[i] = beans::PropertyState_DIRECT_VALUE;
1443 : }
1444 : }
1445 : }
1446 : }
1447 : }
1448 : }
1449 76 : return aStates;
1450 : }
1451 :
1452 : void SAL_CALL
1453 0 : SwXTextSection::setPropertyToDefault(const OUString& rPropertyName)
1454 : throw (beans::UnknownPropertyException, uno::RuntimeException, std::exception)
1455 : {
1456 0 : SolarMutexGuard aGuard;
1457 :
1458 0 : SwSectionFormat *const pFormat = m_pImpl->GetSectionFormat();
1459 0 : if (!pFormat && !m_pImpl->m_bIsDescriptor)
1460 : {
1461 0 : throw uno::RuntimeException();
1462 : }
1463 :
1464 : SfxItemPropertySimpleEntry const*const pEntry =
1465 0 : m_pImpl->m_rPropSet.getPropertyMap().getByName(rPropertyName);
1466 0 : if (!pEntry)
1467 : {
1468 : throw beans::UnknownPropertyException(
1469 0 : "Unknown property: " + rPropertyName,
1470 0 : static_cast< cppu::OWeakObject* >(this));
1471 : }
1472 0 : if (pEntry->nFlags & beans::PropertyAttribute::READONLY)
1473 : {
1474 : throw uno::RuntimeException(
1475 0 : "Property is read-only: " + rPropertyName,
1476 0 : static_cast<cppu::OWeakObject *>(this));
1477 : }
1478 :
1479 : ::std::unique_ptr<SwSectionData> const pSectionData(
1480 0 : (pFormat) ? new SwSectionData(*pFormat->GetSection()) : 0);
1481 :
1482 0 : ::std::unique_ptr<SfxItemSet> pNewAttrSet;
1483 0 : bool bLinkModeChanged = false;
1484 :
1485 0 : switch (pEntry->nWID)
1486 : {
1487 : case WID_SECT_CONDITION:
1488 : {
1489 0 : if (m_pImpl->m_bIsDescriptor)
1490 : {
1491 0 : (m_pImpl->m_pProps->m_sCondition).clear();
1492 : }
1493 : else
1494 : {
1495 0 : pSectionData->SetCondition(OUString());
1496 : }
1497 : }
1498 0 : break;
1499 : case WID_SECT_DDE_TYPE :
1500 : case WID_SECT_DDE_FILE :
1501 : case WID_SECT_DDE_ELEMENT :
1502 : case WID_SECT_LINK :
1503 : case WID_SECT_REGION :
1504 0 : if (m_pImpl->m_bIsDescriptor)
1505 : {
1506 0 : m_pImpl->m_pProps->m_bDDE = false;
1507 0 : (m_pImpl->m_pProps->m_sLinkFileName).clear();
1508 0 : (m_pImpl->m_pProps->m_sSectionRegion).clear();
1509 0 : (m_pImpl->m_pProps->m_sSectionFilter).clear();
1510 : }
1511 : else
1512 : {
1513 0 : pSectionData->SetType(CONTENT_SECTION);
1514 : }
1515 0 : break;
1516 : case WID_SECT_DDE_AUTOUPDATE:
1517 0 : if (m_pImpl->m_bIsDescriptor)
1518 : {
1519 0 : m_pImpl->m_pProps->m_bUpdateType = true;
1520 : }
1521 : else
1522 : {
1523 0 : bLinkModeChanged = true;
1524 : }
1525 0 : break;
1526 : case WID_SECT_VISIBLE :
1527 : {
1528 0 : if (m_pImpl->m_bIsDescriptor)
1529 : {
1530 0 : m_pImpl->m_pProps->m_bHidden = false;
1531 : }
1532 : else
1533 : {
1534 0 : pSectionData->SetHidden(false);
1535 : }
1536 : }
1537 0 : break;
1538 : case WID_SECT_PROTECTED:
1539 : {
1540 0 : if (m_pImpl->m_bIsDescriptor)
1541 : {
1542 0 : m_pImpl->m_pProps->m_bProtect = false;
1543 : }
1544 : else
1545 : {
1546 0 : pSectionData->SetProtectFlag(false);
1547 : }
1548 : }
1549 0 : break;
1550 : case WID_SECT_EDIT_IN_READONLY:
1551 : {
1552 0 : if (m_pImpl->m_bIsDescriptor)
1553 : {
1554 0 : m_pImpl->m_pProps->m_bEditInReadonly = false;
1555 : }
1556 : else
1557 : {
1558 0 : pSectionData->SetEditInReadonlyFlag(false);
1559 : }
1560 : }
1561 0 : break;
1562 :
1563 : case FN_UNO_ANCHOR_TYPES:
1564 : case FN_UNO_TEXT_WRAP:
1565 : case FN_UNO_ANCHOR_TYPE:
1566 0 : break;
1567 : default:
1568 : {
1569 0 : if (pEntry->nWID <= SFX_WHICH_MAX)
1570 : {
1571 0 : if (pFormat)
1572 : {
1573 0 : const SfxItemSet& rOldAttrSet = pFormat->GetAttrSet();
1574 0 : pNewAttrSet.reset( new SfxItemSet(*rOldAttrSet.GetPool(), pEntry->nWID, pEntry->nWID));
1575 0 : pNewAttrSet->ClearItem(pEntry->nWID);
1576 : }
1577 : else
1578 : {
1579 0 : if (RES_COL == pEntry->nWID)
1580 : {
1581 0 : m_pImpl->m_pProps->m_pColItem.reset();
1582 : }
1583 0 : else if (RES_BACKGROUND == pEntry->nWID)
1584 : {
1585 0 : m_pImpl->m_pProps->m_pBrushItem.reset();
1586 : }
1587 : }
1588 : }
1589 : }
1590 : }
1591 :
1592 0 : lcl_UpdateSection(pFormat, pSectionData, pNewAttrSet, bLinkModeChanged);
1593 0 : }
1594 :
1595 : uno::Any SAL_CALL
1596 0 : SwXTextSection::getPropertyDefault(const OUString& rPropertyName)
1597 : throw (beans::UnknownPropertyException, lang::WrappedTargetException,
1598 : uno::RuntimeException, std::exception)
1599 : {
1600 0 : SolarMutexGuard aGuard;
1601 :
1602 0 : uno::Any aRet;
1603 0 : SwSectionFormat *const pFormat = m_pImpl->GetSectionFormat();
1604 : SfxItemPropertySimpleEntry const*const pEntry =
1605 0 : m_pImpl->m_rPropSet.getPropertyMap().getByName(rPropertyName);
1606 0 : if (!pEntry)
1607 : {
1608 : throw beans::UnknownPropertyException(
1609 0 : "Unknown property: " + rPropertyName,
1610 0 : static_cast<cppu::OWeakObject *>(this));
1611 : }
1612 :
1613 0 : switch(pEntry->nWID)
1614 : {
1615 : case WID_SECT_CONDITION:
1616 : case WID_SECT_DDE_TYPE :
1617 : case WID_SECT_DDE_FILE :
1618 : case WID_SECT_DDE_ELEMENT :
1619 : case WID_SECT_REGION :
1620 : case FN_PARAM_LINK_DISPLAY_NAME:
1621 0 : aRet <<= OUString();
1622 0 : break;
1623 : case WID_SECT_LINK :
1624 0 : aRet <<= text::SectionFileLink();
1625 0 : break;
1626 : case WID_SECT_DDE_AUTOUPDATE:
1627 : case WID_SECT_VISIBLE :
1628 0 : aRet <<= true;
1629 0 : break;
1630 : case WID_SECT_PROTECTED:
1631 : case WID_SECT_EDIT_IN_READONLY:
1632 0 : aRet <<= false;
1633 0 : break;
1634 : case FN_UNO_ANCHOR_TYPES:
1635 : case FN_UNO_TEXT_WRAP:
1636 : case FN_UNO_ANCHOR_TYPE:
1637 0 : ::sw::GetDefaultTextContentValue(aRet, OUString(), pEntry->nWID);
1638 0 : break;
1639 : default:
1640 0 : if(pFormat && pEntry->nWID <= SFX_WHICH_MAX)
1641 : {
1642 0 : SwDoc *const pDoc = pFormat->GetDoc();
1643 : const SfxPoolItem& rDefItem =
1644 0 : pDoc->GetAttrPool().GetDefaultItem(pEntry->nWID);
1645 0 : rDefItem.QueryValue(aRet, pEntry->nMemberId);
1646 : }
1647 : }
1648 0 : return aRet;
1649 : }
1650 :
1651 31 : OUString SAL_CALL SwXTextSection::getName() throw (uno::RuntimeException, std::exception)
1652 : {
1653 31 : SolarMutexGuard aGuard;
1654 :
1655 31 : OUString sRet;
1656 31 : SwSectionFormat const*const pFormat = m_pImpl->GetSectionFormat();
1657 31 : if(pFormat)
1658 : {
1659 31 : sRet = pFormat->GetSection()->GetSectionName();
1660 : }
1661 0 : else if (m_pImpl->m_bIsDescriptor)
1662 : {
1663 0 : sRet = m_pImpl->m_sName;
1664 : }
1665 : else
1666 : {
1667 0 : throw uno::RuntimeException();
1668 : }
1669 31 : return sRet;
1670 : }
1671 :
1672 81 : void SAL_CALL SwXTextSection::setName(const OUString& rName)
1673 : throw (uno::RuntimeException, std::exception)
1674 : {
1675 81 : SolarMutexGuard aGuard;
1676 :
1677 81 : SwSectionFormat *const pFormat = m_pImpl->GetSectionFormat();
1678 81 : if(pFormat)
1679 : {
1680 0 : SwSection *const pSect = pFormat->GetSection();
1681 0 : SwSectionData aSection(*pSect);
1682 0 : aSection.SetSectionName(rName);
1683 :
1684 0 : const SwSectionFormats& rFormats = pFormat->GetDoc()->GetSections();
1685 0 : size_t nApplyPos = SIZE_MAX;
1686 0 : for( size_t i = 0; i < rFormats.size(); ++i )
1687 : {
1688 0 : if(rFormats[i]->GetSection() == pSect)
1689 : {
1690 0 : nApplyPos = i;
1691 : }
1692 0 : else if (rName == rFormats[i]->GetSection()->GetSectionName())
1693 : {
1694 0 : throw uno::RuntimeException();
1695 : }
1696 : }
1697 0 : if (nApplyPos != SIZE_MAX)
1698 : {
1699 : {
1700 0 : UnoActionContext aContext(pFormat->GetDoc());
1701 0 : pFormat->GetDoc()->UpdateSection(nApplyPos, aSection);
1702 : }
1703 : {
1704 : // temporarily remove actions to allow cursor update
1705 0 : UnoActionRemoveContext aRemoveContext( pFormat->GetDoc() );
1706 : }
1707 0 : }
1708 : }
1709 81 : else if (m_pImpl->m_bIsDescriptor)
1710 : {
1711 81 : m_pImpl->m_sName = rName;
1712 : }
1713 : else
1714 : {
1715 0 : throw uno::RuntimeException();
1716 81 : }
1717 81 : }
1718 :
1719 : OUString SAL_CALL
1720 0 : SwXTextSection::getImplementationName() throw (uno::RuntimeException, std::exception)
1721 : {
1722 0 : return OUString("SwXTextSection");
1723 : }
1724 :
1725 : static char const*const g_ServicesTextSection[] =
1726 : {
1727 : "com.sun.star.text.TextContent",
1728 : "com.sun.star.text.TextSection",
1729 : "com.sun.star.document.LinkTarget",
1730 : };
1731 :
1732 0 : sal_Bool SAL_CALL SwXTextSection::supportsService(const OUString& rServiceName)
1733 : throw (uno::RuntimeException, std::exception)
1734 : {
1735 0 : return cppu::supportsService(this, rServiceName);
1736 : }
1737 :
1738 : uno::Sequence< OUString > SAL_CALL
1739 0 : SwXTextSection::getSupportedServiceNames() throw (uno::RuntimeException, std::exception)
1740 : {
1741 : return ::sw::GetSupportedServiceNamesImpl(
1742 : SAL_N_ELEMENTS(g_ServicesTextSection),
1743 0 : g_ServicesTextSection);
1744 : }
1745 :
1746 : // MetadatableMixin
1747 88 : ::sfx2::Metadatable* SwXTextSection::GetCoreObject()
1748 : {
1749 88 : SwSectionFormat *const pSectionFormat( m_pImpl->GetSectionFormat() );
1750 88 : return pSectionFormat;
1751 : }
1752 :
1753 0 : uno::Reference<frame::XModel> SwXTextSection::GetModel()
1754 : {
1755 0 : SwSectionFormat *const pSectionFormat( m_pImpl->GetSectionFormat() );
1756 0 : if (pSectionFormat)
1757 : {
1758 0 : SwDocShell const*const pShell( pSectionFormat->GetDoc()->GetDocShell() );
1759 0 : return (pShell) ? pShell->GetModel() : 0;
1760 : }
1761 0 : return 0;
1762 177 : }
1763 :
1764 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
