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 { 199 return ::sw::UnoTunnelImpl<SwXBookmark>(rId, this); 200 } 201 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 261 void SwXBookmark::attachToRange( const uno::Reference< text::XTextRange > & xTextRange ) 262 { 263 attachToRangeEx(xTextRange, IDocumentMarkAccess::BOOKMARK); 264 } 265 266 void SAL_CALL SwXBookmark::attach( const uno::Reference< text::XTextRange > & xTextRange ) 267 { 268 vos::OGuard aGuard(Application::GetSolarMutex()); 269 attachToRange( xTextRange ); 270 } 271 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 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 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 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 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 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 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 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 389 SwXBookmark::getSupportedServiceNames() 390 { 391 return ::sw::GetSupportedServiceNamesImpl( 392 g_nServicesBookmark, g_ServicesBookmark); 393 } 394 395 // MetadatableMixin 396 ::sfx2::Metadatable* SwXBookmark::GetCoreObject() 397 { 398 return dynamic_cast< ::sfx2::Metadatable* >(m_pImpl->m_pRegisteredBookmark); 399 } 400 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 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 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 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 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 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 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 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 488 SwXFieldmark::SwXFieldmark( bool _isReplacementObject ) 489 : SwXFieldmark_Base() 490 , isReplacementObject(_isReplacementObject) 491 { 492 } 493 494 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 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 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 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 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 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 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 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 590 uno::Type SwXFieldmarkParameters::getElementType() 591 { 592 return ::cppu::UnoType< ::cppu::UnoVoidType>::get(); 593 } 594 595 ::sal_Bool SwXFieldmarkParameters::hasElements() 596 { 597 vos::OGuard aGuard(Application::GetSolarMutex()); 598 return !getCoreParameters()->empty(); 599 } 600 601 void SwXFieldmarkParameters::Modify(const SfxPoolItem *pOld, const SfxPoolItem *pNew) 602 { 603 ClientModify(this, pOld, pNew); 604 } 605 606 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 616 void SwXFieldmark::attachToRange( const uno::Reference < text::XTextRange >& xTextRange ) 617 { 618 attachToRangeEx( xTextRange, 619 ( isReplacementObject ? IDocumentMarkAccess::CHECKBOX_FIELDMARK : IDocumentMarkAccess::TEXT_FIELDMARK ) ); 620 } 621 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 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 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