1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_sw.hxx"
26
27 #include <unobookmark.hxx>
28 #include <vos/mutex.hxx>
29 #include <vcl/svapp.hxx>
30
31 #include <TextCursorHelper.hxx>
32 #include <unotextrange.hxx>
33 #include <unomap.hxx>
34 #include <unoprnms.hxx>
35 #include <unoevtlstnr.hxx>
36 #include <IMark.hxx>
37 #include <crossrefbookmark.hxx>
38 #include <doc.hxx>
39 #include <IDocumentUndoRedo.hxx>
40 #include <docary.hxx>
41 #include <swundo.hxx>
42 #include <comcore.hrc>
43 #include <SwRewriter.hxx>
44 #include <docsh.hxx>
45
46
47 using namespace ::sw::mark;
48 using namespace ::com::sun::star;
49 using ::rtl::OUString;
50
51
52 namespace
53 {
lcl_QuoteName(const OUString & rName)54 static OUString lcl_QuoteName(const OUString& rName)
55 {
56 static const OUString sStart = OUString(String(SW_RES(STR_START_QUOTE)));
57 static const OUString sEnd = OUString(String(SW_RES(STR_END_QUOTE)));
58 ::rtl::OUStringBuffer sBuf(64);
59 return sBuf.append(sStart).append(rName).append(sEnd).makeStringAndClear();
60 }
61 }
62
63 /******************************************************************
64 * SwXBookmark
65 ******************************************************************/
66
67 class SwXBookmark::Impl
68 : public SwClient
69 {
70
71 public:
72 SwEventListenerContainer m_ListenerContainer;
73 SwDoc * m_pDoc;
74 ::sw::mark::IMark * m_pRegisteredBookmark;
75 ::rtl::OUString m_sMarkName;
76
77
Impl(SwXBookmark & rThis,SwDoc * const pDoc,::sw::mark::IMark * const)78 Impl( SwXBookmark & rThis,
79 SwDoc *const pDoc, ::sw::mark::IMark *const /*pBookmark*/)
80 : SwClient()
81 , m_ListenerContainer(static_cast< ::cppu::OWeakObject* >(&rThis))
82 , m_pDoc(pDoc)
83 , m_pRegisteredBookmark(0)
84 {
85 // DO NOT regiserInMark here! (because SetXBookmark would delete rThis)
86 }
87
88 void registerInMark(SwXBookmark & rThis, ::sw::mark::IMark *const pBkmk);
89 protected:
90 // SwClient
91 virtual void Modify( const SfxPoolItem *pOld, const SfxPoolItem *pNew);
92
93 };
94
Modify(const SfxPoolItem * pOld,const SfxPoolItem * pNew)95 void SwXBookmark::Impl::Modify(const SfxPoolItem *pOld, const SfxPoolItem *pNew)
96 {
97 ClientModify(this, pOld, pNew);
98 if (!GetRegisteredIn())
99 {
100 m_pRegisteredBookmark = NULL;
101 m_pDoc = NULL;
102 m_ListenerContainer.Disposing();
103 }
104 }
105
registerInMark(SwXBookmark & rThis,::sw::mark::IMark * const pBkmk)106 void SwXBookmark::Impl::registerInMark(
107 SwXBookmark & rThis,
108 ::sw::mark::IMark *const pBkmk)
109 {
110 if (pBkmk)
111 {
112 pBkmk->Add(this);
113 ::sw::mark::MarkBase *const pMarkBase(dynamic_cast< ::sw::mark::MarkBase * >(pBkmk));
114 OSL_ENSURE(pMarkBase, "registerInMark: no MarkBase?");
115 if (pMarkBase)
116 {
117 const uno::Reference<text::XTextContent> xBookmark(& rThis);
118 pMarkBase->SetXBookmark(xBookmark);
119 }
120 }
121 else if (m_pRegisteredBookmark)
122 {
123 m_sMarkName = m_pRegisteredBookmark->GetName();
124 m_pRegisteredBookmark->Remove(this);
125 }
126 m_pRegisteredBookmark = pBkmk;
127 }
128
129
GetBookmark() const130 const ::sw::mark::IMark* SwXBookmark::GetBookmark() const
131 {
132 return m_pImpl->m_pRegisteredBookmark;
133 }
134
SwXBookmark(::sw::mark::IMark * const pBkmk,SwDoc * const pDoc)135 SwXBookmark::SwXBookmark(
136 ::sw::mark::IMark *const pBkmk,
137 SwDoc *const pDoc)
138 : m_pImpl( new SwXBookmark::Impl(*this, pDoc, pBkmk) )
139 {
140 }
141
SwXBookmark()142 SwXBookmark::SwXBookmark()
143 : m_pImpl( new SwXBookmark::Impl(*this, 0, 0) )
144 {
145 }
146
~SwXBookmark()147 SwXBookmark::~SwXBookmark()
148 {
149 }
150
CreateXBookmark(SwDoc & rDoc,::sw::mark::IMark & rBookmark)151 uno::Reference<text::XTextContent> SwXBookmark::CreateXBookmark(
152 SwDoc & rDoc,
153 ::sw::mark::IMark & rBookmark)
154 {
155 // #i105557#: do not iterate over the registered clients: race condition
156 ::sw::mark::MarkBase *const pMarkBase(dynamic_cast< ::sw::mark::MarkBase * >(&rBookmark));
157 OSL_ENSURE(pMarkBase, "CreateXBookmark: no MarkBase?");
158 if (!pMarkBase) { return 0; }
159 uno::Reference<text::XTextContent> xBookmark(pMarkBase->GetXBookmark());
160 if (!xBookmark.is())
161 {
162 OSL_ENSURE(
163 dynamic_cast< ::sw::mark::IBookmark* >(&rBookmark) || IDocumentMarkAccess::GetType(rBookmark) == IDocumentMarkAccess::ANNOTATIONMARK,
164 "<SwXBookmark::GetObject(..)>"
165 "SwXBookmark requested for non-bookmark mark and non-annotation mark.");
166 SwXBookmark *const pXBookmark = new SwXBookmark(&rBookmark, &rDoc);
167 xBookmark.set(pXBookmark);
168 pXBookmark->registerInMark( pMarkBase);
169 }
170 return xBookmark;
171 }
172
173
registerInMark(::sw::mark::IMark * const pBkmk)174 void SwXBookmark::registerInMark( ::sw::mark::IMark *const pBkmk )
175 {
176 m_pImpl->registerInMark( *this, pBkmk );
177 }
178
GetBookmarkInDoc(SwDoc const * const pDoc,const uno::Reference<lang::XUnoTunnel> & xUT)179 ::sw::mark::IMark const* SwXBookmark::GetBookmarkInDoc(SwDoc const*const pDoc,
180 const uno::Reference< lang::XUnoTunnel> & xUT)
181 {
182 SwXBookmark *const pXBkm(
183 ::sw::UnoTunnelGetImplementation<SwXBookmark>(xUT));
184 if (pXBkm && (pDoc == pXBkm->m_pImpl->m_pDoc))
185 {
186 return pXBkm->m_pImpl->m_pRegisteredBookmark;
187 }
188 return 0;
189 }
190
getUnoTunnelId()191 const uno::Sequence< sal_Int8 > & SwXBookmark::getUnoTunnelId()
192 {
193 static uno::Sequence< sal_Int8 > aSeq = ::CreateUnoTunnelId();
194 return aSeq;
195 }
196
getSomething(const uno::Sequence<sal_Int8> & rId)197 sal_Int64 SAL_CALL SwXBookmark::getSomething( const uno::Sequence< sal_Int8 >& rId )
198 {
199 return ::sw::UnoTunnelImpl<SwXBookmark>(rId, this);
200 }
201
attachToRangeEx(const uno::Reference<text::XTextRange> & xTextRange,IDocumentMarkAccess::MarkType eType)202 void SwXBookmark::attachToRangeEx(
203 const uno::Reference< text::XTextRange > & xTextRange,
204 IDocumentMarkAccess::MarkType eType)
205 {
206 if (m_pImpl->m_pRegisteredBookmark)
207 {
208 throw uno::RuntimeException();
209 }
210
211 const uno::Reference<lang::XUnoTunnel> xRangeTunnel(
212 xTextRange, uno::UNO_QUERY);
213 SwXTextRange* pRange = 0;
214 OTextCursorHelper* pCursor = 0;
215 if(xRangeTunnel.is())
216 {
217 pRange = ::sw::UnoTunnelGetImplementation<SwXTextRange>(xRangeTunnel);
218 pCursor =
219 ::sw::UnoTunnelGetImplementation<OTextCursorHelper>(xRangeTunnel);
220 }
221
222 SwDoc *const pDoc =
223 (pRange) ? pRange->GetDoc() : ((pCursor) ? pCursor->GetDoc() : 0);
224 if (!pDoc)
225 {
226 throw lang::IllegalArgumentException();
227 }
228
229 m_pImpl->m_pDoc = pDoc;
230 SwUnoInternalPaM aPam(*m_pImpl->m_pDoc);
231 ::sw::XTextRangeToSwPaM(aPam, xTextRange);
232 UnoActionContext aCont(m_pImpl->m_pDoc);
233 if (!m_pImpl->m_sMarkName.getLength())
234 {
235 m_pImpl->m_sMarkName = OUString::createFromAscii("Bookmark");
236 }
237 if ((eType == IDocumentMarkAccess::BOOKMARK) &&
238 ::sw::mark::CrossRefNumItemBookmark::IsLegalName(m_pImpl->m_sMarkName))
239 {
240 eType = IDocumentMarkAccess::CROSSREF_NUMITEM_BOOKMARK;
241 }
242 else if ((eType == IDocumentMarkAccess::BOOKMARK) &&
243 ::sw::mark::CrossRefHeadingBookmark::IsLegalName(m_pImpl->m_sMarkName) &&
244 IDocumentMarkAccess::IsLegalPaMForCrossRefHeadingBookmark( aPam ) )
245 {
246 eType = IDocumentMarkAccess::CROSSREF_HEADING_BOOKMARK;
247 }
248 registerInMark( m_pImpl->m_pDoc->getIDocumentMarkAccess()->makeMark( aPam, m_pImpl->m_sMarkName, eType ) );
249 // Check, if bookmark has been created.
250 // E.g., the creation of a cross-reference bookmark is suppress,
251 // if the PaM isn't a valid one for cross-reference bookmarks.
252 if (!m_pImpl->m_pRegisteredBookmark)
253 {
254 OSL_ENSURE(false,
255 "<SwXBookmark::attachToRange(..)>"
256 " - could not create Mark.");
257 throw lang::IllegalArgumentException();
258 }
259 }
260
attachToRange(const uno::Reference<text::XTextRange> & xTextRange)261 void SwXBookmark::attachToRange( const uno::Reference< text::XTextRange > & xTextRange )
262 {
263 attachToRangeEx(xTextRange, IDocumentMarkAccess::BOOKMARK);
264 }
265
attach(const uno::Reference<text::XTextRange> & xTextRange)266 void SAL_CALL SwXBookmark::attach( const uno::Reference< text::XTextRange > & xTextRange )
267 {
268 vos::OGuard aGuard(Application::GetSolarMutex());
269 attachToRange( xTextRange );
270 }
271
getAnchor()272 uno::Reference< text::XTextRange > SAL_CALL SwXBookmark::getAnchor()
273 {
274 vos::OGuard aGuard(Application::GetSolarMutex());
275
276 if (!m_pImpl->m_pRegisteredBookmark)
277 {
278 throw uno::RuntimeException();
279 }
280 return SwXTextRange::CreateXTextRange(
281 *m_pImpl->m_pDoc,
282 m_pImpl->m_pRegisteredBookmark->GetMarkPos(),
283 (m_pImpl->m_pRegisteredBookmark->IsExpanded())
284 ? &m_pImpl->m_pRegisteredBookmark->GetOtherMarkPos() : NULL);
285 }
286
dispose()287 void SAL_CALL SwXBookmark::dispose()
288 {
289 vos::OGuard aGuard(Application::GetSolarMutex());
290 if (m_pImpl->m_pRegisteredBookmark)
291 {
292 m_pImpl->m_pDoc->getIDocumentMarkAccess()->deleteMark( m_pImpl->m_pRegisteredBookmark );
293 }
294 }
295
addEventListener(const uno::Reference<lang::XEventListener> & xListener)296 void SAL_CALL SwXBookmark::addEventListener(
297 const uno::Reference< lang::XEventListener > & xListener)
298 {
299 vos::OGuard g(Application::GetSolarMutex());
300
301 if (!m_pImpl->m_pRegisteredBookmark)
302 {
303 throw uno::RuntimeException();
304 }
305 m_pImpl->m_ListenerContainer.AddListener(xListener);
306 }
307
removeEventListener(const uno::Reference<lang::XEventListener> & xListener)308 void SAL_CALL SwXBookmark::removeEventListener(
309 const uno::Reference< lang::XEventListener > & xListener)
310 {
311 vos::OGuard g(Application::GetSolarMutex());
312
313 if (!m_pImpl->m_pRegisteredBookmark ||
314 !m_pImpl->m_ListenerContainer.RemoveListener(xListener))
315 {
316 throw uno::RuntimeException();
317 }
318 }
319
getName()320 OUString SAL_CALL SwXBookmark::getName()
321 {
322 vos::OGuard aGuard(Application::GetSolarMutex());
323
324 return (m_pImpl->m_pRegisteredBookmark)
325 ? m_pImpl->m_pRegisteredBookmark->GetName()
326 : m_pImpl->m_sMarkName;
327 }
328
setName(const OUString & rName)329 void SAL_CALL SwXBookmark::setName(const OUString& rName)
330 {
331 vos::OGuard aGuard(Application::GetSolarMutex());
332
333 if (!m_pImpl->m_pRegisteredBookmark)
334 {
335 m_pImpl->m_sMarkName = rName;
336 }
337 if (!m_pImpl->m_pRegisteredBookmark || (getName() == rName))
338 {
339 return;
340 }
341 IDocumentMarkAccess *const pMarkAccess =
342 m_pImpl->m_pDoc->getIDocumentMarkAccess();
343 if(pMarkAccess->findMark(rName) != pMarkAccess->getAllMarksEnd())
344 {
345 throw uno::RuntimeException();
346 }
347
348 SwPaM aPam(m_pImpl->m_pRegisteredBookmark->GetMarkPos());
349 if (m_pImpl->m_pRegisteredBookmark->IsExpanded())
350 {
351 aPam.SetMark();
352 *aPam.GetMark() = m_pImpl->m_pRegisteredBookmark->GetOtherMarkPos();
353 }
354
355 SwRewriter aRewriter;
356 aRewriter.AddRule(UNDO_ARG1, lcl_QuoteName(getName()));
357 aRewriter.AddRule(UNDO_ARG2, SW_RES(STR_YIELDS));
358 aRewriter.AddRule(UNDO_ARG3, lcl_QuoteName(rName));
359
360 m_pImpl->m_pDoc->GetIDocumentUndoRedo().StartUndo(
361 UNDO_BOOKMARK_RENAME, &aRewriter);
362 pMarkAccess->renameMark(m_pImpl->m_pRegisteredBookmark, rName);
363 m_pImpl->m_pDoc->GetIDocumentUndoRedo().EndUndo(
364 UNDO_BOOKMARK_RENAME, &aRewriter);
365 }
366
367 OUString SAL_CALL
getImplementationName()368 SwXBookmark::getImplementationName()
369 {
370 return OUString::createFromAscii("SwXBookmark");
371 }
372
373 static char const*const g_ServicesBookmark[] =
374 {
375 "com.sun.star.text.TextContent",
376 "com.sun.star.text.Bookmark",
377 "com.sun.star.document.LinkTarget",
378 };
379 static const size_t g_nServicesBookmark(
380 sizeof(g_ServicesBookmark)/sizeof(g_ServicesBookmark[0]));
381
supportsService(const OUString & rServiceName)382 sal_Bool SAL_CALL SwXBookmark::supportsService(const OUString& rServiceName)
383 {
384 return ::sw::SupportsServiceImpl(
385 g_nServicesBookmark, g_ServicesBookmark, rServiceName);
386 }
387
388 uno::Sequence< OUString > SAL_CALL
getSupportedServiceNames()389 SwXBookmark::getSupportedServiceNames()
390 {
391 return ::sw::GetSupportedServiceNamesImpl(
392 g_nServicesBookmark, g_ServicesBookmark);
393 }
394
395 // MetadatableMixin
GetCoreObject()396 ::sfx2::Metadatable* SwXBookmark::GetCoreObject()
397 {
398 return dynamic_cast< ::sfx2::Metadatable* >(m_pImpl->m_pRegisteredBookmark);
399 }
400
GetModel()401 uno::Reference<frame::XModel> SwXBookmark::GetModel()
402 {
403 if (m_pImpl->m_pDoc)
404 {
405 SwDocShell const * const pShell( m_pImpl->m_pDoc->GetDocShell() );
406 return (pShell) ? pShell->GetModel() : 0;
407 }
408 return 0;
409 }
410
411
412 uno::Reference< beans::XPropertySetInfo > SAL_CALL
getPropertySetInfo()413 SwXBookmark::getPropertySetInfo()
414 {
415 vos::OGuard g(Application::GetSolarMutex());
416
417 static uno::Reference< beans::XPropertySetInfo > xRef(
418 aSwMapProvider.GetPropertySet(PROPERTY_MAP_BOOKMARK)
419 ->getPropertySetInfo() );
420 return xRef;
421 }
422
423 void SAL_CALL
setPropertyValue(const OUString & PropertyName,const uno::Any &)424 SwXBookmark::setPropertyValue(const OUString& PropertyName,
425 const uno::Any& /*rValue*/)
426 {
427 // nothing to set here
428 throw lang::IllegalArgumentException( ::rtl::OUString(
429 RTL_CONSTASCII_USTRINGPARAM("Property is read-only: "))
430 + PropertyName, static_cast< cppu::OWeakObject * >(this), 0 );
431 }
432
getPropertyValue(const OUString & rPropertyName)433 uno::Any SAL_CALL SwXBookmark::getPropertyValue(const OUString& rPropertyName)
434 {
435 vos::OGuard g(Application::GetSolarMutex());
436
437 uno::Any aRet;
438 if (! ::sw::GetDefaultTextContentValue(aRet, rPropertyName))
439 {
440 if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_LINK_DISPLAY_NAME)))
441 {
442 aRet <<= getName();
443 }
444 }
445 return aRet;
446 }
447
448 void SAL_CALL
addPropertyChangeListener(const::rtl::OUString &,const uno::Reference<beans::XPropertyChangeListener> &)449 SwXBookmark::addPropertyChangeListener(
450 const ::rtl::OUString& /*rPropertyName*/,
451 const uno::Reference< beans::XPropertyChangeListener >& /*xListener*/)
452 {
453 OSL_ENSURE(false,
454 "SwXBookmark::addPropertyChangeListener(): not implemented");
455 }
456
457 void SAL_CALL
removePropertyChangeListener(const::rtl::OUString &,const uno::Reference<beans::XPropertyChangeListener> &)458 SwXBookmark::removePropertyChangeListener(
459 const ::rtl::OUString& /*rPropertyName*/,
460 const uno::Reference< beans::XPropertyChangeListener >& /*xListener*/)
461 {
462 OSL_ENSURE(false,
463 "SwXBookmark::removePropertyChangeListener(): not implemented");
464 }
465
466 void SAL_CALL
addVetoableChangeListener(const::rtl::OUString &,const uno::Reference<beans::XVetoableChangeListener> &)467 SwXBookmark::addVetoableChangeListener(
468 const ::rtl::OUString& /*rPropertyName*/,
469 const uno::Reference< beans::XVetoableChangeListener >& /*xListener*/)
470 {
471 OSL_ENSURE(false,
472 "SwXBookmark::addVetoableChangeListener(): not implemented");
473 }
474
475 void SAL_CALL
removeVetoableChangeListener(const::rtl::OUString &,const uno::Reference<beans::XVetoableChangeListener> &)476 SwXBookmark::removeVetoableChangeListener(
477 const ::rtl::OUString& /*rPropertyName*/,
478 const uno::Reference< beans::XVetoableChangeListener >& /*xListener*/)
479 {
480 OSL_ENSURE(false,
481 "SwXBookmark::removeVetoableChangeListener(): not implemented");
482 }
483
484 /******************************************************************
485 * SwXFieldmark
486 ******************************************************************/
487
SwXFieldmark(bool _isReplacementObject)488 SwXFieldmark::SwXFieldmark( bool _isReplacementObject )
489 : SwXFieldmark_Base()
490 , isReplacementObject(_isReplacementObject)
491 {
492 }
493
494
SwXFieldmark(bool _isReplacementObject,::sw::mark::IMark * const pMark,SwDoc * const pDoc)495 SwXFieldmark::SwXFieldmark(
496 bool _isReplacementObject,
497 ::sw::mark::IMark *const pMark,
498 SwDoc *const pDoc )
499 : SwXFieldmark_Base( pMark, pDoc )
500 , isReplacementObject( _isReplacementObject )
501 {
502 }
503
504
CreateXFieldmark(SwDoc & rDoc,::sw::mark::IMark & rBookmark)505 uno::Reference<text::XTextContent> SwXFieldmark::CreateXFieldmark(
506 SwDoc & rDoc,
507 ::sw::mark::IMark & rBookmark )
508 {
509 // do not iterate over the registered clients: race condition
510 ::sw::mark::MarkBase *const pMarkBase( dynamic_cast< ::sw::mark::MarkBase * >(&rBookmark));
511 OSL_ENSURE(pMarkBase, "CreateXFieldmark: no MarkBase?");
512 if (!pMarkBase) { return 0; }
513
514 uno::Reference<text::XTextContent> xBookmark(pMarkBase->GetXBookmark());
515 if (!xBookmark.is())
516 {
517 SwXFieldmark* pXFieldmark = NULL;
518 if ( dynamic_cast< ::sw::mark::TextFieldmark* >(&rBookmark) )
519 {
520 pXFieldmark = new SwXFieldmark( false, &rBookmark, &rDoc );
521 }
522 else if ( dynamic_cast< ::sw::mark::CheckboxFieldmark* >(&rBookmark) )
523 {
524 pXFieldmark = new SwXFieldmark( true, &rBookmark, &rDoc );
525 }
526 if ( pXFieldmark != NULL )
527 {
528 xBookmark.set( pXFieldmark );
529 pXFieldmark->registerInMark( pMarkBase );
530 }
531 }
532 return xBookmark;
533 }
534
535
insertByName(const OUString & aName,const uno::Any & aElement)536 void SwXFieldmarkParameters::insertByName(const OUString& aName, const uno::Any& aElement)
537 {
538 vos::OGuard aGuard(Application::GetSolarMutex());
539 IFieldmark::parameter_map_t* pParameters = getCoreParameters();
540 if(pParameters->find(aName) != pParameters->end())
541 throw container::ElementExistException();
542 (*pParameters)[aName] = aElement;
543 }
544
removeByName(const OUString & aName)545 void SwXFieldmarkParameters::removeByName(const OUString& aName)
546 {
547 vos::OGuard aGuard(Application::GetSolarMutex());
548 if(!getCoreParameters()->erase(aName))
549 throw container::NoSuchElementException();
550 }
551
replaceByName(const OUString & aName,const uno::Any & aElement)552 void SwXFieldmarkParameters::replaceByName(const OUString& aName, const uno::Any& aElement)
553 {
554 vos::OGuard aGuard(Application::GetSolarMutex());
555 IFieldmark::parameter_map_t* pParameters = getCoreParameters();
556 IFieldmark::parameter_map_t::iterator pEntry = pParameters->find(aName);
557 if(pEntry == pParameters->end())
558 throw container::NoSuchElementException();
559 pEntry->second = aElement;
560 }
561
getByName(const OUString & aName)562 uno::Any SwXFieldmarkParameters::getByName(const OUString& aName)
563 {
564 vos::OGuard aGuard(Application::GetSolarMutex());
565 IFieldmark::parameter_map_t* pParameters = getCoreParameters();
566 IFieldmark::parameter_map_t::iterator pEntry = pParameters->find(aName);
567 if(pEntry == pParameters->end())
568 throw container::NoSuchElementException();
569 return pEntry->second;
570 }
571
getElementNames()572 uno::Sequence<OUString> SwXFieldmarkParameters::getElementNames()
573 {
574 vos::OGuard aGuard(Application::GetSolarMutex());
575 IFieldmark::parameter_map_t* pParameters = getCoreParameters();
576 uno::Sequence<OUString> vResult(pParameters->size());
577 OUString* pOutEntry = vResult.getArray();
578 for(IFieldmark::parameter_map_t::iterator pEntry = pParameters->begin(); pEntry!=pParameters->end(); ++pEntry, ++pOutEntry)
579 *pOutEntry = pEntry->first;
580 return vResult;
581 }
582
hasByName(const OUString & aName)583 ::sal_Bool SwXFieldmarkParameters::hasByName(const OUString& aName)
584 {
585 vos::OGuard aGuard(Application::GetSolarMutex());
586 IFieldmark::parameter_map_t* pParameters = getCoreParameters();
587 return (pParameters->find(aName) != pParameters->end());
588 }
589
getElementType()590 uno::Type SwXFieldmarkParameters::getElementType()
591 {
592 return ::cppu::UnoType< ::cppu::UnoVoidType>::get();
593 }
594
hasElements()595 ::sal_Bool SwXFieldmarkParameters::hasElements()
596 {
597 vos::OGuard aGuard(Application::GetSolarMutex());
598 return !getCoreParameters()->empty();
599 }
600
Modify(const SfxPoolItem * pOld,const SfxPoolItem * pNew)601 void SwXFieldmarkParameters::Modify(const SfxPoolItem *pOld, const SfxPoolItem *pNew)
602 {
603 ClientModify(this, pOld, pNew);
604 }
605
606
getCoreParameters()607 IFieldmark::parameter_map_t* SwXFieldmarkParameters::getCoreParameters()
608 {
609 const IFieldmark* pFieldmark = dynamic_cast< const IFieldmark* >(GetRegisteredIn());
610 if(!pFieldmark)
611 throw uno::RuntimeException();
612 return const_cast< IFieldmark* >(pFieldmark)->GetParameters();
613 }
614
615
attachToRange(const uno::Reference<text::XTextRange> & xTextRange)616 void SwXFieldmark::attachToRange( const uno::Reference < text::XTextRange >& xTextRange )
617 {
618 attachToRangeEx( xTextRange,
619 ( isReplacementObject ? IDocumentMarkAccess::CHECKBOX_FIELDMARK : IDocumentMarkAccess::TEXT_FIELDMARK ) );
620 }
621
getFieldType(void)622 ::rtl::OUString SwXFieldmark::getFieldType(void)
623 {
624 vos::OGuard aGuard(Application::GetSolarMutex());
625 const IFieldmark *pBkm = dynamic_cast<const IFieldmark*>(GetBookmark());
626 if(!pBkm)
627 throw uno::RuntimeException();
628 return pBkm->GetFieldname();
629 }
630
setFieldType(const::rtl::OUString & fieldType)631 void SwXFieldmark::setFieldType(const::rtl::OUString & fieldType)
632 {
633 vos::OGuard aGuard(Application::GetSolarMutex());
634 IFieldmark *pBkm = const_cast<IFieldmark*>(
635 dynamic_cast<const IFieldmark*>(GetBookmark()));
636 if(!pBkm)
637 throw uno::RuntimeException();
638 pBkm->SetFieldname(fieldType);
639 }
640
getParameters()641 uno::Reference<container::XNameContainer> SwXFieldmark::getParameters()
642 {
643 vos::OGuard aGuard(Application::GetSolarMutex());
644 IFieldmark *pBkm = const_cast<IFieldmark*>(
645 dynamic_cast<const IFieldmark*>(GetBookmark()));
646 if(!pBkm)
647 throw uno::RuntimeException();
648 return uno::Reference<container::XNameContainer>(new SwXFieldmarkParameters(pBkm));
649 }
650