xref: /AOO41X/main/sw/source/core/unocore/unobkm.cxx (revision 772b8e0b82570e4556f647a63961304db1bf493b) 
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 {
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 
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 
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 
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 
130 const ::sw::mark::IMark* SwXBookmark::GetBookmark() const
131 {
132     return m_pImpl->m_pRegisteredBookmark;
133 }
134 
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 
142 SwXBookmark::SwXBookmark()
143     : m_pImpl( new SwXBookmark::Impl(*this, 0, 0) )
144 {
145 }
146 
147 SwXBookmark::~SwXBookmark()
148 {
149 }
150 
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 
174 void SwXBookmark::registerInMark( ::sw::mark::IMark *const pBkmk )
175 {
176     m_pImpl->registerInMark( *this, pBkmk );
177 }
178 
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 
191 const uno::Sequence< sal_Int8 > & SwXBookmark::getUnoTunnelId()
192 {
193     static uno::Sequence< sal_Int8 > aSeq = ::CreateUnoTunnelId();
194     return aSeq;
195 }
196 
197 sal_Int64 SAL_CALL SwXBookmark::getSomething( const uno::Sequence< sal_Int8 >& rId )
198 throw (uno::RuntimeException)
199 {
200     return ::sw::UnoTunnelImpl<SwXBookmark>(rId, this);
201 }
202 
203 void SwXBookmark::attachToRangeEx(
204     const uno::Reference< text::XTextRange > & xTextRange,
205     IDocumentMarkAccess::MarkType eType)
206 throw (lang::IllegalArgumentException, uno::RuntimeException)
207 {
208     if (m_pImpl->m_pRegisteredBookmark)
209     {
210         throw uno::RuntimeException();
211     }
212 
213     const uno::Reference<lang::XUnoTunnel> xRangeTunnel(
214             xTextRange, uno::UNO_QUERY);
215     SwXTextRange* pRange = 0;
216     OTextCursorHelper* pCursor = 0;
217     if(xRangeTunnel.is())
218     {
219         pRange = ::sw::UnoTunnelGetImplementation<SwXTextRange>(xRangeTunnel);
220         pCursor =
221             ::sw::UnoTunnelGetImplementation<OTextCursorHelper>(xRangeTunnel);
222     }
223 
224     SwDoc *const pDoc =
225         (pRange) ? pRange->GetDoc() : ((pCursor) ? pCursor->GetDoc() : 0);
226     if (!pDoc)
227     {
228         throw lang::IllegalArgumentException();
229     }
230 
231     m_pImpl->m_pDoc = pDoc;
232     SwUnoInternalPaM aPam(*m_pImpl->m_pDoc);
233     ::sw::XTextRangeToSwPaM(aPam, xTextRange);
234     UnoActionContext aCont(m_pImpl->m_pDoc);
235     if (!m_pImpl->m_sMarkName.getLength())
236     {
237          m_pImpl->m_sMarkName =  OUString::createFromAscii("Bookmark");
238     }
239     if ((eType == IDocumentMarkAccess::BOOKMARK) &&
240         ::sw::mark::CrossRefNumItemBookmark::IsLegalName(m_pImpl->m_sMarkName))
241     {
242         eType = IDocumentMarkAccess::CROSSREF_NUMITEM_BOOKMARK;
243     }
244     else if ((eType == IDocumentMarkAccess::BOOKMARK) &&
245         ::sw::mark::CrossRefHeadingBookmark::IsLegalName(m_pImpl->m_sMarkName) &&
246         IDocumentMarkAccess::IsLegalPaMForCrossRefHeadingBookmark( aPam ) )
247     {
248         eType = IDocumentMarkAccess::CROSSREF_HEADING_BOOKMARK;
249     }
250     registerInMark( m_pImpl->m_pDoc->getIDocumentMarkAccess()->makeMark( aPam, m_pImpl->m_sMarkName, eType ) );
251     // Check, if bookmark has been created.
252     // E.g., the creation of a cross-reference bookmark is suppress,
253     // if the PaM isn't a valid one for cross-reference bookmarks.
254     if (!m_pImpl->m_pRegisteredBookmark)
255     {
256         OSL_ENSURE(false,
257             "<SwXBookmark::attachToRange(..)>"
258             " - could not create Mark.");
259         throw lang::IllegalArgumentException();
260     }
261 }
262 
263 void SwXBookmark::attachToRange( const uno::Reference< text::XTextRange > & xTextRange )
264 throw (lang::IllegalArgumentException, uno::RuntimeException)
265 {
266     attachToRangeEx(xTextRange, IDocumentMarkAccess::BOOKMARK);
267 }
268 
269 void SAL_CALL SwXBookmark::attach( const uno::Reference< text::XTextRange > & xTextRange )
270 throw (lang::IllegalArgumentException, uno::RuntimeException)
271 {
272     vos::OGuard aGuard(Application::GetSolarMutex());
273     attachToRange( xTextRange );
274 }
275 
276 uno::Reference< text::XTextRange > SAL_CALL SwXBookmark::getAnchor()
277 throw (uno::RuntimeException)
278 {
279     vos::OGuard aGuard(Application::GetSolarMutex());
280 
281     if (!m_pImpl->m_pRegisteredBookmark)
282     {
283         throw uno::RuntimeException();
284     }
285     return SwXTextRange::CreateXTextRange(
286             *m_pImpl->m_pDoc,
287             m_pImpl->m_pRegisteredBookmark->GetMarkPos(),
288             (m_pImpl->m_pRegisteredBookmark->IsExpanded())
289                 ? &m_pImpl->m_pRegisteredBookmark->GetOtherMarkPos() : NULL);
290 }
291 
292 void SAL_CALL SwXBookmark::dispose()
293 throw (uno::RuntimeException)
294 {
295     vos::OGuard aGuard(Application::GetSolarMutex());
296     if (m_pImpl->m_pRegisteredBookmark)
297     {
298         m_pImpl->m_pDoc->getIDocumentMarkAccess()->deleteMark( m_pImpl->m_pRegisteredBookmark );
299     }
300 }
301 
302 void SAL_CALL SwXBookmark::addEventListener(
303         const uno::Reference< lang::XEventListener > & xListener)
304 throw (uno::RuntimeException)
305 {
306     vos::OGuard g(Application::GetSolarMutex());
307 
308     if (!m_pImpl->m_pRegisteredBookmark)
309     {
310         throw uno::RuntimeException();
311     }
312     m_pImpl->m_ListenerContainer.AddListener(xListener);
313 }
314 
315 void SAL_CALL SwXBookmark::removeEventListener(
316         const uno::Reference< lang::XEventListener > & xListener)
317 throw (uno::RuntimeException)
318 {
319     vos::OGuard g(Application::GetSolarMutex());
320 
321     if (!m_pImpl->m_pRegisteredBookmark ||
322         !m_pImpl->m_ListenerContainer.RemoveListener(xListener))
323     {
324         throw uno::RuntimeException();
325     }
326 }
327 
328 OUString SAL_CALL SwXBookmark::getName()
329 throw (uno::RuntimeException)
330 {
331     vos::OGuard aGuard(Application::GetSolarMutex());
332 
333     return (m_pImpl->m_pRegisteredBookmark)
334         ?   m_pImpl->m_pRegisteredBookmark->GetName()
335         :   m_pImpl->m_sMarkName;
336 }
337 
338 void SAL_CALL SwXBookmark::setName(const OUString& rName)
339 throw (uno::RuntimeException)
340 {
341     vos::OGuard aGuard(Application::GetSolarMutex());
342 
343     if (!m_pImpl->m_pRegisteredBookmark)
344     {
345         m_pImpl->m_sMarkName = rName;
346     }
347     if (!m_pImpl->m_pRegisteredBookmark || (getName() == rName))
348     {
349         return;
350     }
351     IDocumentMarkAccess *const pMarkAccess =
352         m_pImpl->m_pDoc->getIDocumentMarkAccess();
353     if(pMarkAccess->findMark(rName) != pMarkAccess->getAllMarksEnd())
354     {
355         throw uno::RuntimeException();
356     }
357 
358     SwPaM aPam(m_pImpl->m_pRegisteredBookmark->GetMarkPos());
359     if (m_pImpl->m_pRegisteredBookmark->IsExpanded())
360     {
361         aPam.SetMark();
362         *aPam.GetMark() = m_pImpl->m_pRegisteredBookmark->GetOtherMarkPos();
363     }
364 
365     SwRewriter aRewriter;
366     aRewriter.AddRule(UNDO_ARG1, lcl_QuoteName(getName()));
367     aRewriter.AddRule(UNDO_ARG2, SW_RES(STR_YIELDS));
368     aRewriter.AddRule(UNDO_ARG3, lcl_QuoteName(rName));
369 
370     m_pImpl->m_pDoc->GetIDocumentUndoRedo().StartUndo(
371             UNDO_BOOKMARK_RENAME, &aRewriter);
372     pMarkAccess->renameMark(m_pImpl->m_pRegisteredBookmark, rName);
373     m_pImpl->m_pDoc->GetIDocumentUndoRedo().EndUndo(
374             UNDO_BOOKMARK_RENAME, &aRewriter);
375 }
376 
377 OUString SAL_CALL
378 SwXBookmark::getImplementationName() throw (uno::RuntimeException)
379 {
380     return OUString::createFromAscii("SwXBookmark");
381 }
382 
383 static char const*const g_ServicesBookmark[] =
384 {
385     "com.sun.star.text.TextContent",
386     "com.sun.star.text.Bookmark",
387     "com.sun.star.document.LinkTarget",
388 };
389 static const size_t g_nServicesBookmark(
390     sizeof(g_ServicesBookmark)/sizeof(g_ServicesBookmark[0]));
391 
392 sal_Bool SAL_CALL SwXBookmark::supportsService(const OUString& rServiceName)
393 throw (uno::RuntimeException)
394 {
395     return ::sw::SupportsServiceImpl(
396             g_nServicesBookmark, g_ServicesBookmark, rServiceName);
397 }
398 
399 uno::Sequence< OUString > SAL_CALL
400 SwXBookmark::getSupportedServiceNames() throw (uno::RuntimeException)
401 {
402     return ::sw::GetSupportedServiceNamesImpl(
403             g_nServicesBookmark, g_ServicesBookmark);
404 }
405 
406 // MetadatableMixin
407 ::sfx2::Metadatable* SwXBookmark::GetCoreObject()
408 {
409     return dynamic_cast< ::sfx2::Metadatable* >(m_pImpl->m_pRegisteredBookmark);
410 }
411 
412 uno::Reference<frame::XModel> SwXBookmark::GetModel()
413 {
414     if (m_pImpl->m_pDoc)
415     {
416         SwDocShell const * const pShell( m_pImpl->m_pDoc->GetDocShell() );
417         return (pShell) ? pShell->GetModel() : 0;
418     }
419     return 0;
420 }
421 
422 
423 uno::Reference< beans::XPropertySetInfo > SAL_CALL
424 SwXBookmark::getPropertySetInfo() throw (uno::RuntimeException)
425 {
426     vos::OGuard g(Application::GetSolarMutex());
427 
428     static uno::Reference< beans::XPropertySetInfo > xRef(
429         aSwMapProvider.GetPropertySet(PROPERTY_MAP_BOOKMARK)
430             ->getPropertySetInfo() );
431     return xRef;
432 }
433 
434 void SAL_CALL
435 SwXBookmark::setPropertyValue(const OUString& PropertyName,
436         const uno::Any& /*rValue*/)
437 throw (beans::UnknownPropertyException, beans::PropertyVetoException,
438     lang::IllegalArgumentException, lang::WrappedTargetException,
439     uno::RuntimeException)
440 {
441     // nothing to set here
442     throw lang::IllegalArgumentException( ::rtl::OUString(
443             RTL_CONSTASCII_USTRINGPARAM("Property is read-only: "))
444             + PropertyName, static_cast< cppu::OWeakObject * >(this), 0 );
445 }
446 
447 uno::Any SAL_CALL SwXBookmark::getPropertyValue(const OUString& rPropertyName)
448 throw (beans::UnknownPropertyException, lang::WrappedTargetException,
449         uno::RuntimeException)
450 {
451     vos::OGuard g(Application::GetSolarMutex());
452 
453     uno::Any aRet;
454     if (! ::sw::GetDefaultTextContentValue(aRet, rPropertyName))
455     {
456         if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_LINK_DISPLAY_NAME)))
457         {
458             aRet <<= getName();
459         }
460     }
461     return aRet;
462 }
463 
464 void SAL_CALL
465 SwXBookmark::addPropertyChangeListener(
466         const ::rtl::OUString& /*rPropertyName*/,
467         const uno::Reference< beans::XPropertyChangeListener >& /*xListener*/)
468 throw (beans::UnknownPropertyException, lang::WrappedTargetException,
469     uno::RuntimeException)
470 {
471     OSL_ENSURE(false,
472         "SwXBookmark::addPropertyChangeListener(): not implemented");
473 }
474 
475 void SAL_CALL
476 SwXBookmark::removePropertyChangeListener(
477         const ::rtl::OUString& /*rPropertyName*/,
478         const uno::Reference< beans::XPropertyChangeListener >& /*xListener*/)
479 throw (beans::UnknownPropertyException, lang::WrappedTargetException,
480     uno::RuntimeException)
481 {
482     OSL_ENSURE(false,
483         "SwXBookmark::removePropertyChangeListener(): not implemented");
484 }
485 
486 void SAL_CALL
487 SwXBookmark::addVetoableChangeListener(
488         const ::rtl::OUString& /*rPropertyName*/,
489         const uno::Reference< beans::XVetoableChangeListener >& /*xListener*/)
490 throw (beans::UnknownPropertyException, lang::WrappedTargetException,
491     uno::RuntimeException)
492 {
493     OSL_ENSURE(false,
494         "SwXBookmark::addVetoableChangeListener(): not implemented");
495 }
496 
497 void SAL_CALL
498 SwXBookmark::removeVetoableChangeListener(
499         const ::rtl::OUString& /*rPropertyName*/,
500         const uno::Reference< beans::XVetoableChangeListener >& /*xListener*/)
501 throw (beans::UnknownPropertyException, lang::WrappedTargetException,
502         uno::RuntimeException)
503 {
504     OSL_ENSURE(false,
505         "SwXBookmark::removeVetoableChangeListener(): not implemented");
506 }
507 
508 /******************************************************************
509  * SwXFieldmark
510  ******************************************************************/
511 
512 SwXFieldmark::SwXFieldmark( bool _isReplacementObject )
513     : SwXFieldmark_Base()
514     , isReplacementObject(_isReplacementObject)
515 {
516 }
517 
518 
519 SwXFieldmark::SwXFieldmark(
520     bool _isReplacementObject,
521     ::sw::mark::IMark *const pMark,
522     SwDoc *const pDoc )
523     : SwXFieldmark_Base( pMark, pDoc )
524     , isReplacementObject( _isReplacementObject )
525 {
526 }
527 
528 
529 uno::Reference<text::XTextContent> SwXFieldmark::CreateXFieldmark(
530     SwDoc & rDoc,
531     ::sw::mark::IMark & rBookmark )
532 {
533     // do not iterate over the registered clients: race condition
534     ::sw::mark::MarkBase *const pMarkBase( dynamic_cast< ::sw::mark::MarkBase * >(&rBookmark));
535     OSL_ENSURE(pMarkBase, "CreateXFieldmark: no MarkBase?");
536     if (!pMarkBase) { return 0; }
537 
538     uno::Reference<text::XTextContent> xBookmark(pMarkBase->GetXBookmark());
539     if (!xBookmark.is())
540     {
541         SwXFieldmark* pXFieldmark = NULL;
542         if ( dynamic_cast< ::sw::mark::TextFieldmark* >(&rBookmark) )
543         {
544             pXFieldmark = new SwXFieldmark( false, &rBookmark, &rDoc );
545         }
546         else if ( dynamic_cast< ::sw::mark::CheckboxFieldmark* >(&rBookmark) )
547         {
548             pXFieldmark = new SwXFieldmark( true, &rBookmark, &rDoc );
549         }
550         if ( pXFieldmark != NULL )
551         {
552             xBookmark.set( pXFieldmark );
553             pXFieldmark->registerInMark( pMarkBase );
554         }
555     }
556     return xBookmark;
557 }
558 
559 
560 void SwXFieldmarkParameters::insertByName(const OUString& aName, const uno::Any& aElement)
561     throw (lang::IllegalArgumentException, container::ElementExistException, lang::WrappedTargetException, uno::RuntimeException)
562 {
563     vos::OGuard aGuard(Application::GetSolarMutex());
564     IFieldmark::parameter_map_t* pParameters = getCoreParameters();
565     if(pParameters->find(aName) != pParameters->end())
566         throw container::ElementExistException();
567     (*pParameters)[aName] = aElement;
568 }
569 
570 void SwXFieldmarkParameters::removeByName(const OUString& aName)
571     throw (container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException)
572 {
573     vos::OGuard aGuard(Application::GetSolarMutex());
574     if(!getCoreParameters()->erase(aName))
575         throw container::NoSuchElementException();
576 }
577 
578 void SwXFieldmarkParameters::replaceByName(const OUString& aName, const uno::Any& aElement)
579     throw (lang::IllegalArgumentException, container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException)
580 {
581     vos::OGuard aGuard(Application::GetSolarMutex());
582     IFieldmark::parameter_map_t* pParameters = getCoreParameters();
583     IFieldmark::parameter_map_t::iterator pEntry = pParameters->find(aName);
584     if(pEntry == pParameters->end())
585         throw container::NoSuchElementException();
586     pEntry->second = aElement;
587 }
588 
589 uno::Any SwXFieldmarkParameters::getByName(const OUString& aName)
590     throw (container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException)
591 {
592     vos::OGuard aGuard(Application::GetSolarMutex());
593     IFieldmark::parameter_map_t* pParameters = getCoreParameters();
594     IFieldmark::parameter_map_t::iterator pEntry = pParameters->find(aName);
595     if(pEntry == pParameters->end())
596         throw container::NoSuchElementException();
597     return pEntry->second;
598 }
599 
600 uno::Sequence<OUString> SwXFieldmarkParameters::getElementNames()
601     throw (uno::RuntimeException)
602 {
603     vos::OGuard aGuard(Application::GetSolarMutex());
604     IFieldmark::parameter_map_t* pParameters = getCoreParameters();
605     uno::Sequence<OUString> vResult(pParameters->size());
606     OUString* pOutEntry = vResult.getArray();
607     for(IFieldmark::parameter_map_t::iterator pEntry = pParameters->begin(); pEntry!=pParameters->end(); ++pEntry, ++pOutEntry)
608         *pOutEntry = pEntry->first;
609     return vResult;
610 }
611 
612 ::sal_Bool SwXFieldmarkParameters::hasByName(const OUString& aName)
613     throw (uno::RuntimeException)
614 {
615     vos::OGuard aGuard(Application::GetSolarMutex());
616     IFieldmark::parameter_map_t* pParameters = getCoreParameters();
617     return (pParameters->find(aName) != pParameters->end());
618 }
619 
620 uno::Type SwXFieldmarkParameters::getElementType()
621     throw (uno::RuntimeException)
622 {
623     return ::cppu::UnoType< ::cppu::UnoVoidType>::get();
624 }
625 
626 ::sal_Bool SwXFieldmarkParameters::hasElements()
627     throw (uno::RuntimeException)
628 {
629     vos::OGuard aGuard(Application::GetSolarMutex());
630     return !getCoreParameters()->empty();
631 }
632 
633 void SwXFieldmarkParameters::Modify(const SfxPoolItem *pOld, const SfxPoolItem *pNew)
634 {
635     ClientModify(this, pOld, pNew);
636 }
637 
638 
639 IFieldmark::parameter_map_t* SwXFieldmarkParameters::getCoreParameters()
640     throw (uno::RuntimeException)
641 {
642     const IFieldmark* pFieldmark = dynamic_cast< const IFieldmark* >(GetRegisteredIn());
643     if(!pFieldmark)
644         throw uno::RuntimeException();
645     return const_cast< IFieldmark* >(pFieldmark)->GetParameters();
646 }
647 
648 
649 void SwXFieldmark::attachToRange( const uno::Reference < text::XTextRange >& xTextRange )
650     throw(lang::IllegalArgumentException, uno::RuntimeException)
651 {
652     attachToRangeEx( xTextRange,
653                      ( isReplacementObject ? IDocumentMarkAccess::CHECKBOX_FIELDMARK : IDocumentMarkAccess::TEXT_FIELDMARK ) );
654 }
655 
656 ::rtl::OUString SwXFieldmark::getFieldType(void)
657     throw(uno::RuntimeException)
658 {
659     vos::OGuard aGuard(Application::GetSolarMutex());
660     const IFieldmark *pBkm = dynamic_cast<const IFieldmark*>(GetBookmark());
661     if(!pBkm)
662         throw uno::RuntimeException();
663     return pBkm->GetFieldname();
664 }
665 
666 void SwXFieldmark::setFieldType(const::rtl::OUString & fieldType)
667     throw(uno::RuntimeException)
668 {
669     vos::OGuard aGuard(Application::GetSolarMutex());
670     IFieldmark *pBkm = const_cast<IFieldmark*>(
671         dynamic_cast<const IFieldmark*>(GetBookmark()));
672     if(!pBkm)
673         throw uno::RuntimeException();
674     pBkm->SetFieldname(fieldType);
675 }
676 
677 uno::Reference<container::XNameContainer> SwXFieldmark::getParameters()
678     throw (uno::RuntimeException)
679 {
680     vos::OGuard aGuard(Application::GetSolarMutex());
681     IFieldmark *pBkm = const_cast<IFieldmark*>(
682         dynamic_cast<const IFieldmark*>(GetBookmark()));
683     if(!pBkm)
684         throw uno::RuntimeException();
685     return uno::Reference<container::XNameContainer>(new SwXFieldmarkParameters(pBkm));
686 }
687 
688