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