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 <com/sun/star/beans/PropertyAttribute.hpp> 28 #include <com/sun/star/container/XIndexReplace.hpp> 29 #include <com/sun/star/frame/XModel.hpp> 30 #include <com/sun/star/text/ChapterFormat.hpp> 31 #include <com/sun/star/text/ReferenceFieldPart.hpp> 32 #include <com/sun/star/text/BibliographyDataField.hpp> 33 #include <com/sun/star/text/XTextDocument.hpp> 34 35 #include <tools/debug.hxx> 36 #include <vos/mutex.hxx> 37 #include <vcl/svapp.hxx> 38 #include <editeng/unolingu.hxx> 39 #include <com/sun/star/text/ChapterFormat.hpp> 40 #include <com/sun/star/text/ReferenceFieldPart.hpp> 41 #include <com/sun/star/text/BibliographyDataField.hpp> 42 #include <com/sun/star/frame/XModel.hpp> 43 #include <com/sun/star/text/XTextDocument.hpp> 44 #include <com/sun/star/beans/PropertyAttribute.hpp> 45 #include <hints.hxx> 46 #include <cmdid.h> 47 #include <swtypes.hxx> 48 #include <shellres.hxx> 49 #include <viewsh.hxx> 50 #include <doc.hxx> 51 #include <docary.hxx> 52 #include <poolfmt.hxx> 53 #include <poolfmt.hrc> 54 #include <pagedesc.hxx> 55 #include <fmtcntnt.hxx> 56 #include <unomap.hxx> 57 #include <unotextrange.hxx> 58 #include <unotextcursor.hxx> 59 #include <unosection.hxx> 60 #include <doctxm.hxx> 61 #include <txttxmrk.hxx> 62 #include <unocrsr.hxx> 63 #include <unostyle.hxx> 64 #include <ndtxt.hxx> 65 #include <unoidx.hxx> 66 #include <docsh.hxx> 67 #include <chpfld.hxx> 68 #include <SwStyleNameMapper.hxx> 69 #include <unoevtlstnr.hxx> 70 #include <editsh.hxx> 71 72 73 using namespace ::com::sun::star; 74 using ::rtl::OUString; 75 76 //----------------------------------------------------------------------------- 77 static OUString 78 lcl_AnyToString(uno::Any const& rVal) throw (lang::IllegalArgumentException) 79 { 80 OUString sRet; 81 if(!(rVal >>= sRet)) 82 { 83 throw lang::IllegalArgumentException(); 84 } 85 return sRet; 86 } 87 //----------------------------------------------------------------------------- 88 static sal_Int16 89 lcl_AnyToInt16(uno::Any const& rVal) throw (lang::IllegalArgumentException) 90 { 91 sal_Int16 nRet = 0; 92 if(!(rVal >>= nRet)) 93 { 94 throw lang::IllegalArgumentException(); 95 } 96 return nRet; 97 } 98 //----------------------------------------------------------------------------- 99 static sal_Bool 100 lcl_AnyToBool(uno::Any const& rVal) throw (lang::IllegalArgumentException) 101 { 102 sal_Bool bRet = sal_False; 103 if(!(rVal >>= bRet)) 104 { 105 throw lang::IllegalArgumentException(); 106 } 107 return bRet; 108 } 109 110 static void 111 lcl_AnyToBitMask(uno::Any const& rValue, 112 sal_uInt16 & rBitMask, const sal_uInt16 nBit) 113 throw (lang::IllegalArgumentException) 114 { 115 rBitMask = lcl_AnyToBool(rValue) 116 ? (rBitMask | nBit) 117 : (rBitMask & ~nBit); 118 } 119 static void 120 lcl_BitMaskToAny(uno::Any & o_rValue, 121 const sal_uInt16 nBitMask, const sal_uInt16 nBit) 122 { 123 const sal_Bool bRet = 0 != (nBitMask & nBit); 124 o_rValue <<= bRet; 125 } 126 127 //----------------------------------------------------------------------------- 128 static void 129 lcl_ReAssignTOXType(SwDoc* pDoc, SwTOXBase& rTOXBase, const OUString& rNewName) 130 { 131 const sal_uInt16 nUserCount = pDoc->GetTOXTypeCount( TOX_USER ); 132 const SwTOXType* pNewType = 0; 133 for(sal_uInt16 nUser = 0; nUser < nUserCount; nUser++) 134 { 135 const SwTOXType* pType = pDoc->GetTOXType( TOX_USER, nUser ); 136 if(pType->GetTypeName().Equals((String)rNewName)) 137 { 138 pNewType = pType; 139 break; 140 } 141 } 142 if(!pNewType) 143 { 144 SwTOXType aNewType(TOX_USER, rNewName); 145 pNewType = pDoc->InsertTOXType( aNewType ); 146 } 147 148 rTOXBase.RegisterToTOXType( *((SwTOXType*)pNewType) ); 149 } 150 //----------------------------------------------------------------------------- 151 static const char cUserDefined[] = "User-Defined"; 152 static const char cUserSuffix[] = " (user)"; 153 #define USER_LEN 12 154 #define USER_AND_SUFFIXLEN 19 155 156 void lcl_ConvertTOUNameToProgrammaticName(OUString& rTmp) 157 { 158 ShellResource* pShellRes = ViewShell::GetShellRes(); 159 160 if(rTmp.equals(pShellRes->aTOXUserName)) 161 { 162 rTmp = OUString(C2U(cUserDefined)); 163 } 164 // if the version is not English but the alternative index's name is 165 // "User-Defined" a " (user)" is appended 166 else if(rTmp.equalsAscii(cUserDefined)) 167 { 168 rTmp += C2U(cUserSuffix); 169 } 170 } 171 //----------------------------------------------------------------------------- 172 static void 173 lcl_ConvertTOUNameToUserName(OUString& rTmp) 174 { 175 ShellResource* pShellRes = ViewShell::GetShellRes(); 176 if(rTmp.equalsAscii(cUserDefined)) 177 { 178 rTmp = pShellRes->aTOXUserName; 179 } 180 else if(!pShellRes->aTOXUserName.EqualsAscii(cUserDefined) && 181 USER_AND_SUFFIXLEN == rTmp.getLength()) 182 { 183 //make sure that in non-English versions the " (user)" suffix is removed 184 if (rTmp.matchAsciiL(cUserDefined, sizeof(cUserDefined)) && 185 rTmp.matchAsciiL(cUserSuffix, sizeof(cUserSuffix), USER_LEN)) 186 { 187 rTmp = C2U(cUserDefined); 188 } 189 } 190 } 191 192 /* -----------------13.09.99 16:39------------------- 193 194 --------------------------------------------------*/ 195 typedef ::cppu::WeakImplHelper2 196 < lang::XServiceInfo 197 , container::XIndexReplace 198 > SwXDocumentIndexStyleAccess_Base; 199 200 class SwXDocumentIndex::StyleAccess_Impl 201 : public SwXDocumentIndexStyleAccess_Base 202 { 203 204 private: 205 /// can be destroyed threadsafely, so no UnoImplPtr here 206 ::rtl::Reference<SwXDocumentIndex> m_xParent; 207 208 virtual ~StyleAccess_Impl(); 209 210 public: 211 StyleAccess_Impl(SwXDocumentIndex& rParentIdx); 212 213 // XServiceInfo 214 virtual ::rtl::OUString SAL_CALL getImplementationName() 215 throw (uno::RuntimeException); 216 virtual sal_Bool SAL_CALL 217 supportsService(const ::rtl::OUString& rServiceName) 218 throw (uno::RuntimeException); 219 virtual uno::Sequence< ::rtl::OUString > SAL_CALL 220 getSupportedServiceNames() throw (uno::RuntimeException); 221 222 // XElementAccess 223 virtual uno::Type SAL_CALL getElementType() throw (uno::RuntimeException); 224 virtual sal_Bool SAL_CALL hasElements() throw (uno::RuntimeException); 225 226 // XIndexAccess 227 virtual sal_Int32 SAL_CALL getCount() throw (uno::RuntimeException); 228 virtual uno::Any SAL_CALL getByIndex(sal_Int32 nIndex) 229 throw (lang::IndexOutOfBoundsException, lang::WrappedTargetException, 230 uno::RuntimeException); 231 232 // XIndexReplace 233 virtual void SAL_CALL 234 replaceByIndex(sal_Int32 Index, const uno::Any& rElement) 235 throw (lang::IllegalArgumentException, lang::IndexOutOfBoundsException, 236 lang::WrappedTargetException, uno::RuntimeException); 237 238 }; 239 240 /* -----------------13.09.99 16:39------------------- 241 242 --------------------------------------------------*/ 243 typedef ::cppu::WeakImplHelper2 244 < lang::XServiceInfo 245 , container::XIndexReplace 246 > SwXDocumentIndexTokenAccess_Base; 247 248 class SwXDocumentIndex::TokenAccess_Impl 249 : public SwXDocumentIndexTokenAccess_Base 250 { 251 252 private: 253 /// can be destroyed threadsafely, so no UnoImplPtr here 254 ::rtl::Reference<SwXDocumentIndex> m_xParent; 255 256 virtual ~TokenAccess_Impl(); 257 258 public: 259 260 TokenAccess_Impl(SwXDocumentIndex& rParentIdx); 261 262 // XServiceInfo 263 virtual ::rtl::OUString SAL_CALL getImplementationName() 264 throw (uno::RuntimeException); 265 virtual sal_Bool SAL_CALL 266 supportsService(const ::rtl::OUString& rServiceName) 267 throw (uno::RuntimeException); 268 virtual uno::Sequence< ::rtl::OUString > SAL_CALL 269 getSupportedServiceNames() throw (uno::RuntimeException); 270 271 // XElementAccess 272 virtual uno::Type SAL_CALL getElementType() throw (uno::RuntimeException); 273 virtual sal_Bool SAL_CALL hasElements() throw (uno::RuntimeException); 274 275 // XIndexAccess 276 virtual sal_Int32 SAL_CALL getCount() throw (uno::RuntimeException); 277 virtual uno::Any SAL_CALL getByIndex(sal_Int32 nIndex) 278 throw (lang::IndexOutOfBoundsException, lang::WrappedTargetException, 279 uno::RuntimeException); 280 281 // XIndexReplace 282 virtual void SAL_CALL 283 replaceByIndex(sal_Int32 Index, const uno::Any& rElement) 284 throw (lang::IllegalArgumentException, lang::IndexOutOfBoundsException, 285 lang::WrappedTargetException, uno::RuntimeException); 286 287 }; 288 289 290 /****************************************************************** 291 * SwXDocumentIndex 292 ******************************************************************/ 293 294 /* -----------------20.06.98 11:06------------------- 295 * 296 * --------------------------------------------------*/ 297 class SwDocIndexDescriptorProperties_Impl 298 { 299 private: 300 ::std::auto_ptr<SwTOXBase> m_pTOXBase; 301 OUString m_sUserTOXTypeName; 302 303 public: 304 SwDocIndexDescriptorProperties_Impl(SwTOXType const*const pType); 305 306 SwTOXBase & GetTOXBase() { return *m_pTOXBase; } 307 const OUString& GetTypeName() const { return m_sUserTOXTypeName; } 308 void SetTypeName(const OUString& rSet) { m_sUserTOXTypeName = rSet; } 309 }; 310 /* -----------------20.06.98 11:41------------------- 311 * 312 * --------------------------------------------------*/ 313 SwDocIndexDescriptorProperties_Impl::SwDocIndexDescriptorProperties_Impl( 314 SwTOXType const*const pType) 315 { 316 SwForm aForm(pType->GetType()); 317 m_pTOXBase.reset(new SwTOXBase(pType, aForm, 318 nsSwTOXElement::TOX_MARK, pType->GetTypeName())); 319 if(pType->GetType() == TOX_CONTENT || pType->GetType() == TOX_USER) 320 { 321 m_pTOXBase->SetLevel(MAXLEVEL); 322 } 323 m_sUserTOXTypeName = pType->GetTypeName(); 324 } 325 326 static sal_uInt16 327 lcl_TypeToPropertyMap_Index(const TOXTypes eType) 328 { 329 switch (eType) 330 { 331 case TOX_INDEX: return PROPERTY_MAP_INDEX_IDX; 332 case TOX_CONTENT: return PROPERTY_MAP_INDEX_CNTNT; 333 case TOX_TABLES: return PROPERTY_MAP_INDEX_TABLES; 334 case TOX_ILLUSTRATIONS: return PROPERTY_MAP_INDEX_ILLUSTRATIONS; 335 case TOX_OBJECTS: return PROPERTY_MAP_INDEX_OBJECTS; 336 case TOX_AUTHORITIES: return PROPERTY_MAP_BIBLIOGRAPHY; 337 //case TOX_USER: 338 default: 339 return PROPERTY_MAP_INDEX_USER; 340 } 341 } 342 343 class SwXDocumentIndex::Impl 344 : public SwClient 345 { 346 347 public: 348 349 SfxItemPropertySet const& m_rPropSet; 350 const TOXTypes m_eTOXType; 351 SwEventListenerContainer m_ListenerContainer; 352 bool m_bIsDescriptor; 353 SwDoc * m_pDoc; 354 ::std::auto_ptr<SwDocIndexDescriptorProperties_Impl> m_pProps; 355 uno::WeakReference<container::XIndexReplace> m_wStyleAccess; 356 uno::WeakReference<container::XIndexReplace> m_wTokenAccess; 357 358 Impl( SwXDocumentIndex & rThis, 359 SwDoc & rDoc, 360 const TOXTypes eType, 361 SwTOXBaseSection const*const pBaseSection) 362 : SwClient((pBaseSection) ? pBaseSection->GetFmt() : 0) 363 , m_rPropSet( 364 *aSwMapProvider.GetPropertySet(lcl_TypeToPropertyMap_Index(eType))) 365 , m_eTOXType(eType) 366 , m_ListenerContainer(static_cast< ::cppu::OWeakObject* >(&rThis)) 367 // #i111177# unxsols4 (Sun C++ 5.9 SunOS_sparc) may generate wrong code 368 , m_bIsDescriptor((0 == pBaseSection) ? true : false) 369 , m_pDoc(&rDoc) 370 , m_pProps((m_bIsDescriptor) 371 ? new SwDocIndexDescriptorProperties_Impl(rDoc.GetTOXType(eType, 0)) 372 : 0) 373 { 374 } 375 376 SwSectionFmt * GetSectionFmt() const { 377 return static_cast<SwSectionFmt *>( 378 const_cast<SwModify *>(GetRegisteredIn())); 379 } 380 381 SwTOXBase & GetTOXSectionOrThrow() const 382 { 383 SwSectionFmt *const pSectionFmt(GetSectionFmt()); 384 SwTOXBase *const pTOXSection( (m_bIsDescriptor) 385 ? &m_pProps->GetTOXBase() 386 : ((pSectionFmt) 387 ? static_cast<SwTOXBaseSection*>(pSectionFmt->GetSection()) 388 : 0)); 389 if (!pTOXSection) 390 { 391 throw uno::RuntimeException(OUString(RTL_CONSTASCII_USTRINGPARAM( 392 "SwXDocumentIndex: disposed or invalid")), 0); 393 } 394 return *pTOXSection; 395 } 396 397 sal_Int32 GetFormMax() const 398 { 399 SwTOXBase & rSection( GetTOXSectionOrThrow() ); 400 return (m_bIsDescriptor) 401 ? SwForm::GetFormMaxLevel(m_eTOXType) 402 : rSection.GetTOXForm().GetFormMax(); 403 } 404 protected: 405 // SwClient 406 virtual void Modify(const SfxPoolItem *pOld, const SfxPoolItem *pNew); 407 408 }; 409 410 /*-- 14.12.98 09:35:07--------------------------------------------------- 411 412 -----------------------------------------------------------------------*/ 413 void SwXDocumentIndex::Impl::Modify(const SfxPoolItem *pOld, const SfxPoolItem *pNew) 414 { 415 ClientModify(this, pOld, pNew); 416 417 if (!GetRegisteredIn()) 418 { 419 m_ListenerContainer.Disposing(); 420 } 421 } 422 423 /*-- 14.12.98 09:35:03--------------------------------------------------- 424 425 -----------------------------------------------------------------------*/ 426 SwXDocumentIndex::SwXDocumentIndex( 427 SwTOXBaseSection const& rBaseSection, SwDoc & rDoc) 428 : m_pImpl( new SwXDocumentIndex::Impl( *this, 429 rDoc, rBaseSection.SwTOXBase::GetType(), & rBaseSection) ) 430 { 431 } 432 /* -----------------15.01.99 14:59------------------- 433 * 434 * --------------------------------------------------*/ 435 SwXDocumentIndex::SwXDocumentIndex(const TOXTypes eType, SwDoc& rDoc) 436 : m_pImpl( new SwXDocumentIndex::Impl( *this, rDoc, eType, 0) ) 437 { 438 } 439 440 /*-- 14.12.98 09:35:04--------------------------------------------------- 441 442 -----------------------------------------------------------------------*/ 443 SwXDocumentIndex::~SwXDocumentIndex() 444 { 445 } 446 447 uno::Reference<text::XDocumentIndex> 448 SwXDocumentIndex::CreateXDocumentIndex( 449 SwDoc & rDoc, SwTOXBaseSection const& rSection) 450 { 451 // re-use existing SwXDocumentIndex 452 // #i105557#: do not iterate over the registered clients: race condition 453 SwSectionFmt *const pFmt = rSection.GetFmt(); 454 uno::Reference<text::XDocumentIndex> xIndex(pFmt->GetXObject(), 455 uno::UNO_QUERY); 456 if (!xIndex.is()) 457 { 458 SwXDocumentIndex *const pIndex(new SwXDocumentIndex(rSection, rDoc)); 459 xIndex.set(pIndex); 460 pFmt->SetXObject(uno::Reference<uno::XInterface>(xIndex)); 461 } 462 return xIndex; 463 } 464 465 /* -----------------------------10.03.00 18:02-------------------------------- 466 467 ---------------------------------------------------------------------------*/ 468 const uno::Sequence< sal_Int8 > & SwXDocumentIndex::getUnoTunnelId() 469 { 470 static uno::Sequence< sal_Int8 > aSeq = ::CreateUnoTunnelId(); 471 return aSeq; 472 } 473 /* -----------------------------10.03.00 18:04-------------------------------- 474 475 ---------------------------------------------------------------------------*/ 476 sal_Int64 SAL_CALL 477 SwXDocumentIndex::getSomething(const uno::Sequence< sal_Int8 >& rId) 478 throw (uno::RuntimeException) 479 { 480 return ::sw::UnoTunnelImpl<SwXDocumentIndex>(rId, this); 481 } 482 483 /* -----------------------------06.04.00 15:01-------------------------------- 484 485 ---------------------------------------------------------------------------*/ 486 OUString SAL_CALL 487 SwXDocumentIndex::getImplementationName() throw (uno::RuntimeException) 488 { 489 return C2U("SwXDocumentIndex"); 490 } 491 /* -----------------------------06.04.00 15:01-------------------------------- 492 493 ---------------------------------------------------------------------------*/ 494 sal_Bool SAL_CALL 495 SwXDocumentIndex::supportsService(const OUString& rServiceName) 496 throw (uno::RuntimeException) 497 { 498 vos::OGuard g(Application::GetSolarMutex()); 499 500 return C2U("com.sun.star.text.BaseIndex") == rServiceName 501 || ((TOX_INDEX == m_pImpl->m_eTOXType) && 502 rServiceName.equalsAscii("com.sun.star.text.DocumentIndex")) 503 || ((TOX_CONTENT == m_pImpl->m_eTOXType) && 504 rServiceName.equalsAscii("com.sun.star.text.ContentIndex")) 505 || ((TOX_USER == m_pImpl->m_eTOXType) && 506 rServiceName.equalsAscii("com.sun.star.text.UserDefinedIndex")) 507 || ((TOX_ILLUSTRATIONS == m_pImpl->m_eTOXType) && 508 rServiceName.equalsAscii("com.sun.star.text.IllustrationsIndex")) 509 || ((TOX_TABLES == m_pImpl->m_eTOXType) && 510 rServiceName.equalsAscii("com.sun.star.text.TableIndex")) 511 || ((TOX_OBJECTS == m_pImpl->m_eTOXType) && 512 rServiceName.equalsAscii("com.sun.star.text.ObjectIndex")) 513 || ((TOX_AUTHORITIES == m_pImpl->m_eTOXType) && 514 rServiceName.equalsAscii("com.sun.star.text.Bibliography")); 515 } 516 /* -----------------------------06.04.00 15:01-------------------------------- 517 518 ---------------------------------------------------------------------------*/ 519 uno::Sequence< OUString > SAL_CALL 520 SwXDocumentIndex::getSupportedServiceNames() throw (uno::RuntimeException) 521 { 522 vos::OGuard g(Application::GetSolarMutex()); 523 524 uno::Sequence< OUString > aRet(2); 525 OUString* pArray = aRet.getArray(); 526 pArray[0] = C2U("com.sun.star.text.BaseIndex"); 527 switch (m_pImpl->m_eTOXType) 528 { 529 case TOX_INDEX: 530 pArray[1] = C2U("com.sun.star.text.DocumentIndex"); 531 break; 532 case TOX_CONTENT: 533 pArray[1] = C2U("com.sun.star.text.ContentIndex"); 534 break; 535 case TOX_TABLES: 536 pArray[1] = C2U("com.sun.star.text.TableIndex"); 537 break; 538 case TOX_ILLUSTRATIONS: 539 pArray[1] = C2U("com.sun.star.text.IllustrationsIndex"); 540 break; 541 case TOX_OBJECTS: 542 pArray[1] = C2U("com.sun.star.text.ObjectIndex"); 543 break; 544 case TOX_AUTHORITIES: 545 pArray[1] = C2U("com.sun.star.text.Bibliography"); 546 break; 547 //case TOX_USER: 548 default: 549 pArray[1] = C2U("com.sun.star.text.UserDefinedIndex"); 550 } 551 return aRet; 552 } 553 554 /*-- 14.12.98 09:35:05--------------------------------------------------- 555 556 -----------------------------------------------------------------------*/ 557 OUString SAL_CALL SwXDocumentIndex::getServiceName() 558 throw (uno::RuntimeException) 559 { 560 vos::OGuard g(Application::GetSolarMutex()); 561 562 sal_uInt16 nObjectType = SW_SERVICE_TYPE_INDEX; 563 switch (m_pImpl->m_eTOXType) 564 { 565 // case TOX_INDEX: break; 566 case TOX_USER: nObjectType = SW_SERVICE_USER_INDEX; 567 break; 568 case TOX_CONTENT: nObjectType = SW_SERVICE_CONTENT_INDEX; 569 break; 570 case TOX_ILLUSTRATIONS: nObjectType = SW_SERVICE_INDEX_ILLUSTRATIONS; 571 break; 572 case TOX_OBJECTS: nObjectType = SW_SERVICE_INDEX_OBJECTS; 573 break; 574 case TOX_TABLES: nObjectType = SW_SERVICE_INDEX_TABLES; 575 break; 576 case TOX_AUTHORITIES: nObjectType = SW_SERVICE_INDEX_BIBLIOGRAPHY; 577 break; 578 default: 579 break; 580 } 581 return SwXServiceProvider::GetProviderName(nObjectType); 582 } 583 584 /*-- 14.12.98 09:35:05--------------------------------------------------- 585 586 -----------------------------------------------------------------------*/ 587 void lcl_CalcLayout(SwDoc *pDoc) 588 { 589 ViewShell *pViewShell = 0; 590 SwEditShell* pEditShell = pDoc ? pDoc->GetEditShell(&pViewShell) : 0; 591 if (pEditShell) 592 { 593 pEditShell->CalcLayout(); 594 } 595 else if (pViewShell) 596 { 597 pViewShell->CalcLayout(); 598 } 599 600 } 601 602 void SAL_CALL SwXDocumentIndex::update() throw (uno::RuntimeException) 603 { 604 vos::OGuard aGuard(Application::GetSolarMutex()); 605 606 SwSectionFmt *const pFmt = m_pImpl->GetSectionFmt(); 607 SwTOXBaseSection *const pTOXBase = (pFmt) ? 608 static_cast<SwTOXBaseSection*>(pFmt->GetSection()) : 0; 609 if(!pTOXBase) 610 { 611 throw uno::RuntimeException(); 612 } 613 pTOXBase->Update(); 614 615 // the insertion of TOC will affect the document layout 616 lcl_CalcLayout(m_pImpl->m_pDoc); 617 618 // page numbers 619 pTOXBase->UpdatePageNum(); 620 } 621 622 /*-- 14.12.98 09:35:05--------------------------------------------------- 623 624 -----------------------------------------------------------------------*/ 625 uno::Reference< beans::XPropertySetInfo > SAL_CALL 626 SwXDocumentIndex::getPropertySetInfo() throw (uno::RuntimeException) 627 { 628 vos::OGuard g(Application::GetSolarMutex()); 629 630 const uno::Reference< beans::XPropertySetInfo > xRef = 631 m_pImpl->m_rPropSet.getPropertySetInfo(); 632 return xRef; 633 } 634 635 /*-- 14.12.98 09:35:05--------------------------------------------------- 636 637 -----------------------------------------------------------------------*/ 638 void SAL_CALL 639 SwXDocumentIndex::setPropertyValue( 640 const OUString& rPropertyName, const uno::Any& rValue) 641 throw (beans::UnknownPropertyException, beans::PropertyVetoException, 642 lang::IllegalArgumentException, lang::WrappedTargetException, 643 uno::RuntimeException) 644 { 645 vos::OGuard aGuard(Application::GetSolarMutex()); 646 647 SfxItemPropertySimpleEntry const*const pEntry = 648 m_pImpl->m_rPropSet.getPropertyMap()->getByName(rPropertyName); 649 if (!pEntry) 650 { 651 throw beans::UnknownPropertyException( 652 OUString(RTL_CONSTASCII_USTRINGPARAM("Unknown property: ")) 653 + rPropertyName, 654 static_cast<cppu::OWeakObject *>(this)); 655 } 656 if (pEntry->nFlags & beans::PropertyAttribute::READONLY) 657 { 658 throw beans::PropertyVetoException( 659 OUString(RTL_CONSTASCII_USTRINGPARAM("Property is read-only: " )) 660 + rPropertyName, 661 static_cast<cppu::OWeakObject *>(this)); 662 } 663 664 SwSectionFmt *const pSectionFmt(m_pImpl->GetSectionFmt()); 665 SwTOXBase & rTOXBase( m_pImpl->GetTOXSectionOrThrow() ); 666 667 sal_uInt16 nCreate = rTOXBase.GetCreateType(); 668 sal_uInt16 nTOIOptions = 0; 669 sal_uInt16 nOLEOptions = rTOXBase.GetOLEOptions(); 670 const TOXTypes eTxBaseType = rTOXBase.GetTOXType()->GetType(); 671 if (eTxBaseType == TOX_INDEX) 672 { 673 nTOIOptions = rTOXBase.GetOptions(); 674 } 675 SwForm aForm(rTOXBase.GetTOXForm()); 676 sal_Bool bForm = sal_False; 677 switch (pEntry->nWID) 678 { 679 case WID_IDX_TITLE: 680 { 681 OUString sNewName; 682 if (!(rValue >>= sNewName)) 683 { 684 throw lang::IllegalArgumentException(); 685 } 686 rTOXBase.SetTitle(sNewName); 687 } 688 break; 689 case WID_IDX_NAME: 690 { 691 OUString sNewName; 692 if (!(rValue >>= sNewName)) 693 { 694 throw lang::IllegalArgumentException(); 695 } 696 rTOXBase.SetTOXName(sNewName); 697 } 698 break; 699 case WID_USER_IDX_NAME: 700 { 701 OUString sNewName; 702 if (!(rValue >>= sNewName)) 703 { 704 throw lang::IllegalArgumentException(); 705 } 706 lcl_ConvertTOUNameToUserName(sNewName); 707 DBG_ASSERT(TOX_USER == eTxBaseType, 708 "tox type name can only be changed for user indexes"); 709 if (pSectionFmt) 710 { 711 OUString sTmp = rTOXBase.GetTOXType()->GetTypeName(); 712 if (sTmp != sNewName) 713 { 714 lcl_ReAssignTOXType(pSectionFmt->GetDoc(), 715 rTOXBase, sNewName); 716 } 717 } 718 else 719 { 720 m_pImpl->m_pProps->SetTypeName(sNewName); 721 } 722 } 723 break; 724 case WID_IDX_LOCALE: 725 { 726 lang::Locale aLocale; 727 if (!(rValue>>= aLocale)) 728 { 729 throw lang::IllegalArgumentException(); 730 } 731 rTOXBase.SetLanguage(SvxLocaleToLanguage(aLocale)); 732 } 733 break; 734 case WID_IDX_SORT_ALGORITHM: 735 { 736 OUString sTmp; 737 if (!(rValue >>= sTmp)) 738 { 739 throw lang::IllegalArgumentException(); 740 } 741 rTOXBase.SetSortAlgorithm(sTmp); 742 } 743 break; 744 case WID_LEVEL: 745 { 746 rTOXBase.SetLevel(lcl_AnyToInt16(rValue)); 747 } 748 break; 749 case WID_CREATE_FROM_MARKS: 750 lcl_AnyToBitMask(rValue, nCreate, nsSwTOXElement::TOX_MARK); 751 break; 752 case WID_CREATE_FROM_OUTLINE: 753 lcl_AnyToBitMask(rValue, nCreate, nsSwTOXElement::TOX_OUTLINELEVEL); 754 break; 755 // case WID_PARAGRAPH_STYLE_NAMES :DBG_ERROR("not implemented") 756 // break; 757 case WID_CREATE_FROM_CHAPTER: 758 rTOXBase.SetFromChapter(lcl_AnyToBool(rValue)); 759 break; 760 case WID_CREATE_FROM_LABELS: 761 rTOXBase.SetFromObjectNames(! lcl_AnyToBool(rValue)); 762 break; 763 case WID_PROTECTED: 764 { 765 sal_Bool bSet = lcl_AnyToBool(rValue); 766 rTOXBase.SetProtected(bSet); 767 if (pSectionFmt) 768 { 769 static_cast<SwTOXBaseSection &>(rTOXBase).SetProtect(bSet); 770 } 771 } 772 break; 773 case WID_USE_ALPHABETICAL_SEPARATORS: 774 lcl_AnyToBitMask(rValue, nTOIOptions, 775 nsSwTOIOptions::TOI_ALPHA_DELIMITTER); 776 break; 777 case WID_USE_KEY_AS_ENTRY: 778 lcl_AnyToBitMask(rValue, nTOIOptions, 779 nsSwTOIOptions::TOI_KEY_AS_ENTRY); 780 break; 781 case WID_USE_COMBINED_ENTRIES: 782 lcl_AnyToBitMask(rValue, nTOIOptions, 783 nsSwTOIOptions::TOI_SAME_ENTRY); 784 break; 785 case WID_IS_CASE_SENSITIVE: 786 lcl_AnyToBitMask(rValue, nTOIOptions, 787 nsSwTOIOptions::TOI_CASE_SENSITIVE); 788 break; 789 case WID_USE_P_P: 790 lcl_AnyToBitMask(rValue, nTOIOptions, nsSwTOIOptions::TOI_FF); 791 break; 792 case WID_USE_DASH: 793 lcl_AnyToBitMask(rValue, nTOIOptions, nsSwTOIOptions::TOI_DASH); 794 break; 795 case WID_USE_UPPER_CASE: 796 lcl_AnyToBitMask(rValue, nTOIOptions, 797 nsSwTOIOptions::TOI_INITIAL_CAPS); 798 break; 799 case WID_IS_COMMA_SEPARATED: 800 bForm = sal_True; 801 aForm.SetCommaSeparated(lcl_AnyToBool(rValue)); 802 break; 803 case WID_LABEL_CATEGORY: 804 { 805 // convert file-format/API/external programmatic english name 806 // to internal UI name before usage 807 String aName( SwStyleNameMapper::GetSpecialExtraUIName( 808 lcl_AnyToString(rValue) ) ); 809 rTOXBase.SetSequenceName( aName ); 810 } 811 break; 812 case WID_LABEL_DISPLAY_TYPE: 813 { 814 const sal_Int16 nVal = lcl_AnyToInt16(rValue); 815 sal_uInt16 nSet = CAPTION_COMPLETE; 816 switch (nVal) 817 { 818 case text::ReferenceFieldPart::TEXT: 819 nSet = CAPTION_COMPLETE; 820 break; 821 case text::ReferenceFieldPart::CATEGORY_AND_NUMBER: 822 nSet = CAPTION_NUMBER; 823 break; 824 case text::ReferenceFieldPart::ONLY_CAPTION: 825 nSet = CAPTION_TEXT; 826 break; 827 default: 828 throw lang::IllegalArgumentException(); 829 } 830 rTOXBase.SetCaptionDisplay(static_cast<SwCaptionDisplay>(nSet)); 831 } 832 break; 833 case WID_USE_LEVEL_FROM_SOURCE: 834 rTOXBase.SetLevelFromChapter(lcl_AnyToBool(rValue)); 835 break; 836 case WID_MAIN_ENTRY_CHARACTER_STYLE_NAME: 837 { 838 String aString; 839 SwStyleNameMapper::FillUIName(lcl_AnyToString(rValue), 840 aString, nsSwGetPoolIdFromName::GET_POOLID_CHRFMT, sal_True); 841 rTOXBase.SetMainEntryCharStyle( aString ); 842 } 843 break; 844 case WID_CREATE_FROM_TABLES: 845 lcl_AnyToBitMask(rValue, nCreate, nsSwTOXElement::TOX_TABLE); 846 break; 847 case WID_CREATE_FROM_TEXT_FRAMES: 848 lcl_AnyToBitMask(rValue, nCreate, nsSwTOXElement::TOX_FRAME); 849 break; 850 case WID_CREATE_FROM_GRAPHIC_OBJECTS: 851 lcl_AnyToBitMask(rValue, nCreate, nsSwTOXElement::TOX_GRAPHIC); 852 break; 853 case WID_CREATE_FROM_EMBEDDED_OBJECTS: 854 lcl_AnyToBitMask(rValue, nCreate, nsSwTOXElement::TOX_OLE); 855 break; 856 case WID_CREATE_FROM_STAR_MATH: 857 lcl_AnyToBitMask(rValue, nOLEOptions, nsSwTOOElements::TOO_MATH); 858 break; 859 case WID_CREATE_FROM_STAR_CHART: 860 lcl_AnyToBitMask(rValue, nOLEOptions, nsSwTOOElements::TOO_CHART); 861 break; 862 case WID_CREATE_FROM_STAR_CALC: 863 lcl_AnyToBitMask(rValue, nOLEOptions, nsSwTOOElements::TOO_CALC); 864 break; 865 case WID_CREATE_FROM_STAR_DRAW: 866 lcl_AnyToBitMask(rValue, nOLEOptions, 867 nsSwTOOElements::TOO_DRAW_IMPRESS); 868 break; 869 case WID_CREATE_FROM_OTHER_EMBEDDED_OBJECTS: 870 lcl_AnyToBitMask(rValue, nOLEOptions, nsSwTOOElements::TOO_OTHER); 871 break; 872 case WID_PARA_HEAD: 873 { 874 String aString; 875 SwStyleNameMapper::FillUIName( lcl_AnyToString(rValue), 876 aString, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, sal_True); 877 bForm = sal_True; 878 // Header is on Pos 0 879 aForm.SetTemplate( 0, aString ); 880 } 881 break; 882 case WID_IS_RELATIVE_TABSTOPS: 883 bForm = sal_True; 884 aForm.SetRelTabPos(lcl_AnyToBool(rValue)); 885 break; 886 case WID_PARA_SEP: 887 { 888 String aString; 889 bForm = sal_True; 890 SwStyleNameMapper::FillUIName( lcl_AnyToString(rValue), 891 aString, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, sal_True); 892 aForm.SetTemplate( 1, aString ); 893 } 894 break; 895 case WID_CREATE_FROM_PARAGRAPH_STYLES: 896 lcl_AnyToBitMask(rValue, nCreate, nsSwTOXElement::TOX_TEMPLATE); 897 break; 898 899 case WID_PARA_LEV1: 900 case WID_PARA_LEV2: 901 case WID_PARA_LEV3: 902 case WID_PARA_LEV4: 903 case WID_PARA_LEV5: 904 case WID_PARA_LEV6: 905 case WID_PARA_LEV7: 906 case WID_PARA_LEV8: 907 case WID_PARA_LEV9: 908 case WID_PARA_LEV10: 909 { 910 bForm = sal_True; 911 // in sdbcx::Index Label 1 begins at Pos 2 otherwise at Pos 1 912 const sal_uInt16 nLPos = rTOXBase.GetType() == TOX_INDEX ? 2 : 1; 913 String aString; 914 SwStyleNameMapper::FillUIName( lcl_AnyToString(rValue), 915 aString, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, sal_True); 916 aForm.SetTemplate(nLPos + pEntry->nWID - WID_PARA_LEV1, aString ); 917 } 918 break; 919 default: 920 //this is for items only 921 if (WID_PRIMARY_KEY > pEntry->nWID) 922 { 923 const SwAttrSet& rSet = 924 m_pImpl->m_pDoc->GetTOXBaseAttrSet(rTOXBase); 925 SfxItemSet aAttrSet(rSet); 926 m_pImpl->m_rPropSet.setPropertyValue( 927 rPropertyName, rValue, aAttrSet); 928 929 const SwSectionFmts& rSects = m_pImpl->m_pDoc->GetSections(); 930 for (sal_uInt16 i = 0; i < rSects.Count(); i++) 931 { 932 const SwSectionFmt* pTmpFmt = rSects[ i ]; 933 if (pTmpFmt == pSectionFmt) 934 { 935 SwSectionData tmpData( 936 static_cast<SwTOXBaseSection&>(rTOXBase)); 937 m_pImpl->m_pDoc->UpdateSection(i, tmpData, & aAttrSet); 938 break; 939 } 940 } 941 } 942 } 943 rTOXBase.SetCreate(nCreate); 944 rTOXBase.SetOLEOptions(nOLEOptions); 945 if (rTOXBase.GetTOXType()->GetType() == TOX_INDEX) 946 { 947 rTOXBase.SetOptions(nTOIOptions); 948 } 949 if (bForm) 950 { 951 rTOXBase.SetTOXForm(aForm); 952 } 953 } 954 955 /*-- 14.12.98 09:35:05--------------------------------------------------- 956 957 -----------------------------------------------------------------------*/ 958 uno::Any SAL_CALL 959 SwXDocumentIndex::getPropertyValue(const OUString& rPropertyName) 960 throw (beans::UnknownPropertyException, lang::WrappedTargetException, 961 uno::RuntimeException) 962 { 963 vos::OGuard aGuard(Application::GetSolarMutex()); 964 965 uno::Any aRet; 966 SfxItemPropertySimpleEntry const*const pEntry = 967 m_pImpl->m_rPropSet.getPropertyMap()->getByName(rPropertyName); 968 if (!pEntry) 969 { 970 throw beans::UnknownPropertyException( 971 OUString(RTL_CONSTASCII_USTRINGPARAM("Unknown property: ")) 972 + rPropertyName, 973 static_cast< cppu::OWeakObject * >(this)); 974 } 975 976 SwSectionFmt *const pSectionFmt( m_pImpl->GetSectionFmt() ); 977 SwTOXBase* pTOXBase = 0; 978 if (pSectionFmt) 979 { 980 pTOXBase = static_cast<SwTOXBaseSection*>(pSectionFmt->GetSection()); 981 } 982 else if (m_pImpl->m_bIsDescriptor) 983 { 984 pTOXBase = &m_pImpl->m_pProps->GetTOXBase(); 985 } 986 if(pTOXBase) 987 { 988 const sal_uInt16 nCreate = pTOXBase->GetCreateType(); 989 const sal_uInt16 nOLEOptions = pTOXBase->GetOLEOptions(); 990 const sal_uInt16 nTOIOptions = 991 (pTOXBase->GetTOXType()->GetType() == TOX_INDEX) 992 ? pTOXBase->GetOptions() 993 : 0U; 994 const SwForm& rForm = pTOXBase->GetTOXForm(); 995 switch(pEntry->nWID) 996 { 997 case WID_IDX_CONTENT_SECTION: 998 case WID_IDX_HEADER_SECTION : 999 if(WID_IDX_CONTENT_SECTION == pEntry->nWID) 1000 { 1001 const uno::Reference <text::XTextSection> xContentSect = 1002 SwXTextSection::CreateXTextSection( pSectionFmt ); 1003 aRet <<= xContentSect; 1004 } 1005 else 1006 { 1007 SwSections aSectArr; 1008 pSectionFmt->GetChildSections(aSectArr, 1009 SORTSECT_NOT, sal_False); 1010 for(sal_uInt16 i = 0; i < aSectArr.Count(); i++) 1011 { 1012 SwSection* pSect = aSectArr[i]; 1013 if(pSect->GetType() == TOX_HEADER_SECTION) 1014 { 1015 const uno::Reference <text::XTextSection> xHeader = 1016 SwXTextSection::CreateXTextSection( 1017 pSect->GetFmt() ); 1018 aRet <<= xHeader; 1019 break; 1020 } 1021 } 1022 } 1023 break; 1024 case WID_IDX_TITLE : 1025 { 1026 OUString uRet(pTOXBase->GetTitle()); 1027 aRet <<= uRet; 1028 break; 1029 } 1030 case WID_IDX_NAME: 1031 aRet <<= OUString(pTOXBase->GetTOXName()); 1032 break; 1033 case WID_USER_IDX_NAME: 1034 { 1035 OUString sTmp; 1036 if (!m_pImpl->m_bIsDescriptor) 1037 { 1038 sTmp = pTOXBase->GetTOXType()->GetTypeName(); 1039 } 1040 else 1041 { 1042 sTmp = m_pImpl->m_pProps->GetTypeName(); 1043 } 1044 //I18N 1045 lcl_ConvertTOUNameToProgrammaticName(sTmp); 1046 aRet <<= sTmp; 1047 } 1048 break; 1049 case WID_IDX_LOCALE: 1050 aRet <<= SvxCreateLocale(pTOXBase->GetLanguage()); 1051 break; 1052 case WID_IDX_SORT_ALGORITHM: 1053 aRet <<= OUString(pTOXBase->GetSortAlgorithm()); 1054 break; 1055 case WID_LEVEL : 1056 aRet <<= static_cast<sal_Int16>(pTOXBase->GetLevel()); 1057 break; 1058 case WID_CREATE_FROM_MARKS: 1059 lcl_BitMaskToAny(aRet, nCreate, nsSwTOXElement::TOX_MARK); 1060 break; 1061 case WID_CREATE_FROM_OUTLINE: 1062 lcl_BitMaskToAny(aRet, nCreate, 1063 nsSwTOXElement::TOX_OUTLINELEVEL); 1064 break; 1065 case WID_CREATE_FROM_CHAPTER: 1066 { 1067 const sal_Bool bRet = pTOXBase->IsFromChapter(); 1068 aRet <<= bRet; 1069 } 1070 break; 1071 case WID_CREATE_FROM_LABELS: 1072 { 1073 const sal_Bool bRet = ! pTOXBase->IsFromObjectNames(); 1074 aRet <<= bRet; 1075 } 1076 break; 1077 case WID_PROTECTED: 1078 { 1079 const sal_Bool bRet = pTOXBase->IsProtected(); 1080 aRet <<= bRet; 1081 } 1082 break; 1083 case WID_USE_ALPHABETICAL_SEPARATORS: 1084 lcl_BitMaskToAny(aRet, nTOIOptions, 1085 nsSwTOIOptions::TOI_ALPHA_DELIMITTER); 1086 break; 1087 case WID_USE_KEY_AS_ENTRY: 1088 lcl_BitMaskToAny(aRet, nTOIOptions, 1089 nsSwTOIOptions::TOI_KEY_AS_ENTRY); 1090 break; 1091 case WID_USE_COMBINED_ENTRIES: 1092 lcl_BitMaskToAny(aRet, nTOIOptions, 1093 nsSwTOIOptions::TOI_SAME_ENTRY); 1094 break; 1095 case WID_IS_CASE_SENSITIVE: 1096 lcl_BitMaskToAny(aRet, nTOIOptions, 1097 nsSwTOIOptions::TOI_CASE_SENSITIVE); 1098 break; 1099 case WID_USE_P_P: 1100 lcl_BitMaskToAny(aRet, nTOIOptions, nsSwTOIOptions::TOI_FF); 1101 break; 1102 case WID_USE_DASH: 1103 lcl_BitMaskToAny(aRet, nTOIOptions, nsSwTOIOptions::TOI_DASH); 1104 break; 1105 case WID_USE_UPPER_CASE: 1106 lcl_BitMaskToAny(aRet, nTOIOptions, 1107 nsSwTOIOptions::TOI_INITIAL_CAPS); 1108 break; 1109 case WID_IS_COMMA_SEPARATED: 1110 { 1111 const sal_Bool bRet = rForm.IsCommaSeparated(); 1112 aRet <<= bRet; 1113 } 1114 break; 1115 case WID_LABEL_CATEGORY: 1116 { 1117 // convert internal UI name to 1118 // file-format/API/external programmatic english name 1119 // before usage 1120 String aName( SwStyleNameMapper::GetSpecialExtraProgName( 1121 pTOXBase->GetSequenceName() ) ); 1122 aRet <<= OUString( aName ); 1123 } 1124 break; 1125 case WID_LABEL_DISPLAY_TYPE: 1126 { 1127 sal_Int16 nSet = text::ReferenceFieldPart::TEXT; 1128 switch (pTOXBase->GetCaptionDisplay()) 1129 { 1130 case CAPTION_COMPLETE: 1131 nSet = text::ReferenceFieldPart::TEXT; 1132 break; 1133 case CAPTION_NUMBER: 1134 nSet = text::ReferenceFieldPart::CATEGORY_AND_NUMBER; 1135 break; 1136 case CAPTION_TEXT: 1137 nSet = text::ReferenceFieldPart::ONLY_CAPTION; 1138 break; 1139 } 1140 aRet <<= nSet; 1141 } 1142 break; 1143 case WID_USE_LEVEL_FROM_SOURCE: 1144 { 1145 const sal_Bool bRet = pTOXBase->IsLevelFromChapter(); 1146 aRet <<= bRet; 1147 } 1148 break; 1149 case WID_LEVEL_FORMAT: 1150 { 1151 uno::Reference< container::XIndexReplace > xTokenAccess( 1152 m_pImpl->m_wTokenAccess); 1153 if (!xTokenAccess.is()) 1154 { 1155 xTokenAccess = new TokenAccess_Impl(*this); 1156 m_pImpl->m_wTokenAccess = xTokenAccess; 1157 } 1158 aRet <<= xTokenAccess; 1159 } 1160 break; 1161 case WID_LEVEL_PARAGRAPH_STYLES: 1162 { 1163 uno::Reference< container::XIndexReplace > xStyleAccess( 1164 m_pImpl->m_wStyleAccess); 1165 if (!xStyleAccess.is()) 1166 { 1167 xStyleAccess = new StyleAccess_Impl(*this); 1168 m_pImpl->m_wStyleAccess = xStyleAccess; 1169 } 1170 aRet <<= xStyleAccess; 1171 } 1172 break; 1173 case WID_MAIN_ENTRY_CHARACTER_STYLE_NAME: 1174 { 1175 String aString; 1176 SwStyleNameMapper::FillProgName( 1177 pTOXBase->GetMainEntryCharStyle(), 1178 aString, 1179 nsSwGetPoolIdFromName::GET_POOLID_CHRFMT, 1180 sal_True); 1181 aRet <<= OUString( aString ); 1182 } 1183 break; 1184 case WID_CREATE_FROM_TABLES: 1185 lcl_BitMaskToAny(aRet, nCreate, nsSwTOXElement::TOX_TABLE); 1186 break; 1187 case WID_CREATE_FROM_TEXT_FRAMES: 1188 lcl_BitMaskToAny(aRet, nCreate, nsSwTOXElement::TOX_FRAME); 1189 break; 1190 case WID_CREATE_FROM_GRAPHIC_OBJECTS: 1191 lcl_BitMaskToAny(aRet, nCreate, nsSwTOXElement::TOX_GRAPHIC); 1192 break; 1193 case WID_CREATE_FROM_EMBEDDED_OBJECTS: 1194 lcl_BitMaskToAny(aRet, nCreate, nsSwTOXElement::TOX_OLE); 1195 break; 1196 case WID_CREATE_FROM_STAR_MATH: 1197 lcl_BitMaskToAny(aRet, nOLEOptions, nsSwTOOElements::TOO_MATH); 1198 break; 1199 case WID_CREATE_FROM_STAR_CHART: 1200 lcl_BitMaskToAny(aRet, nOLEOptions, nsSwTOOElements::TOO_CHART); 1201 break; 1202 case WID_CREATE_FROM_STAR_CALC: 1203 lcl_BitMaskToAny(aRet, nOLEOptions, nsSwTOOElements::TOO_CALC); 1204 break; 1205 case WID_CREATE_FROM_STAR_DRAW: 1206 lcl_BitMaskToAny(aRet, nOLEOptions, 1207 nsSwTOOElements::TOO_DRAW_IMPRESS); 1208 break; 1209 case WID_CREATE_FROM_OTHER_EMBEDDED_OBJECTS: 1210 lcl_BitMaskToAny(aRet, nOLEOptions, nsSwTOOElements::TOO_OTHER); 1211 break; 1212 case WID_CREATE_FROM_PARAGRAPH_STYLES: 1213 lcl_BitMaskToAny(aRet, nCreate, nsSwTOXElement::TOX_TEMPLATE); 1214 break; 1215 case WID_PARA_HEAD: 1216 { 1217 //Header steht an Pos 0 1218 String aString; 1219 SwStyleNameMapper::FillProgName(rForm.GetTemplate( 0 ), aString, 1220 nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, sal_True ); 1221 aRet <<= OUString( aString ); 1222 } 1223 break; 1224 case WID_PARA_SEP: 1225 { 1226 String aString; 1227 SwStyleNameMapper::FillProgName( 1228 rForm.GetTemplate( 1 ), 1229 aString, 1230 nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, 1231 sal_True); 1232 aRet <<= OUString( aString ); 1233 } 1234 break; 1235 case WID_PARA_LEV1: 1236 case WID_PARA_LEV2: 1237 case WID_PARA_LEV3: 1238 case WID_PARA_LEV4: 1239 case WID_PARA_LEV5: 1240 case WID_PARA_LEV6: 1241 case WID_PARA_LEV7: 1242 case WID_PARA_LEV8: 1243 case WID_PARA_LEV9: 1244 case WID_PARA_LEV10: 1245 { 1246 // in sdbcx::Index Label 1 begins at Pos 2 otherwise at Pos 1 1247 sal_uInt16 nLPos = pTOXBase->GetType() == TOX_INDEX ? 2 : 1; 1248 String aString; 1249 SwStyleNameMapper::FillProgName( 1250 rForm.GetTemplate(nLPos + pEntry->nWID - WID_PARA_LEV1), 1251 aString, 1252 nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, 1253 sal_True); 1254 aRet <<= OUString( aString ); 1255 } 1256 break; 1257 case WID_IS_RELATIVE_TABSTOPS: 1258 { 1259 const sal_Bool bRet = rForm.IsRelTabPos(); 1260 aRet <<= bRet; 1261 } 1262 break; 1263 case WID_INDEX_MARKS: 1264 { 1265 SwTOXMarks aMarks; 1266 const SwTOXType* pType = pTOXBase->GetTOXType(); 1267 SwTOXMark::InsertTOXMarks( aMarks, *pType ); 1268 uno::Sequence< uno::Reference<text::XDocumentIndexMark> > aXMarks(aMarks.Count()); 1269 uno::Reference<text::XDocumentIndexMark>* pxMarks = aXMarks.getArray(); 1270 for(sal_uInt16 i = 0; i < aMarks.Count(); i++) 1271 { 1272 SwTOXMark* pMark = aMarks.GetObject(i); 1273 pxMarks[i] = SwXDocumentIndexMark::CreateXDocumentIndexMark( 1274 *m_pImpl->m_pDoc, 1275 *const_cast<SwTOXType*>(pType), *pMark); 1276 } 1277 aRet <<= aXMarks; 1278 } 1279 break; 1280 default: 1281 //this is for items only 1282 if(WID_PRIMARY_KEY > pEntry->nWID) 1283 { 1284 const SwAttrSet& rSet = 1285 m_pImpl->m_pDoc->GetTOXBaseAttrSet(*pTOXBase); 1286 aRet = m_pImpl->m_rPropSet.getPropertyValue( 1287 rPropertyName, rSet); 1288 } 1289 } 1290 } 1291 return aRet; 1292 } 1293 1294 /*-- 14.12.98 09:35:06--------------------------------------------------- 1295 1296 -----------------------------------------------------------------------*/ 1297 void SAL_CALL 1298 SwXDocumentIndex::addPropertyChangeListener( 1299 const ::rtl::OUString& /*rPropertyName*/, 1300 const uno::Reference< beans::XPropertyChangeListener >& /*xListener*/) 1301 throw (beans::UnknownPropertyException, lang::WrappedTargetException, 1302 uno::RuntimeException) 1303 { 1304 OSL_ENSURE(false, 1305 "SwXDocumentIndex::addPropertyChangeListener(): not implemented"); 1306 } 1307 1308 void SAL_CALL 1309 SwXDocumentIndex::removePropertyChangeListener( 1310 const ::rtl::OUString& /*rPropertyName*/, 1311 const uno::Reference< beans::XPropertyChangeListener >& /*xListener*/) 1312 throw (beans::UnknownPropertyException, lang::WrappedTargetException, 1313 uno::RuntimeException) 1314 { 1315 OSL_ENSURE(false, 1316 "SwXDocumentIndex::removePropertyChangeListener(): not implemented"); 1317 } 1318 1319 void SAL_CALL 1320 SwXDocumentIndex::addVetoableChangeListener( 1321 const ::rtl::OUString& /*rPropertyName*/, 1322 const uno::Reference< beans::XVetoableChangeListener >& /*xListener*/) 1323 throw (beans::UnknownPropertyException, lang::WrappedTargetException, 1324 uno::RuntimeException) 1325 { 1326 OSL_ENSURE(false, 1327 "SwXDocumentIndex::addVetoableChangeListener(): not implemented"); 1328 } 1329 1330 void SAL_CALL 1331 SwXDocumentIndex::removeVetoableChangeListener( 1332 const ::rtl::OUString& /*rPropertyName*/, 1333 const uno::Reference< beans::XVetoableChangeListener >& /*xListener*/) 1334 throw (beans::UnknownPropertyException, lang::WrappedTargetException, 1335 uno::RuntimeException) 1336 { 1337 OSL_ENSURE(false, 1338 "SwXDocumentIndex::removeVetoableChangeListener(): not implemented"); 1339 } 1340 1341 /* -----------------18.02.99 13:39------------------- 1342 * 1343 * --------------------------------------------------*/ 1344 void SAL_CALL 1345 SwXDocumentIndex::attach(const uno::Reference< text::XTextRange > & xTextRange) 1346 throw (lang::IllegalArgumentException, uno::RuntimeException) 1347 { 1348 vos::OGuard aGuard(Application::GetSolarMutex()); 1349 1350 if (!m_pImpl->m_bIsDescriptor) 1351 { 1352 throw uno::RuntimeException(); 1353 } 1354 const uno::Reference<XUnoTunnel> xRangeTunnel( xTextRange, uno::UNO_QUERY); 1355 SwXTextRange *const pRange = 1356 ::sw::UnoTunnelGetImplementation<SwXTextRange>(xRangeTunnel); 1357 OTextCursorHelper *const pCursor = 1358 ::sw::UnoTunnelGetImplementation<OTextCursorHelper>(xRangeTunnel); 1359 1360 SwDoc *const pDoc = 1361 (pRange) ? pRange->GetDoc() : ((pCursor) ? pCursor->GetDoc() : 0); 1362 if (!pDoc) 1363 { 1364 throw lang::IllegalArgumentException(); 1365 } 1366 1367 SwUnoInternalPaM aPam(*pDoc); 1368 //das muss jetzt sal_True liefern 1369 ::sw::XTextRangeToSwPaM(aPam, xTextRange); 1370 1371 const SwTOXBase* pOld = pDoc->GetCurTOX( *aPam.Start() ); 1372 if (pOld) 1373 { 1374 throw lang::IllegalArgumentException(); 1375 } 1376 1377 UnoActionContext aAction(pDoc); 1378 if (aPam.HasMark()) 1379 { 1380 pDoc->DeleteAndJoin(aPam); 1381 } 1382 1383 SwTOXBase & rTOXBase = m_pImpl->m_pProps->GetTOXBase(); 1384 SwTOXType const*const pTOXType = rTOXBase.GetTOXType(); 1385 if ((TOX_USER == pTOXType->GetType()) && 1386 !m_pImpl->m_pProps->GetTypeName().equals(pTOXType->GetTypeName())) 1387 { 1388 lcl_ReAssignTOXType(pDoc, rTOXBase, m_pImpl->m_pProps->GetTypeName()); 1389 } 1390 //TODO: apply Section attributes (columns and background) 1391 SwTOXBaseSection const*const pTOX = 1392 pDoc->InsertTableOf( *aPam.GetPoint(), rTOXBase, 0, sal_False ); 1393 1394 pDoc->SetTOXBaseName(*pTOX, m_pImpl->m_pProps->GetTOXBase().GetTOXName()); 1395 1396 // update page numbers 1397 pTOX->GetFmt()->Add(m_pImpl.get()); 1398 pTOX->GetFmt()->SetXObject(static_cast< ::cppu::OWeakObject*>(this)); 1399 const_cast<SwTOXBaseSection*>(pTOX)->UpdatePageNum(); 1400 1401 m_pImpl->m_pProps.reset(); 1402 m_pImpl->m_pDoc = pDoc; 1403 m_pImpl->m_bIsDescriptor = sal_False; 1404 } 1405 1406 /*-- 15.01.99 14:23:56--------------------------------------------------- 1407 1408 -----------------------------------------------------------------------*/ 1409 uno::Reference< text::XTextRange > SAL_CALL 1410 SwXDocumentIndex::getAnchor() throw (uno::RuntimeException) 1411 { 1412 vos::OGuard aGuard(Application::GetSolarMutex()); 1413 1414 SwSectionFmt *const pSectionFmt( m_pImpl->GetSectionFmt() ); 1415 if (!pSectionFmt) 1416 { 1417 throw uno::RuntimeException(); 1418 } 1419 1420 uno::Reference< text::XTextRange > xRet; 1421 SwNodeIndex const*const pIdx( pSectionFmt->GetCntnt().GetCntntIdx() ); 1422 if (pIdx && pIdx->GetNode().GetNodes().IsDocNodes()) 1423 { 1424 SwPaM aPaM(*pIdx); 1425 aPaM.Move( fnMoveForward, fnGoCntnt ); 1426 aPaM.SetMark(); 1427 aPaM.GetPoint()->nNode = *pIdx->GetNode().EndOfSectionNode(); 1428 aPaM.Move( fnMoveBackward, fnGoCntnt ); 1429 xRet = SwXTextRange::CreateXTextRange(*pSectionFmt->GetDoc(), 1430 *aPaM.GetMark(), aPaM.GetPoint()); 1431 } 1432 return xRet; 1433 } 1434 1435 /*-- 15.01.99 15:46:48--------------------------------------------------- 1436 1437 -----------------------------------------------------------------------*/ 1438 void lcl_RemoveChildSections(SwSectionFmt& rParentFmt) 1439 { 1440 SwSections aTmpArr; 1441 SwDoc *const pDoc = rParentFmt.GetDoc(); 1442 const sal_uInt16 nCnt = rParentFmt.GetChildSections(aTmpArr, SORTSECT_POS); 1443 if( nCnt ) 1444 { 1445 for( sal_uInt16 n = 0; n < nCnt; ++n ) 1446 { 1447 if( aTmpArr[n]->GetFmt()->IsInNodesArr() ) 1448 { 1449 SwSectionFmt* pFmt = aTmpArr[n]->GetFmt(); 1450 lcl_RemoveChildSections(*pFmt); 1451 pDoc->DelSectionFmt( pFmt ); 1452 } 1453 } 1454 } 1455 } 1456 1457 void SAL_CALL SwXDocumentIndex::dispose() throw (uno::RuntimeException) 1458 { 1459 vos::OGuard aGuard(Application::GetSolarMutex()); 1460 1461 SwSectionFmt *const pSectionFmt( m_pImpl->GetSectionFmt() ); 1462 if (pSectionFmt) 1463 { 1464 pSectionFmt->GetDoc()->DeleteTOX( 1465 *static_cast<SwTOXBaseSection*>(pSectionFmt->GetSection()), 1466 sal_True); 1467 } 1468 } 1469 1470 /*-- 15.01.99 15:46:49--------------------------------------------------- 1471 1472 -----------------------------------------------------------------------*/ 1473 void SAL_CALL 1474 SwXDocumentIndex::addEventListener( 1475 const uno::Reference< lang::XEventListener > & xListener) 1476 throw (uno::RuntimeException) 1477 { 1478 vos::OGuard g(Application::GetSolarMutex()); 1479 1480 if (!m_pImpl->GetRegisteredIn()) 1481 { 1482 throw uno::RuntimeException(); 1483 } 1484 m_pImpl->m_ListenerContainer.AddListener(xListener); 1485 } 1486 /*-- 15.01.99 15:46:54--------------------------------------------------- 1487 1488 -----------------------------------------------------------------------*/ 1489 void SAL_CALL 1490 SwXDocumentIndex::removeEventListener( 1491 const uno::Reference< lang::XEventListener > & xListener) 1492 throw (uno::RuntimeException) 1493 { 1494 vos::OGuard g(Application::GetSolarMutex()); 1495 1496 if (!m_pImpl->GetRegisteredIn() || 1497 !m_pImpl->m_ListenerContainer.RemoveListener(xListener)) 1498 { 1499 throw uno::RuntimeException(); 1500 } 1501 } 1502 1503 /* -----------------30.07.99 11:28------------------- 1504 1505 --------------------------------------------------*/ 1506 OUString SAL_CALL SwXDocumentIndex::getName() throw (uno::RuntimeException) 1507 { 1508 vos::OGuard g(Application::GetSolarMutex()); 1509 1510 OUString uRet; 1511 SwSectionFmt *const pSectionFmt( m_pImpl->GetSectionFmt() ); 1512 if (m_pImpl->m_bIsDescriptor) 1513 { 1514 uRet = OUString(m_pImpl->m_pProps->GetTOXBase().GetTOXName()); 1515 } 1516 else if(pSectionFmt) 1517 { 1518 uRet = OUString(pSectionFmt->GetSection()->GetSectionName()); 1519 } 1520 else 1521 { 1522 throw uno::RuntimeException(); 1523 } 1524 return uRet; 1525 } 1526 /* -----------------30.07.99 11:28------------------- 1527 1528 --------------------------------------------------*/ 1529 void SAL_CALL 1530 SwXDocumentIndex::setName(const OUString& rName) throw (uno::RuntimeException) 1531 { 1532 vos::OGuard g(Application::GetSolarMutex()); 1533 1534 if (!rName.getLength()) 1535 { 1536 throw uno::RuntimeException(); 1537 } 1538 1539 SwSectionFmt *const pSectionFmt( m_pImpl->GetSectionFmt() ); 1540 if (m_pImpl->m_bIsDescriptor) 1541 { 1542 m_pImpl->m_pProps->GetTOXBase().SetTOXName(rName); 1543 } 1544 else if (pSectionFmt) 1545 { 1546 const bool bSuccess = pSectionFmt->GetDoc()->SetTOXBaseName( 1547 *static_cast<SwTOXBaseSection*>(pSectionFmt->GetSection()), rName); 1548 if (!bSuccess) 1549 { 1550 throw uno::RuntimeException(); 1551 } 1552 } 1553 else 1554 { 1555 throw uno::RuntimeException(); 1556 } 1557 } 1558 1559 // MetadatableMixin 1560 ::sfx2::Metadatable* SwXDocumentIndex::GetCoreObject() 1561 { 1562 SwSectionFmt *const pSectionFmt( m_pImpl->GetSectionFmt() ); 1563 return pSectionFmt; 1564 } 1565 1566 uno::Reference<frame::XModel> SwXDocumentIndex::GetModel() 1567 { 1568 SwSectionFmt *const pSectionFmt( m_pImpl->GetSectionFmt() ); 1569 if (pSectionFmt) 1570 { 1571 SwDocShell const*const pShell( pSectionFmt->GetDoc()->GetDocShell() ); 1572 return (pShell) ? pShell->GetModel() : 0; 1573 } 1574 return 0; 1575 } 1576 1577 1578 /****************************************************************** 1579 * SwXDocumentIndexMark 1580 ******************************************************************/ 1581 /* -----------------21.04.99 09:36------------------- 1582 * 1583 * --------------------------------------------------*/ 1584 static sal_uInt16 1585 lcl_TypeToPropertyMap_Mark(const TOXTypes eType) 1586 { 1587 switch (eType) 1588 { 1589 case TOX_INDEX: return PROPERTY_MAP_INDEX_MARK; 1590 case TOX_CONTENT: return PROPERTY_MAP_CNTIDX_MARK; 1591 //case TOX_USER: 1592 default: 1593 return PROPERTY_MAP_USER_MARK; 1594 } 1595 } 1596 1597 class SwXDocumentIndexMark::Impl 1598 : public SwClient 1599 { 1600 private: 1601 bool m_bInReplaceMark; 1602 1603 public: 1604 1605 SfxItemPropertySet const& m_rPropSet; 1606 const TOXTypes m_eTOXType; 1607 SwEventListenerContainer m_ListenerContainer; 1608 bool m_bIsDescriptor; 1609 SwDepend m_TypeDepend; 1610 const SwTOXMark * m_pTOXMark; 1611 SwDoc * m_pDoc; 1612 1613 sal_Bool m_bMainEntry; 1614 sal_uInt16 m_nLevel; 1615 OUString m_sAltText; 1616 OUString m_sPrimaryKey; 1617 OUString m_sSecondaryKey; 1618 OUString m_sTextReading; 1619 OUString m_sPrimaryKeyReading; 1620 OUString m_sSecondaryKeyReading; 1621 OUString m_sUserIndexName; 1622 1623 Impl( SwXDocumentIndexMark & rThis, 1624 SwDoc *const pDoc, 1625 const enum TOXTypes eType, 1626 SwTOXType *const pType, SwTOXMark const*const pMark) 1627 : SwClient(const_cast<SwTOXMark*>(pMark)) 1628 , m_bInReplaceMark(false) 1629 , m_rPropSet( 1630 *aSwMapProvider.GetPropertySet(lcl_TypeToPropertyMap_Mark(eType))) 1631 , m_eTOXType(eType) 1632 , m_ListenerContainer(static_cast< ::cppu::OWeakObject* >(&rThis)) 1633 // #i112513#: unxsols4 (Sun C++ 5.9 SunOS_sparc) generates wrong code for this 1634 // , m_bIsDescriptor(0 == pMark) 1635 , m_bIsDescriptor((0 == pMark) ? true : false) 1636 , m_TypeDepend(this, pType) 1637 , m_pTOXMark(pMark) 1638 , m_pDoc(pDoc) 1639 , m_bMainEntry(sal_False) 1640 , m_nLevel(0) 1641 { 1642 } 1643 1644 SwTOXType * GetTOXType() const { 1645 return static_cast<SwTOXType*>( 1646 const_cast<SwModify *>(m_TypeDepend.GetRegisteredIn())); 1647 } 1648 1649 void DeleteTOXMark() 1650 { 1651 m_pDoc->DeleteTOXMark(m_pTOXMark); // calls Invalidate() via Modify! 1652 m_pTOXMark = 0; 1653 } 1654 1655 void InsertTOXMark(SwTOXType & rTOXType, SwTOXMark & rMark, SwPaM & rPam, 1656 SwXTextCursor const*const pTextCursor); 1657 1658 void ReplaceTOXMark(SwTOXType & rTOXType, SwTOXMark & rMark, SwPaM & rPam) 1659 { 1660 m_bInReplaceMark = true; 1661 DeleteTOXMark(); 1662 m_bInReplaceMark = false; 1663 try { 1664 InsertTOXMark(rTOXType, rMark, rPam, 0); 1665 } catch (...) { 1666 OSL_ENSURE(false, "ReplaceTOXMark() failed!"); 1667 m_ListenerContainer.Disposing(); 1668 throw; 1669 } 1670 } 1671 1672 void Invalidate(); 1673 protected: 1674 // SwClient 1675 virtual void Modify(const SfxPoolItem *pOld, const SfxPoolItem *pNew); 1676 }; 1677 1678 /* -----------------------------16.10.00 11:24-------------------------------- 1679 1680 ---------------------------------------------------------------------------*/ 1681 void SwXDocumentIndexMark::Impl::Invalidate() 1682 { 1683 if (GetRegisteredIn()) 1684 { 1685 const_cast<SwModify*>(GetRegisteredIn())->Remove(this); 1686 if (m_TypeDepend.GetRegisteredIn()) 1687 { 1688 const_cast<SwModify*>(m_TypeDepend.GetRegisteredIn())->Remove( 1689 &m_TypeDepend); 1690 } 1691 } 1692 if (!m_bInReplaceMark) // #i109983# only dispose on delete, not on replace! 1693 { 1694 m_ListenerContainer.Disposing(); 1695 } 1696 m_pDoc = 0; 1697 m_pTOXMark = 0; 1698 } 1699 1700 /*-- 14.12.98 10:25:47--------------------------------------------------- 1701 1702 -----------------------------------------------------------------------*/ 1703 void SwXDocumentIndexMark::Impl::Modify(const SfxPoolItem *pOld, const SfxPoolItem *pNew) 1704 { 1705 ClientModify(this, pOld, pNew); 1706 1707 if (!GetRegisteredIn()) // removed => dispose 1708 { 1709 Invalidate(); 1710 } 1711 } 1712 1713 /*-- 14.12.98 10:25:43--------------------------------------------------- 1714 1715 -----------------------------------------------------------------------*/ 1716 SwXDocumentIndexMark::SwXDocumentIndexMark(const TOXTypes eToxType) 1717 : m_pImpl( new SwXDocumentIndexMark::Impl(*this, 0, eToxType, 0, 0) ) 1718 { 1719 } 1720 /*-- 14.12.98 10:25:44--------------------------------------------------- 1721 1722 -----------------------------------------------------------------------*/ 1723 SwXDocumentIndexMark::SwXDocumentIndexMark(SwDoc & rDoc, 1724 SwTOXType & rType, SwTOXMark & rMark) 1725 : m_pImpl( new SwXDocumentIndexMark::Impl(*this, &rDoc, rType.GetType(), 1726 &rType, &rMark) ) 1727 { 1728 } 1729 /*-- 14.12.98 10:25:44--------------------------------------------------- 1730 1731 -----------------------------------------------------------------------*/ 1732 SwXDocumentIndexMark::~SwXDocumentIndexMark() 1733 { 1734 } 1735 1736 uno::Reference<text::XDocumentIndexMark> 1737 SwXDocumentIndexMark::CreateXDocumentIndexMark( 1738 SwDoc & rDoc, SwTOXType & rType, SwTOXMark & rMark) 1739 { 1740 // re-use existing SwXDocumentIndexMark 1741 // NB: xmloff depends on this caching to generate ID from the address! 1742 // #i105557#: do not iterate over the registered clients: race condition 1743 uno::Reference< text::XDocumentIndexMark > xTOXMark(rMark.GetXTOXMark()); 1744 if (!xTOXMark.is()) 1745 { 1746 SwXDocumentIndexMark *const pNew = 1747 new SwXDocumentIndexMark(rDoc, rType, rMark); 1748 xTOXMark.set(pNew); 1749 rMark.SetXTOXMark(xTOXMark); 1750 } 1751 return xTOXMark; 1752 } 1753 1754 /* -----------------------------10.03.00 18:02-------------------------------- 1755 1756 ---------------------------------------------------------------------------*/ 1757 const uno::Sequence< sal_Int8 > & SwXDocumentIndexMark::getUnoTunnelId() 1758 { 1759 static uno::Sequence< sal_Int8 > aSeq = ::CreateUnoTunnelId(); 1760 return aSeq; 1761 } 1762 /* -----------------------------10.03.00 18:04-------------------------------- 1763 1764 ---------------------------------------------------------------------------*/ 1765 sal_Int64 SAL_CALL 1766 SwXDocumentIndexMark::getSomething(const uno::Sequence< sal_Int8 >& rId) 1767 throw (uno::RuntimeException) 1768 { 1769 return ::sw::UnoTunnelImpl<SwXDocumentIndexMark>(rId, this); 1770 } 1771 1772 static const sal_Char cBaseMark[] = "com.sun.star.text.BaseIndexMark"; 1773 static const sal_Char cContentMark[] = "com.sun.star.text.ContentIndexMark"; 1774 static const sal_Char cIdxMark[] = "com.sun.star.text.DocumentIndexMark"; 1775 static const sal_Char cIdxMarkAsian[] = "com.sun.star.text.DocumentIndexMarkAsian"; 1776 static const sal_Char cUserMark[] = "com.sun.star.text.UserIndexMark"; 1777 static const sal_Char cTextContent[] = "com.sun.star.text.TextContent"; 1778 1779 /* -----------------------------06.04.00 15:07-------------------------------- 1780 1781 ---------------------------------------------------------------------------*/ 1782 OUString SAL_CALL 1783 SwXDocumentIndexMark::getImplementationName() throw (uno::RuntimeException) 1784 { 1785 return C2U("SwXDocumentIndexMark"); 1786 } 1787 /* -----------------------------06.04.00 15:07-------------------------------- 1788 1789 ---------------------------------------------------------------------------*/ 1790 sal_Bool SAL_CALL 1791 SwXDocumentIndexMark::supportsService(const OUString& rServiceName) 1792 throw (uno::RuntimeException) 1793 { 1794 vos::OGuard g(Application::GetSolarMutex()); 1795 1796 return rServiceName.equalsAscii(cBaseMark) 1797 || rServiceName.equalsAscii(cTextContent) 1798 || ((m_pImpl->m_eTOXType == TOX_USER) 1799 && rServiceName.equalsAscii(cUserMark)) 1800 || ((m_pImpl->m_eTOXType == TOX_CONTENT) 1801 && rServiceName.equalsAscii(cContentMark)) 1802 || ((m_pImpl->m_eTOXType == TOX_INDEX) 1803 && rServiceName.equalsAscii(cIdxMark)) 1804 || ((m_pImpl->m_eTOXType == TOX_INDEX) 1805 && rServiceName.equalsAscii(cIdxMarkAsian)); 1806 } 1807 /* -----------------------------06.04.00 15:07-------------------------------- 1808 1809 ---------------------------------------------------------------------------*/ 1810 uno::Sequence< OUString > SAL_CALL 1811 SwXDocumentIndexMark::getSupportedServiceNames() throw (uno::RuntimeException) 1812 { 1813 vos::OGuard g(Application::GetSolarMutex()); 1814 1815 const sal_Int32 nCnt = (m_pImpl->m_eTOXType == TOX_INDEX) ? 4 : 3; 1816 uno::Sequence< OUString > aRet(nCnt); 1817 OUString* pArray = aRet.getArray(); 1818 pArray[0] = C2U(cBaseMark); 1819 pArray[1] = C2U(cTextContent); 1820 switch (m_pImpl->m_eTOXType) 1821 { 1822 case TOX_USER: 1823 pArray[2] = C2U(cUserMark); 1824 break; 1825 case TOX_CONTENT: 1826 pArray[2] = C2U(cContentMark); 1827 break; 1828 case TOX_INDEX: 1829 pArray[2] = C2U(cIdxMark); 1830 pArray[3] = C2U(cIdxMarkAsian); 1831 break; 1832 1833 default: 1834 ; 1835 } 1836 return aRet; 1837 } 1838 1839 /*-- 14.12.98 10:25:45--------------------------------------------------- 1840 1841 -----------------------------------------------------------------------*/ 1842 OUString SAL_CALL 1843 SwXDocumentIndexMark::getMarkEntry() throw (uno::RuntimeException) 1844 { 1845 vos::OGuard aGuard(Application::GetSolarMutex()); 1846 1847 OUString sRet; 1848 SwTOXType *const pType = m_pImpl->GetTOXType(); 1849 if (pType && m_pImpl->m_pTOXMark) 1850 { 1851 sRet = OUString(m_pImpl->m_pTOXMark->GetAlternativeText()); 1852 } 1853 else if (m_pImpl->m_bIsDescriptor) 1854 { 1855 sRet = m_pImpl->m_sAltText; 1856 } 1857 else 1858 { 1859 throw uno::RuntimeException(); 1860 } 1861 return sRet; 1862 } 1863 /*-- 14.12.98 10:25:45--------------------------------------------------- 1864 1865 -----------------------------------------------------------------------*/ 1866 void SAL_CALL 1867 SwXDocumentIndexMark::setMarkEntry(const OUString& rIndexEntry) 1868 throw (uno::RuntimeException) 1869 { 1870 vos::OGuard aGuard(Application::GetSolarMutex()); 1871 1872 SwTOXType *const pType = m_pImpl->GetTOXType(); 1873 if (pType && m_pImpl->m_pTOXMark) 1874 { 1875 SwTOXMark aMark(*m_pImpl->m_pTOXMark); 1876 aMark.SetAlternativeText(rIndexEntry); 1877 SwTxtTOXMark const*const pTxtMark = 1878 m_pImpl->m_pTOXMark->GetTxtTOXMark(); 1879 SwPaM aPam(pTxtMark->GetTxtNode(), *pTxtMark->GetStart()); 1880 aPam.SetMark(); 1881 if(pTxtMark->End()) 1882 { 1883 aPam.GetPoint()->nContent = *pTxtMark->End(); 1884 } 1885 else 1886 aPam.GetPoint()->nContent++; 1887 1888 m_pImpl->ReplaceTOXMark(*pType, aMark, aPam); 1889 } 1890 else if (m_pImpl->m_bIsDescriptor) 1891 { 1892 m_pImpl->m_sAltText = rIndexEntry; 1893 } 1894 else 1895 { 1896 throw uno::RuntimeException(); 1897 } 1898 } 1899 1900 /* -----------------18.02.99 13:40------------------- 1901 * 1902 * --------------------------------------------------*/ 1903 void SAL_CALL 1904 SwXDocumentIndexMark::attach( 1905 const uno::Reference< text::XTextRange > & xTextRange) 1906 throw (lang::IllegalArgumentException, uno::RuntimeException) 1907 { 1908 vos::OGuard aGuard(Application::GetSolarMutex()); 1909 1910 if (!m_pImpl->m_bIsDescriptor) 1911 { 1912 throw uno::RuntimeException(); 1913 } 1914 1915 const uno::Reference<XUnoTunnel> xRangeTunnel(xTextRange, uno::UNO_QUERY); 1916 SwXTextRange *const pRange = 1917 ::sw::UnoTunnelGetImplementation<SwXTextRange>(xRangeTunnel); 1918 OTextCursorHelper *const pCursor = 1919 ::sw::UnoTunnelGetImplementation<OTextCursorHelper>(xRangeTunnel); 1920 SwDoc *const pDoc = 1921 (pRange) ? pRange->GetDoc() : ((pCursor) ? pCursor->GetDoc() : 0); 1922 if (!pDoc) 1923 { 1924 throw lang::IllegalArgumentException(); 1925 } 1926 1927 const SwTOXType* pTOXType = 0; 1928 switch (m_pImpl->m_eTOXType) 1929 { 1930 case TOX_INDEX: 1931 case TOX_CONTENT: 1932 pTOXType = pDoc->GetTOXType( m_pImpl->m_eTOXType, 0 ); 1933 break; 1934 case TOX_USER: 1935 { 1936 if (!m_pImpl->m_sUserIndexName.getLength()) 1937 { 1938 pTOXType = pDoc->GetTOXType( m_pImpl->m_eTOXType, 0 ); 1939 } 1940 else 1941 { 1942 const sal_uInt16 nCount = 1943 pDoc->GetTOXTypeCount(m_pImpl->m_eTOXType); 1944 for (sal_uInt16 i = 0; i < nCount; i++) 1945 { 1946 SwTOXType const*const pTemp = 1947 pDoc->GetTOXType( m_pImpl->m_eTOXType, i ); 1948 if (m_pImpl->m_sUserIndexName == 1949 OUString(pTemp->GetTypeName())) 1950 { 1951 pTOXType = pTemp; 1952 break; 1953 } 1954 } 1955 if (!pTOXType) 1956 { 1957 SwTOXType aUserType(TOX_USER, m_pImpl->m_sUserIndexName); 1958 pTOXType = pDoc->InsertTOXType(aUserType); 1959 } 1960 } 1961 } 1962 break; 1963 1964 default: 1965 break; 1966 } 1967 if (!pTOXType) 1968 { 1969 throw lang::IllegalArgumentException(); 1970 } 1971 1972 SwUnoInternalPaM aPam(*pDoc); 1973 //das muss jetzt sal_True liefern 1974 ::sw::XTextRangeToSwPaM(aPam, xTextRange); 1975 SwTOXMark aMark (pTOXType); 1976 if (m_pImpl->m_sAltText.getLength()) 1977 { 1978 aMark.SetAlternativeText(m_pImpl->m_sAltText); 1979 } 1980 switch (m_pImpl->m_eTOXType) 1981 { 1982 case TOX_INDEX: 1983 if (m_pImpl->m_sPrimaryKey.getLength()) 1984 { 1985 aMark.SetPrimaryKey(m_pImpl->m_sPrimaryKey); 1986 } 1987 if (m_pImpl->m_sSecondaryKey.getLength()) 1988 { 1989 aMark.SetSecondaryKey(m_pImpl->m_sSecondaryKey); 1990 } 1991 if (m_pImpl->m_sTextReading.getLength()) 1992 { 1993 aMark.SetTextReading(m_pImpl->m_sTextReading); 1994 } 1995 if (m_pImpl->m_sPrimaryKeyReading.getLength()) 1996 { 1997 aMark.SetPrimaryKeyReading(m_pImpl->m_sPrimaryKeyReading); 1998 } 1999 if (m_pImpl->m_sSecondaryKeyReading.getLength()) 2000 { 2001 aMark.SetSecondaryKeyReading(m_pImpl->m_sSecondaryKeyReading); 2002 } 2003 aMark.SetMainEntry(m_pImpl->m_bMainEntry); 2004 break; 2005 case TOX_USER: 2006 case TOX_CONTENT: 2007 if (USHRT_MAX != m_pImpl->m_nLevel) 2008 { 2009 aMark.SetLevel(m_pImpl->m_nLevel+1); 2010 } 2011 break; 2012 2013 default: 2014 break; 2015 } 2016 2017 m_pImpl->InsertTOXMark(*const_cast<SwTOXType *>(pTOXType), aMark, aPam, 2018 dynamic_cast<SwXTextCursor const*>(pCursor)); 2019 2020 m_pImpl->m_bIsDescriptor = sal_False; 2021 } 2022 2023 template<typename T> struct NotContainedIn 2024 { 2025 ::std::vector<T> const& m_rVector; 2026 explicit NotContainedIn(::std::vector<T> const& rVector) 2027 : m_rVector(rVector) { } 2028 bool operator() (T const& rT) { 2029 return ::std::find(m_rVector.begin(), m_rVector.end(), rT) 2030 == m_rVector.end(); 2031 } 2032 }; 2033 2034 void SwXDocumentIndexMark::Impl::InsertTOXMark( 2035 SwTOXType & rTOXType, SwTOXMark & rMark, SwPaM & rPam, 2036 SwXTextCursor const*const pTextCursor) 2037 { 2038 SwDoc *const pDoc( rPam.GetDoc() ); 2039 UnoActionContext aAction(pDoc); 2040 bool bMark = *rPam.GetPoint() != *rPam.GetMark(); 2041 // n.b.: toxmarks must have either alternative text or an extent 2042 if (bMark && rMark.GetAlternativeText().Len()) 2043 { 2044 rPam.Normalize(sal_True); 2045 rPam.DeleteMark(); 2046 bMark = false; 2047 } 2048 // Marks ohne Alternativtext ohne selektierten Text koennen nicht eingefuegt werden, 2049 // deshalb hier ein Leerzeichen - ob das die ideale Loesung ist? 2050 if (!bMark && !rMark.GetAlternativeText().Len()) 2051 { 2052 rMark.SetAlternativeText( String(' ') ); 2053 } 2054 2055 const bool bForceExpandHints( (!bMark && pTextCursor) 2056 ? pTextCursor->IsAtEndOfMeta() : false ); 2057 const SetAttrMode nInsertFlags = (bForceExpandHints) 2058 ? ( nsSetAttrMode::SETATTR_FORCEHINTEXPAND 2059 | nsSetAttrMode::SETATTR_DONTEXPAND) 2060 : nsSetAttrMode::SETATTR_DONTEXPAND; 2061 2062 ::std::vector<SwTxtAttr *> oldMarks; 2063 if (bMark) 2064 { 2065 oldMarks = rPam.GetNode()->GetTxtNode()->GetTxtAttrsAt( 2066 rPam.GetPoint()->nContent.GetIndex(), RES_TXTATR_TOXMARK); 2067 } 2068 2069 pDoc->InsertPoolItem(rPam, rMark, nInsertFlags); 2070 if (bMark && *rPam.GetPoint() > *rPam.GetMark()) 2071 { 2072 rPam.Exchange(); 2073 } 2074 2075 // rMark was copied into the document pool; now retrieve real format... 2076 SwTxtAttr * pTxtAttr(0); 2077 if (bMark) 2078 { 2079 // #i107672# 2080 // ensure that we do not retrieve a different mark at the same position 2081 ::std::vector<SwTxtAttr *> const newMarks( 2082 rPam.GetNode()->GetTxtNode()->GetTxtAttrsAt( 2083 rPam.GetPoint()->nContent.GetIndex(), RES_TXTATR_TOXMARK)); 2084 ::std::vector<SwTxtAttr *>::const_iterator const iter( 2085 ::std::find_if(newMarks.begin(), newMarks.end(), 2086 NotContainedIn<SwTxtAttr *>(oldMarks))); 2087 OSL_ASSERT(newMarks.end() != iter); 2088 if (newMarks.end() != iter) 2089 { 2090 pTxtAttr = *iter; 2091 } 2092 } 2093 else 2094 { 2095 pTxtAttr = rPam.GetNode()->GetTxtNode()->GetTxtAttrForCharAt( 2096 rPam.GetPoint()->nContent.GetIndex()-1, RES_TXTATR_TOXMARK ); 2097 } 2098 2099 if (!pTxtAttr) 2100 { 2101 throw uno::RuntimeException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( 2102 "SwXDocumentIndexMark::InsertTOXMark(): cannot insert attribute")), 2103 0); 2104 } 2105 2106 m_pDoc = pDoc; 2107 m_pTOXMark = & pTxtAttr->GetTOXMark(); 2108 const_cast<SwTOXMark*>(m_pTOXMark)->Add(this); 2109 const_cast<SwTOXType &>(rTOXType).Add(& m_TypeDepend); 2110 } 2111 2112 /*-- 14.12.98 10:25:45--------------------------------------------------- 2113 2114 -----------------------------------------------------------------------*/ 2115 uno::Reference< text::XTextRange > SAL_CALL 2116 SwXDocumentIndexMark::getAnchor() throw (uno::RuntimeException) 2117 { 2118 vos::OGuard aGuard(Application::GetSolarMutex()); 2119 2120 SwTOXType *const pType = m_pImpl->GetTOXType(); 2121 if (!pType || !m_pImpl->m_pTOXMark) 2122 { 2123 throw uno::RuntimeException(); 2124 } 2125 if (!m_pImpl->m_pTOXMark->GetTxtTOXMark()) 2126 { 2127 throw uno::RuntimeException(); 2128 } 2129 const SwTxtTOXMark* pTxtMark = m_pImpl->m_pTOXMark->GetTxtTOXMark(); 2130 SwPaM aPam(pTxtMark->GetTxtNode(), *pTxtMark->GetStart()); 2131 aPam.SetMark(); 2132 if(pTxtMark->End()) 2133 { 2134 aPam.GetPoint()->nContent = *pTxtMark->End(); 2135 } 2136 else 2137 { 2138 aPam.GetPoint()->nContent++; 2139 } 2140 const uno::Reference< frame::XModel > xModel = 2141 m_pImpl->m_pDoc->GetDocShell()->GetBaseModel(); 2142 const uno::Reference< text::XTextDocument > xTDoc(xModel, uno::UNO_QUERY); 2143 const uno::Reference< text::XTextRange > xRet = 2144 new SwXTextRange(aPam, xTDoc->getText()); 2145 2146 return xRet; 2147 } 2148 2149 /*-- 14.12.98 10:25:45--------------------------------------------------- 2150 2151 -----------------------------------------------------------------------*/ 2152 void SAL_CALL 2153 SwXDocumentIndexMark::dispose() throw (uno::RuntimeException) 2154 { 2155 vos::OGuard aGuard(Application::GetSolarMutex()); 2156 2157 SwTOXType *const pType = m_pImpl->GetTOXType(); 2158 if (pType && m_pImpl->m_pTOXMark) 2159 { 2160 m_pImpl->DeleteTOXMark(); // call Invalidate() via modify! 2161 } 2162 } 2163 /*-- 14.12.98 10:25:45--------------------------------------------------- 2164 2165 -----------------------------------------------------------------------*/ 2166 void SAL_CALL 2167 SwXDocumentIndexMark::addEventListener( 2168 const uno::Reference< lang::XEventListener > & xListener) 2169 throw (uno::RuntimeException) 2170 { 2171 vos::OGuard g(Application::GetSolarMutex()); 2172 2173 if (!m_pImpl->GetRegisteredIn()) 2174 { 2175 throw uno::RuntimeException(); 2176 } 2177 m_pImpl->m_ListenerContainer.AddListener(xListener); 2178 } 2179 /*-- 14.12.98 10:25:46--------------------------------------------------- 2180 2181 -----------------------------------------------------------------------*/ 2182 void SAL_CALL 2183 SwXDocumentIndexMark::removeEventListener( 2184 const uno::Reference< lang::XEventListener > & xListener) 2185 throw (uno::RuntimeException) 2186 { 2187 vos::OGuard g(Application::GetSolarMutex()); 2188 2189 if (!m_pImpl->GetRegisteredIn() || 2190 !m_pImpl->m_ListenerContainer.RemoveListener(xListener)) 2191 { 2192 throw uno::RuntimeException(); 2193 } 2194 } 2195 2196 /*-- 14.12.98 10:25:46--------------------------------------------------- 2197 2198 -----------------------------------------------------------------------*/ 2199 uno::Reference< beans::XPropertySetInfo > SAL_CALL 2200 SwXDocumentIndexMark::getPropertySetInfo() throw (uno::RuntimeException) 2201 { 2202 vos::OGuard g(Application::GetSolarMutex()); 2203 2204 static uno::Reference< beans::XPropertySetInfo > xInfos[3]; 2205 int nPos = 0; 2206 switch (m_pImpl->m_eTOXType) 2207 { 2208 case TOX_INDEX: nPos = 0; break; 2209 case TOX_CONTENT: nPos = 1; break; 2210 case TOX_USER: nPos = 2; break; 2211 default: 2212 ; 2213 } 2214 if(!xInfos[nPos].is()) 2215 { 2216 const uno::Reference< beans::XPropertySetInfo > xInfo = 2217 m_pImpl->m_rPropSet.getPropertySetInfo(); 2218 // extend PropertySetInfo! 2219 const uno::Sequence<beans::Property> aPropSeq = xInfo->getProperties(); 2220 xInfos[nPos] = new SfxExtItemPropertySetInfo( 2221 aSwMapProvider.GetPropertyMapEntries( 2222 PROPERTY_MAP_PARAGRAPH_EXTENSIONS), 2223 aPropSeq ); 2224 } 2225 return xInfos[nPos]; 2226 } 2227 2228 /*-- 14.12.98 10:25:46--------------------------------------------------- 2229 2230 -----------------------------------------------------------------------*/ 2231 void SAL_CALL 2232 SwXDocumentIndexMark::setPropertyValue( 2233 const OUString& rPropertyName, const uno::Any& rValue) 2234 throw (beans::UnknownPropertyException, beans::PropertyVetoException, 2235 lang::IllegalArgumentException, lang::WrappedTargetException, 2236 uno::RuntimeException) 2237 { 2238 vos::OGuard aGuard(Application::GetSolarMutex()); 2239 2240 SfxItemPropertySimpleEntry const*const pEntry = 2241 m_pImpl->m_rPropSet.getPropertyMap()->getByName(rPropertyName); 2242 if (!pEntry) 2243 { 2244 throw beans::UnknownPropertyException( 2245 OUString(RTL_CONSTASCII_USTRINGPARAM("Unknown property: ")) 2246 + rPropertyName, 2247 static_cast<cppu::OWeakObject *>(this)); 2248 } 2249 if (pEntry->nFlags & beans::PropertyAttribute::READONLY) 2250 { 2251 throw beans::PropertyVetoException( 2252 OUString(RTL_CONSTASCII_USTRINGPARAM("Property is read-only: ")) 2253 + rPropertyName, 2254 static_cast<cppu::OWeakObject *>(this)); 2255 } 2256 2257 SwTOXType *const pType = m_pImpl->GetTOXType(); 2258 if (pType && m_pImpl->m_pTOXMark) 2259 { 2260 SwTOXMark aMark(*m_pImpl->m_pTOXMark); 2261 switch(pEntry->nWID) 2262 { 2263 case WID_ALT_TEXT: 2264 aMark.SetAlternativeText(lcl_AnyToString(rValue)); 2265 break; 2266 case WID_LEVEL: 2267 aMark.SetLevel(Min( static_cast<sal_Int8>( MAXLEVEL ), 2268 static_cast<sal_Int8>(lcl_AnyToInt16(rValue)+1))); 2269 break; 2270 case WID_PRIMARY_KEY : 2271 aMark.SetPrimaryKey(lcl_AnyToString(rValue)); 2272 break; 2273 case WID_SECONDARY_KEY: 2274 aMark.SetSecondaryKey(lcl_AnyToString(rValue)); 2275 break; 2276 case WID_MAIN_ENTRY: 2277 aMark.SetMainEntry(lcl_AnyToBool(rValue)); 2278 break; 2279 case WID_TEXT_READING: 2280 aMark.SetTextReading(lcl_AnyToString(rValue)); 2281 break; 2282 case WID_PRIMARY_KEY_READING: 2283 aMark.SetPrimaryKeyReading(lcl_AnyToString(rValue)); 2284 break; 2285 case WID_SECONDARY_KEY_READING: 2286 aMark.SetSecondaryKeyReading(lcl_AnyToString(rValue)); 2287 break; 2288 } 2289 SwTxtTOXMark const*const pTxtMark = 2290 m_pImpl->m_pTOXMark->GetTxtTOXMark(); 2291 SwPaM aPam(pTxtMark->GetTxtNode(), *pTxtMark->GetStart()); 2292 aPam.SetMark(); 2293 if(pTxtMark->End()) 2294 { 2295 aPam.GetPoint()->nContent = *pTxtMark->End(); 2296 } 2297 else 2298 { 2299 aPam.GetPoint()->nContent++; 2300 } 2301 2302 m_pImpl->ReplaceTOXMark(*pType, aMark, aPam); 2303 } 2304 else if (m_pImpl->m_bIsDescriptor) 2305 { 2306 switch(pEntry->nWID) 2307 { 2308 case WID_ALT_TEXT: 2309 m_pImpl->m_sAltText = lcl_AnyToString(rValue); 2310 break; 2311 case WID_LEVEL: 2312 { 2313 const sal_Int16 nVal = lcl_AnyToInt16(rValue); 2314 if(nVal >= 0 && nVal < MAXLEVEL) 2315 { 2316 m_pImpl->m_nLevel = nVal; 2317 } 2318 else 2319 { 2320 throw lang::IllegalArgumentException(); 2321 } 2322 } 2323 break; 2324 case WID_PRIMARY_KEY: 2325 m_pImpl->m_sPrimaryKey = lcl_AnyToString(rValue); 2326 break; 2327 case WID_SECONDARY_KEY: 2328 m_pImpl->m_sSecondaryKey = lcl_AnyToString(rValue); 2329 break; 2330 case WID_TEXT_READING: 2331 m_pImpl->m_sTextReading = lcl_AnyToString(rValue); 2332 break; 2333 case WID_PRIMARY_KEY_READING: 2334 m_pImpl->m_sPrimaryKeyReading = lcl_AnyToString(rValue); 2335 break; 2336 case WID_SECONDARY_KEY_READING: 2337 m_pImpl->m_sSecondaryKeyReading = lcl_AnyToString(rValue); 2338 break; 2339 case WID_USER_IDX_NAME: 2340 { 2341 OUString sTmp(lcl_AnyToString(rValue)); 2342 lcl_ConvertTOUNameToUserName(sTmp); 2343 m_pImpl->m_sUserIndexName = sTmp; 2344 } 2345 break; 2346 case WID_MAIN_ENTRY: 2347 m_pImpl->m_bMainEntry = lcl_AnyToBool(rValue); 2348 break; 2349 } 2350 } 2351 else 2352 { 2353 throw uno::RuntimeException(); 2354 } 2355 } 2356 2357 /*-- 14.12.98 10:25:46--------------------------------------------------- 2358 2359 -----------------------------------------------------------------------*/ 2360 uno::Any SAL_CALL 2361 SwXDocumentIndexMark::getPropertyValue(const OUString& rPropertyName) 2362 throw (beans::UnknownPropertyException, lang::WrappedTargetException, 2363 uno::RuntimeException) 2364 { 2365 vos::OGuard aGuard(Application::GetSolarMutex()); 2366 2367 uno::Any aRet; 2368 SfxItemPropertySimpleEntry const*const pEntry = 2369 m_pImpl->m_rPropSet.getPropertyMap()->getByName(rPropertyName); 2370 if (!pEntry) 2371 { 2372 throw beans::UnknownPropertyException( 2373 OUString(RTL_CONSTASCII_USTRINGPARAM("Unknown property: ")) 2374 + rPropertyName, 2375 static_cast<cppu::OWeakObject *>(this)); 2376 } 2377 if (::sw::GetDefaultTextContentValue(aRet, rPropertyName, pEntry->nWID)) 2378 { 2379 return aRet; 2380 } 2381 2382 SwTOXType *const pType = m_pImpl->GetTOXType(); 2383 if (pType && m_pImpl->m_pTOXMark) 2384 { 2385 switch(pEntry->nWID) 2386 { 2387 case WID_ALT_TEXT: 2388 aRet <<= OUString(m_pImpl->m_pTOXMark->GetAlternativeText()); 2389 break; 2390 case WID_LEVEL: 2391 aRet <<= static_cast<sal_Int16>( 2392 m_pImpl->m_pTOXMark->GetLevel() - 1); 2393 break; 2394 case WID_PRIMARY_KEY : 2395 aRet <<= OUString(m_pImpl->m_pTOXMark->GetPrimaryKey()); 2396 break; 2397 case WID_SECONDARY_KEY: 2398 aRet <<= OUString(m_pImpl->m_pTOXMark->GetSecondaryKey()); 2399 break; 2400 case WID_TEXT_READING: 2401 aRet <<= OUString(m_pImpl->m_pTOXMark->GetTextReading()); 2402 break; 2403 case WID_PRIMARY_KEY_READING: 2404 aRet <<= OUString(m_pImpl->m_pTOXMark->GetPrimaryKeyReading()); 2405 break; 2406 case WID_SECONDARY_KEY_READING: 2407 aRet <<= OUString( 2408 m_pImpl->m_pTOXMark->GetSecondaryKeyReading()); 2409 break; 2410 case WID_USER_IDX_NAME : 2411 { 2412 OUString sTmp(pType->GetTypeName()); 2413 lcl_ConvertTOUNameToProgrammaticName(sTmp); 2414 aRet <<= sTmp; 2415 } 2416 break; 2417 case WID_MAIN_ENTRY: 2418 { 2419 const sal_Bool bTemp = m_pImpl->m_pTOXMark->IsMainEntry(); 2420 aRet <<= bTemp; 2421 } 2422 break; 2423 } 2424 } 2425 else if (m_pImpl->m_bIsDescriptor) 2426 { 2427 switch(pEntry->nWID) 2428 { 2429 case WID_ALT_TEXT: 2430 aRet <<= m_pImpl->m_sAltText; 2431 break; 2432 case WID_LEVEL: 2433 aRet <<= static_cast<sal_Int16>(m_pImpl->m_nLevel); 2434 break; 2435 case WID_PRIMARY_KEY: 2436 aRet <<= m_pImpl->m_sPrimaryKey; 2437 break; 2438 case WID_SECONDARY_KEY: 2439 aRet <<= m_pImpl->m_sSecondaryKey; 2440 break; 2441 case WID_TEXT_READING: 2442 aRet <<= m_pImpl->m_sTextReading; 2443 break; 2444 case WID_PRIMARY_KEY_READING: 2445 aRet <<= m_pImpl->m_sPrimaryKeyReading; 2446 break; 2447 case WID_SECONDARY_KEY_READING: 2448 aRet <<= m_pImpl->m_sSecondaryKeyReading; 2449 break; 2450 case WID_USER_IDX_NAME : 2451 aRet <<= m_pImpl->m_sUserIndexName; 2452 break; 2453 case WID_MAIN_ENTRY: 2454 { 2455 aRet <<= static_cast<sal_Bool>(m_pImpl->m_bMainEntry); 2456 } 2457 break; 2458 } 2459 } 2460 else 2461 { 2462 throw uno::RuntimeException(); 2463 } 2464 return aRet; 2465 } 2466 2467 /*-- 14.12.98 10:25:46--------------------------------------------------- 2468 2469 -----------------------------------------------------------------------*/ 2470 void SAL_CALL 2471 SwXDocumentIndexMark::addPropertyChangeListener( 2472 const ::rtl::OUString& /*rPropertyName*/, 2473 const uno::Reference< beans::XPropertyChangeListener >& /*xListener*/) 2474 throw (beans::UnknownPropertyException, lang::WrappedTargetException, 2475 uno::RuntimeException) 2476 { 2477 OSL_ENSURE(false, 2478 "SwXDocumentIndexMark::addPropertyChangeListener(): not implemented"); 2479 } 2480 2481 void SAL_CALL 2482 SwXDocumentIndexMark::removePropertyChangeListener( 2483 const ::rtl::OUString& /*rPropertyName*/, 2484 const uno::Reference< beans::XPropertyChangeListener >& /*xListener*/) 2485 throw (beans::UnknownPropertyException, lang::WrappedTargetException, 2486 uno::RuntimeException) 2487 { 2488 OSL_ENSURE(false, 2489 "SwXDocumentIndexMark::removePropertyChangeListener(): not implemented"); 2490 } 2491 2492 void SAL_CALL 2493 SwXDocumentIndexMark::addVetoableChangeListener( 2494 const ::rtl::OUString& /*rPropertyName*/, 2495 const uno::Reference< beans::XVetoableChangeListener >& /*xListener*/) 2496 throw (beans::UnknownPropertyException, lang::WrappedTargetException, 2497 uno::RuntimeException) 2498 { 2499 OSL_ENSURE(false, 2500 "SwXDocumentIndexMark::addVetoableChangeListener(): not implemented"); 2501 } 2502 2503 void SAL_CALL 2504 SwXDocumentIndexMark::removeVetoableChangeListener( 2505 const ::rtl::OUString& /*rPropertyName*/, 2506 const uno::Reference< beans::XVetoableChangeListener >& /*xListener*/) 2507 throw (beans::UnknownPropertyException, lang::WrappedTargetException, 2508 uno::RuntimeException) 2509 { 2510 OSL_ENSURE(false, 2511 "SwXDocumentIndexMark::removeVetoableChangeListener(): not implemented"); 2512 } 2513 2514 2515 /****************************************************************** 2516 * SwXDocumentIndexes 2517 ******************************************************************/ 2518 /*-- 05.05.99 13:14:59--------------------------------------------------- 2519 2520 -----------------------------------------------------------------------*/ 2521 SwXDocumentIndexes::SwXDocumentIndexes(SwDoc *const _pDoc) 2522 : SwUnoCollection(_pDoc) 2523 { 2524 } 2525 /*-- 05.05.99 13:15:00--------------------------------------------------- 2526 2527 -----------------------------------------------------------------------*/ 2528 SwXDocumentIndexes::~SwXDocumentIndexes() 2529 { 2530 } 2531 2532 /* -----------------------------06.04.00 15:08-------------------------------- 2533 2534 ---------------------------------------------------------------------------*/ 2535 OUString SAL_CALL 2536 SwXDocumentIndexes::getImplementationName() throw (uno::RuntimeException) 2537 { 2538 return C2U("SwXDocumentIndexes"); 2539 } 2540 2541 static char const*const g_ServicesDocumentIndexes[] = 2542 { 2543 "com.sun.star.text.DocumentIndexes", 2544 }; 2545 static const size_t g_nServicesDocumentIndexes( 2546 sizeof(g_ServicesDocumentIndexes)/sizeof(g_ServicesDocumentIndexes[0])); 2547 2548 sal_Bool SAL_CALL 2549 SwXDocumentIndexes::supportsService(const OUString& rServiceName) 2550 throw (uno::RuntimeException) 2551 { 2552 return ::sw::SupportsServiceImpl( 2553 g_nServicesDocumentIndexes, g_ServicesDocumentIndexes, rServiceName); 2554 } 2555 2556 uno::Sequence< OUString > SAL_CALL 2557 SwXDocumentIndexes::getSupportedServiceNames() throw (uno::RuntimeException) 2558 { 2559 return ::sw::GetSupportedServiceNamesImpl( 2560 g_nServicesDocumentIndexes, g_ServicesDocumentIndexes); 2561 } 2562 2563 /*-- 05.05.99 13:15:01--------------------------------------------------- 2564 2565 -----------------------------------------------------------------------*/ 2566 sal_Int32 SAL_CALL 2567 SwXDocumentIndexes::getCount() throw (uno::RuntimeException) 2568 { 2569 vos::OGuard aGuard(Application::GetSolarMutex()); 2570 2571 if(!IsValid()) 2572 throw uno::RuntimeException(); 2573 2574 sal_uInt32 nRet = 0; 2575 const SwSectionFmts& rFmts = GetDoc()->GetSections(); 2576 for( sal_uInt16 n = 0; n < rFmts.Count(); ++n ) 2577 { 2578 const SwSection* pSect = rFmts[ n ]->GetSection(); 2579 if( TOX_CONTENT_SECTION == pSect->GetType() && 2580 pSect->GetFmt()->GetSectionNode() ) 2581 { 2582 ++nRet; 2583 } 2584 } 2585 return nRet; 2586 } 2587 2588 /*-- 05.05.99 13:15:01--------------------------------------------------- 2589 2590 -----------------------------------------------------------------------*/ 2591 uno::Any SAL_CALL 2592 SwXDocumentIndexes::getByIndex(sal_Int32 nIndex) 2593 throw (lang::IndexOutOfBoundsException, lang::WrappedTargetException, 2594 uno::RuntimeException) 2595 { 2596 vos::OGuard aGuard(Application::GetSolarMutex()); 2597 2598 if(!IsValid()) 2599 throw uno::RuntimeException(); 2600 2601 sal_Int32 nIdx = 0; 2602 2603 const SwSectionFmts& rFmts = GetDoc()->GetSections(); 2604 for( sal_uInt16 n = 0; n < rFmts.Count(); ++n ) 2605 { 2606 const SwSection* pSect = rFmts[ n ]->GetSection(); 2607 if( TOX_CONTENT_SECTION == pSect->GetType() && 2608 pSect->GetFmt()->GetSectionNode() && 2609 nIdx++ == nIndex ) 2610 { 2611 const uno::Reference< text::XDocumentIndex > xTmp = 2612 SwXDocumentIndex::CreateXDocumentIndex( 2613 *GetDoc(), static_cast<SwTOXBaseSection const&>(*pSect)); 2614 uno::Any aRet; 2615 aRet <<= xTmp; 2616 return aRet; 2617 } 2618 } 2619 2620 throw lang::IndexOutOfBoundsException(); 2621 } 2622 2623 /*-- 31.01.00 10:12:31--------------------------------------------------- 2624 2625 -----------------------------------------------------------------------*/ 2626 uno::Any SAL_CALL 2627 SwXDocumentIndexes::getByName(const OUString& rName) 2628 throw (container::NoSuchElementException, lang::WrappedTargetException, 2629 uno::RuntimeException) 2630 { 2631 vos::OGuard aGuard(Application::GetSolarMutex()); 2632 2633 if(!IsValid()) 2634 throw uno::RuntimeException(); 2635 2636 String sToFind(rName); 2637 const SwSectionFmts& rFmts = GetDoc()->GetSections(); 2638 for( sal_uInt16 n = 0; n < rFmts.Count(); ++n ) 2639 { 2640 const SwSection* pSect = rFmts[ n ]->GetSection(); 2641 if( TOX_CONTENT_SECTION == pSect->GetType() && 2642 pSect->GetFmt()->GetSectionNode() && 2643 (static_cast<SwTOXBaseSection const*>(pSect)->GetTOXName() 2644 == sToFind)) 2645 { 2646 const uno::Reference< text::XDocumentIndex > xTmp = 2647 SwXDocumentIndex::CreateXDocumentIndex( 2648 *GetDoc(), static_cast<SwTOXBaseSection const&>(*pSect)); 2649 uno::Any aRet; 2650 aRet <<= xTmp; 2651 return aRet; 2652 } 2653 } 2654 throw container::NoSuchElementException(); 2655 } 2656 2657 /*-- 31.01.00 10:12:31--------------------------------------------------- 2658 2659 -----------------------------------------------------------------------*/ 2660 uno::Sequence< OUString > SAL_CALL 2661 SwXDocumentIndexes::getElementNames() throw (uno::RuntimeException) 2662 { 2663 vos::OGuard aGuard(Application::GetSolarMutex()); 2664 2665 if(!IsValid()) 2666 throw uno::RuntimeException(); 2667 2668 const SwSectionFmts& rFmts = GetDoc()->GetSections(); 2669 sal_Int32 nCount = 0; 2670 sal_uInt16 n; 2671 for( n = 0; n < rFmts.Count(); ++n ) 2672 { 2673 SwSection const*const pSect = rFmts[ n ]->GetSection(); 2674 if( TOX_CONTENT_SECTION == pSect->GetType() && 2675 pSect->GetFmt()->GetSectionNode() ) 2676 { 2677 ++nCount; 2678 } 2679 } 2680 2681 uno::Sequence< OUString > aRet(nCount); 2682 OUString* pArray = aRet.getArray(); 2683 sal_uInt16 nCnt; 2684 for( n = 0, nCnt = 0; n < rFmts.Count(); ++n ) 2685 { 2686 SwSection const*const pSect = rFmts[ n ]->GetSection(); 2687 if( TOX_CONTENT_SECTION == pSect->GetType() && 2688 pSect->GetFmt()->GetSectionNode()) 2689 { 2690 pArray[nCnt++] = OUString( 2691 static_cast<SwTOXBaseSection const*>(pSect)->GetTOXName()); 2692 } 2693 } 2694 return aRet; 2695 } 2696 2697 /*-- 31.01.00 10:12:31--------------------------------------------------- 2698 2699 -----------------------------------------------------------------------*/ 2700 sal_Bool SAL_CALL 2701 SwXDocumentIndexes::hasByName(const OUString& rName) 2702 throw (uno::RuntimeException) 2703 { 2704 vos::OGuard aGuard(Application::GetSolarMutex()); 2705 2706 if(!IsValid()) 2707 throw uno::RuntimeException(); 2708 2709 String sToFind(rName); 2710 const SwSectionFmts& rFmts = GetDoc()->GetSections(); 2711 for( sal_uInt16 n = 0; n < rFmts.Count(); ++n ) 2712 { 2713 SwSection const*const pSect = rFmts[ n ]->GetSection(); 2714 if( TOX_CONTENT_SECTION == pSect->GetType() && 2715 pSect->GetFmt()->GetSectionNode()) 2716 { 2717 if (static_cast<SwTOXBaseSection const*>(pSect)->GetTOXName() 2718 == sToFind) 2719 { 2720 return sal_True; 2721 } 2722 } 2723 } 2724 return sal_False; 2725 } 2726 2727 /*-- 05.05.99 13:15:01--------------------------------------------------- 2728 2729 -----------------------------------------------------------------------*/ 2730 uno::Type SAL_CALL 2731 SwXDocumentIndexes::getElementType() throw (uno::RuntimeException) 2732 { 2733 return text::XDocumentIndex::static_type(); 2734 } 2735 /*-- 05.05.99 13:15:02--------------------------------------------------- 2736 2737 -----------------------------------------------------------------------*/ 2738 sal_Bool SAL_CALL 2739 SwXDocumentIndexes::hasElements() throw (uno::RuntimeException) 2740 { 2741 return 0 != getCount(); 2742 } 2743 2744 /****************************************************************** 2745 * SwXDocumentIndex::StyleAccess_Impl 2746 ******************************************************************/ 2747 2748 /*-- 13.09.99 16:52:28--------------------------------------------------- 2749 2750 -----------------------------------------------------------------------*/ 2751 SwXDocumentIndex::StyleAccess_Impl::StyleAccess_Impl( 2752 SwXDocumentIndex& rParentIdx) 2753 : m_xParent(&rParentIdx) 2754 { 2755 } 2756 /*-- 13.09.99 16:52:29--------------------------------------------------- 2757 2758 -----------------------------------------------------------------------*/ 2759 SwXDocumentIndex::StyleAccess_Impl::~StyleAccess_Impl() 2760 { 2761 } 2762 2763 /* -----------------------------06.04.00 15:08-------------------------------- 2764 2765 ---------------------------------------------------------------------------*/ 2766 OUString SAL_CALL 2767 SwXDocumentIndex::StyleAccess_Impl::getImplementationName() 2768 throw (uno::RuntimeException) 2769 { 2770 return C2U("SwXDocumentIndex::StyleAccess_Impl"); 2771 } 2772 2773 static char const*const g_ServicesIndexStyleAccess[] = 2774 { 2775 "com.sun.star.text.DocumentIndexParagraphStyles", 2776 }; 2777 static const size_t g_nServicesIndexStyleAccess( 2778 sizeof(g_ServicesIndexStyleAccess)/sizeof(g_ServicesIndexStyleAccess[0])); 2779 2780 sal_Bool SAL_CALL 2781 SwXDocumentIndex::StyleAccess_Impl::supportsService( 2782 const OUString& rServiceName) 2783 throw (uno::RuntimeException) 2784 { 2785 return ::sw::SupportsServiceImpl( 2786 g_nServicesIndexStyleAccess, g_ServicesIndexStyleAccess, rServiceName); 2787 } 2788 2789 uno::Sequence< OUString > SAL_CALL 2790 SwXDocumentIndex::StyleAccess_Impl::getSupportedServiceNames() 2791 throw (uno::RuntimeException) 2792 { 2793 return ::sw::GetSupportedServiceNamesImpl( 2794 g_nServicesIndexStyleAccess, g_ServicesIndexStyleAccess); 2795 } 2796 2797 /*-- 13.09.99 16:52:29--------------------------------------------------- 2798 2799 -----------------------------------------------------------------------*/ 2800 void SAL_CALL 2801 SwXDocumentIndex::StyleAccess_Impl::replaceByIndex( 2802 sal_Int32 nIndex, const uno::Any& rElement) 2803 throw (lang::IllegalArgumentException, lang::IndexOutOfBoundsException, 2804 lang::WrappedTargetException, uno::RuntimeException) 2805 { 2806 vos::OGuard aGuard(Application::GetSolarMutex()); 2807 2808 if(nIndex < 0 || nIndex > MAXLEVEL) 2809 { 2810 throw lang::IndexOutOfBoundsException(); 2811 } 2812 2813 SwTOXBase & rTOXBase( m_xParent->m_pImpl->GetTOXSectionOrThrow() ); 2814 2815 uno::Sequence<OUString> aSeq; 2816 if(!(rElement >>= aSeq)) 2817 { 2818 throw lang::IllegalArgumentException(); 2819 } 2820 2821 const sal_Int32 nStyles = aSeq.getLength(); 2822 const OUString* pStyles = aSeq.getConstArray(); 2823 String sSetStyles; 2824 String aString; 2825 for(sal_Int32 i = 0; i < nStyles; i++) 2826 { 2827 if(i) 2828 { 2829 sSetStyles += TOX_STYLE_DELIMITER; 2830 } 2831 SwStyleNameMapper::FillUIName(pStyles[i], aString, 2832 nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, sal_True); 2833 sSetStyles += aString; 2834 } 2835 rTOXBase.SetStyleNames(sSetStyles, static_cast<sal_uInt16>(nIndex)); 2836 } 2837 /*-- 13.09.99 16:52:29--------------------------------------------------- 2838 2839 -----------------------------------------------------------------------*/ 2840 sal_Int32 SAL_CALL 2841 SwXDocumentIndex::StyleAccess_Impl::getCount() throw (uno::RuntimeException) 2842 { 2843 return MAXLEVEL; 2844 } 2845 /*-- 13.09.99 16:52:30--------------------------------------------------- 2846 2847 -----------------------------------------------------------------------*/ 2848 uno::Any SAL_CALL 2849 SwXDocumentIndex::StyleAccess_Impl::getByIndex(sal_Int32 nIndex) 2850 throw (lang::IndexOutOfBoundsException, lang::WrappedTargetException, 2851 uno::RuntimeException) 2852 { 2853 vos::OGuard aGuard(Application::GetSolarMutex()); 2854 2855 if(nIndex < 0 || nIndex > MAXLEVEL) 2856 { 2857 throw lang::IndexOutOfBoundsException(); 2858 } 2859 2860 SwTOXBase & rTOXBase( m_xParent->m_pImpl->GetTOXSectionOrThrow() ); 2861 2862 const String& rStyles = 2863 rTOXBase.GetStyleNames(static_cast<sal_uInt16>(nIndex)); 2864 const sal_uInt16 nStyles = rStyles.GetTokenCount(TOX_STYLE_DELIMITER); 2865 uno::Sequence<OUString> aStyles(nStyles); 2866 OUString* pStyles = aStyles.getArray(); 2867 String aString; 2868 for(sal_uInt16 i = 0; i < nStyles; i++) 2869 { 2870 SwStyleNameMapper::FillProgName( 2871 rStyles.GetToken(i, TOX_STYLE_DELIMITER), 2872 aString, 2873 nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, 2874 sal_True); 2875 pStyles[i] = OUString( aString ); 2876 } 2877 uno::Any aRet(&aStyles, ::getCppuType((uno::Sequence<OUString>*)0)); 2878 return aRet; 2879 } 2880 /*-- 13.09.99 16:52:30--------------------------------------------------- 2881 2882 -----------------------------------------------------------------------*/ 2883 uno::Type SAL_CALL 2884 SwXDocumentIndex::StyleAccess_Impl::getElementType() 2885 throw (uno::RuntimeException) 2886 { 2887 return ::getCppuType((uno::Sequence<OUString>*)0); 2888 } 2889 /*-- 13.09.99 16:52:30--------------------------------------------------- 2890 2891 -----------------------------------------------------------------------*/ 2892 sal_Bool SAL_CALL 2893 SwXDocumentIndex::StyleAccess_Impl::hasElements() throw (uno::RuntimeException) 2894 { 2895 return sal_True; 2896 } 2897 2898 /****************************************************************** 2899 * SwXDocumentIndex::TokenAccess_Impl 2900 ******************************************************************/ 2901 /*-- 13.09.99 16:52:28--------------------------------------------------- 2902 2903 -----------------------------------------------------------------------*/ 2904 SwXDocumentIndex::TokenAccess_Impl::TokenAccess_Impl( 2905 SwXDocumentIndex& rParentIdx) 2906 : m_xParent(&rParentIdx) 2907 { 2908 } 2909 /*-- 13.09.99 16:52:29--------------------------------------------------- 2910 2911 -----------------------------------------------------------------------*/ 2912 SwXDocumentIndex::TokenAccess_Impl::~TokenAccess_Impl() 2913 { 2914 } 2915 2916 /* -----------------------------06.04.00 15:08-------------------------------- 2917 2918 ---------------------------------------------------------------------------*/ 2919 OUString SAL_CALL 2920 SwXDocumentIndex::TokenAccess_Impl::getImplementationName() 2921 throw (uno::RuntimeException) 2922 { 2923 return C2U("SwXDocumentIndex::TokenAccess_Impl"); 2924 } 2925 2926 static char const*const g_ServicesIndexTokenAccess[] = 2927 { 2928 "com.sun.star.text.DocumentIndexLevelFormat", 2929 }; 2930 static const size_t g_nServicesIndexTokenAccess( 2931 sizeof(g_ServicesIndexTokenAccess)/sizeof(g_ServicesIndexTokenAccess[0])); 2932 2933 sal_Bool SAL_CALL 2934 SwXDocumentIndex::TokenAccess_Impl::supportsService( 2935 const OUString& rServiceName) 2936 throw (uno::RuntimeException) 2937 { 2938 return ::sw::SupportsServiceImpl( 2939 g_nServicesIndexTokenAccess, g_ServicesIndexTokenAccess, rServiceName); 2940 } 2941 2942 uno::Sequence< OUString > SAL_CALL 2943 SwXDocumentIndex::TokenAccess_Impl::getSupportedServiceNames() 2944 throw (uno::RuntimeException) 2945 { 2946 return ::sw::GetSupportedServiceNamesImpl( 2947 g_nServicesIndexTokenAccess, g_ServicesIndexTokenAccess); 2948 } 2949 2950 struct TokenType { 2951 const char *pName; 2952 const enum FormTokenType eTokenType; 2953 }; 2954 2955 static const struct TokenType g_TokenTypes[] = 2956 { 2957 { "TokenEntryNumber", TOKEN_ENTRY_NO }, 2958 { "TokenEntryText", TOKEN_ENTRY_TEXT }, 2959 { "TokenTabStop", TOKEN_TAB_STOP }, 2960 { "TokenText", TOKEN_TEXT }, 2961 { "TokenPageNumber", TOKEN_PAGE_NUMS }, 2962 { "TokenChapterInfo", TOKEN_CHAPTER_INFO }, 2963 { "TokenHyperlinkStart", TOKEN_LINK_START }, 2964 { "TokenHyperlinkEnd", TOKEN_LINK_END }, 2965 { "TokenBibliographyDataField", TOKEN_AUTHORITY }, 2966 { 0, static_cast<enum FormTokenType>(0) } 2967 }; 2968 2969 /*-- 13.09.99 16:52:29--------------------------------------------------- 2970 2971 -----------------------------------------------------------------------*/ 2972 void SAL_CALL 2973 SwXDocumentIndex::TokenAccess_Impl::replaceByIndex( 2974 sal_Int32 nIndex, const uno::Any& rElement) 2975 throw (lang::IllegalArgumentException, lang::IndexOutOfBoundsException, 2976 lang::WrappedTargetException, uno::RuntimeException) 2977 { 2978 vos::OGuard aGuard(Application::GetSolarMutex()); 2979 2980 SwTOXBase & rTOXBase( m_xParent->m_pImpl->GetTOXSectionOrThrow() ); 2981 2982 if ((nIndex < 0) || (nIndex > rTOXBase.GetTOXForm().GetFormMax())) 2983 { 2984 throw lang::IndexOutOfBoundsException(); 2985 } 2986 2987 uno::Sequence<beans::PropertyValues> aSeq; 2988 if(!(rElement >>= aSeq)) 2989 { 2990 throw lang::IllegalArgumentException(); 2991 } 2992 2993 String sPattern; 2994 const sal_Int32 nTokens = aSeq.getLength(); 2995 const beans::PropertyValues* pTokens = aSeq.getConstArray(); 2996 for(sal_Int32 i = 0; i < nTokens; i++) 2997 { 2998 const beans::PropertyValue* pProperties = pTokens[i].getConstArray(); 2999 const sal_Int32 nProperties = pTokens[i].getLength(); 3000 //create an invalid token 3001 SwFormToken aToken(TOKEN_END); 3002 for(sal_Int32 j = 0; j < nProperties; j++) 3003 { 3004 if (pProperties[j].Name.equalsAscii("TokenType")) 3005 { 3006 const OUString sTokenType = 3007 lcl_AnyToString(pProperties[j].Value); 3008 for (TokenType const* pTokenType = g_TokenTypes; 3009 pTokenType->pName; ++pTokenType) 3010 { 3011 if (sTokenType.equalsAscii(pTokenType->pName)) 3012 { 3013 aToken.eTokenType = pTokenType->eTokenType; 3014 break; 3015 } 3016 } 3017 } 3018 else if (pProperties[j].Name.equalsAsciiL( 3019 RTL_CONSTASCII_STRINGPARAM("CharacterStyleName"))) 3020 { 3021 String sCharStyleName; 3022 SwStyleNameMapper::FillUIName( 3023 lcl_AnyToString(pProperties[j].Value), 3024 sCharStyleName, 3025 nsSwGetPoolIdFromName::GET_POOLID_CHRFMT, 3026 sal_True); 3027 aToken.sCharStyleName = sCharStyleName; 3028 aToken.nPoolId = SwStyleNameMapper::GetPoolIdFromUIName ( 3029 sCharStyleName, nsSwGetPoolIdFromName::GET_POOLID_CHRFMT ); 3030 } 3031 else if (pProperties[j].Name.equalsAsciiL( 3032 RTL_CONSTASCII_STRINGPARAM("TabStopRightAligned"))) 3033 { 3034 const sal_Bool bRight = lcl_AnyToBool(pProperties[j].Value); 3035 aToken.eTabAlign = bRight ? 3036 SVX_TAB_ADJUST_END : SVX_TAB_ADJUST_LEFT; 3037 } 3038 else if (pProperties[j].Name.equalsAsciiL( 3039 RTL_CONSTASCII_STRINGPARAM("TabStopPosition"))) 3040 { 3041 sal_Int32 nPosition = 0; 3042 if (!(pProperties[j].Value >>= nPosition)) 3043 { 3044 throw lang::IllegalArgumentException(); 3045 } 3046 nPosition = MM100_TO_TWIP(nPosition); 3047 if(nPosition < 0) 3048 { 3049 throw lang::IllegalArgumentException(); 3050 } 3051 aToken.nTabStopPosition = nPosition; 3052 } 3053 else if (pProperties[j].Name.equalsAsciiL( 3054 RTL_CONSTASCII_STRINGPARAM("TabStopFillCharacter"))) 3055 { 3056 const OUString sFillChar = 3057 lcl_AnyToString(pProperties[j].Value); 3058 if (sFillChar.getLength() > 1) 3059 { 3060 throw lang::IllegalArgumentException(); 3061 } 3062 aToken.cTabFillChar = 3063 (sFillChar.getLength()) ? sFillChar[0] : ' '; 3064 } 3065 else if (pProperties[j].Name.equalsAsciiL( 3066 RTL_CONSTASCII_STRINGPARAM("Text"))) 3067 { 3068 const OUString sText = lcl_AnyToString(pProperties[j].Value); 3069 aToken.sText = sText; 3070 } 3071 else if (pProperties[j].Name.equalsAsciiL( 3072 RTL_CONSTASCII_STRINGPARAM("ChapterFormat"))) 3073 { 3074 sal_Int16 nFormat = lcl_AnyToInt16(pProperties[j].Value); 3075 switch(nFormat) 3076 { 3077 case text::ChapterFormat::NUMBER: 3078 nFormat = CF_NUMBER; 3079 break; 3080 case text::ChapterFormat::NAME: 3081 nFormat = CF_TITLE; 3082 break; 3083 case text::ChapterFormat::NAME_NUMBER: 3084 nFormat = CF_NUM_TITLE; 3085 break; 3086 case text::ChapterFormat::NO_PREFIX_SUFFIX: 3087 nFormat = CF_NUMBER_NOPREPST; 3088 break; 3089 case text::ChapterFormat::DIGIT: 3090 nFormat = CF_NUM_NOPREPST_TITLE; 3091 break; 3092 default: 3093 throw lang::IllegalArgumentException(); 3094 } 3095 aToken.nChapterFormat = nFormat; 3096 } 3097 //--->i53420 3098 else if (pProperties[j].Name.equalsAsciiL( 3099 RTL_CONSTASCII_STRINGPARAM("ChapterLevel"))) 3100 { 3101 const sal_Int16 nLevel = lcl_AnyToInt16(pProperties[j].Value); 3102 if( nLevel < 1 || nLevel > MAXLEVEL ) 3103 { 3104 throw lang::IllegalArgumentException(); 3105 } 3106 aToken.nOutlineLevel = nLevel; 3107 } 3108 //<--- 3109 else if (pProperties[j].Name.equalsAsciiL( 3110 RTL_CONSTASCII_STRINGPARAM("BibliographyDataField"))) 3111 { 3112 sal_Int16 nType = 0; 3113 pProperties[j].Value >>= nType; 3114 if(nType < 0 || nType > text::BibliographyDataField::ISBN) 3115 { 3116 lang::IllegalArgumentException aExcept; 3117 aExcept.Message = C2U("BibliographyDataField - wrong value"); 3118 aExcept.ArgumentPosition = static_cast< sal_Int16 >(j); 3119 throw aExcept; 3120 } 3121 aToken.nAuthorityField = nType; 3122 } 3123 // #i21237# 3124 else if (pProperties[j].Name.equalsAsciiL( 3125 RTL_CONSTASCII_STRINGPARAM("WithTab"))) 3126 { 3127 aToken.bWithTab = lcl_AnyToBool(pProperties[j].Value); 3128 } 3129 3130 } 3131 //exception if wrong TokenType 3132 if(TOKEN_END <= aToken.eTokenType ) 3133 { 3134 throw lang::IllegalArgumentException(); 3135 } 3136 // set TokenType from TOKEN_ENTRY_TEXT to TOKEN_ENTRY if it is 3137 // not a content index 3138 if(TOKEN_ENTRY_TEXT == aToken.eTokenType && 3139 (TOX_CONTENT != rTOXBase.GetType())) 3140 { 3141 aToken.eTokenType = TOKEN_ENTRY; 3142 } 3143 //---> i53420 3144 // check for chapter format allowed values if it was TOKEN_ENTRY_NO type 3145 // only allowed value are CF_NUMBER and CF_NUM_NOPREPST_TITLE 3146 // reading from file 3147 if( TOKEN_ENTRY_NO == aToken.eTokenType ) 3148 { 3149 switch(aToken.nChapterFormat) 3150 { 3151 case CF_NUMBER: 3152 case CF_NUM_NOPREPST_TITLE: 3153 break; 3154 default: 3155 throw lang::IllegalArgumentException(); 3156 } 3157 } 3158 //<--- 3159 sPattern += aToken.GetString(); 3160 } 3161 SwForm aForm(rTOXBase.GetTOXForm()); 3162 aForm.SetPattern(static_cast<sal_uInt16>(nIndex), sPattern); 3163 rTOXBase.SetTOXForm(aForm); 3164 } 3165 3166 /*-- 13.09.99 16:52:29--------------------------------------------------- 3167 3168 -----------------------------------------------------------------------*/ 3169 sal_Int32 SAL_CALL 3170 SwXDocumentIndex::TokenAccess_Impl::getCount() throw (uno::RuntimeException) 3171 { 3172 vos::OGuard aGuard(Application::GetSolarMutex()); 3173 3174 const sal_Int32 nRet = m_xParent->m_pImpl->GetFormMax(); 3175 return nRet; 3176 } 3177 3178 /*-- 13.09.99 16:52:30--------------------------------------------------- 3179 3180 -----------------------------------------------------------------------*/ 3181 uno::Any SAL_CALL 3182 SwXDocumentIndex::TokenAccess_Impl::getByIndex(sal_Int32 nIndex) 3183 throw (lang::IndexOutOfBoundsException, lang::WrappedTargetException, 3184 uno::RuntimeException) 3185 { 3186 vos::OGuard aGuard(Application::GetSolarMutex()); 3187 3188 SwTOXBase & rTOXBase( m_xParent->m_pImpl->GetTOXSectionOrThrow() ); 3189 3190 if ((nIndex < 0) || (nIndex > rTOXBase.GetTOXForm().GetFormMax())) 3191 { 3192 throw lang::IndexOutOfBoundsException(); 3193 } 3194 3195 // #i21237# 3196 SwFormTokens aPattern = rTOXBase.GetTOXForm(). 3197 GetPattern(static_cast<sal_uInt16>(nIndex)); 3198 SwFormTokens::iterator aIt = aPattern.begin(); 3199 3200 sal_uInt16 nTokenCount = 0; 3201 uno::Sequence< beans::PropertyValues > aRetSeq; 3202 String aString; 3203 while(aIt != aPattern.end()) // #i21237# 3204 { 3205 nTokenCount++; 3206 aRetSeq.realloc(nTokenCount); 3207 beans::PropertyValues* pTokenProps = aRetSeq.getArray(); 3208 SwFormToken aToken = *aIt; // #i21237# 3209 3210 uno::Sequence< beans::PropertyValue >& rCurTokenSeq = 3211 pTokenProps[nTokenCount-1]; 3212 SwStyleNameMapper::FillProgName( 3213 aToken.sCharStyleName, 3214 aString, 3215 nsSwGetPoolIdFromName::GET_POOLID_CHRFMT, 3216 sal_True ); 3217 const OUString aProgCharStyle( aString ); 3218 switch(aToken.eTokenType) 3219 { 3220 case TOKEN_ENTRY_NO: 3221 { 3222 //--->i53420 3223 // writing to file (from doc to properties) 3224 sal_Int32 nElements = 2; 3225 sal_Int32 nCurrentElement = 0; 3226 3227 // check for default value 3228 if (aToken.nChapterFormat != CF_NUMBER) 3229 { 3230 nElements++;//we need the element 3231 } 3232 if( aToken.nOutlineLevel != MAXLEVEL ) 3233 { 3234 nElements++; 3235 } 3236 3237 rCurTokenSeq.realloc( nElements ); 3238 3239 beans::PropertyValue* pArr = rCurTokenSeq.getArray(); 3240 3241 pArr[nCurrentElement].Name = C2U("TokenType"); 3242 pArr[nCurrentElement++].Value <<= 3243 OUString::createFromAscii("TokenEntryNumber"); 3244 3245 pArr[nCurrentElement].Name = C2U("CharacterStyleName"); 3246 pArr[nCurrentElement++].Value <<= aProgCharStyle; 3247 if( aToken.nChapterFormat != CF_NUMBER ) 3248 { 3249 pArr[nCurrentElement].Name = C2U("ChapterFormat"); 3250 sal_Int16 nVal; 3251 // the allowed values for chapter format, when used as entry number, 3252 // are CF_NUMBER and CF_NUM_NOPREPST_TITLE only, all else forced to 3253 //CF_NUMBER 3254 switch(aToken.nChapterFormat) 3255 { 3256 default: 3257 case CF_NUMBER: 3258 nVal = text::ChapterFormat::NUMBER; 3259 break; 3260 case CF_NUM_NOPREPST_TITLE: 3261 nVal = text::ChapterFormat::DIGIT; 3262 break; 3263 } 3264 pArr[nCurrentElement++].Value <<= nVal; 3265 } 3266 3267 // only a ChapterLevel != MAXLEVEL is registered 3268 if (aToken.nOutlineLevel != MAXLEVEL) 3269 { 3270 pArr[nCurrentElement].Name = C2U("ChapterLevel"); 3271 pArr[nCurrentElement].Value <<= aToken.nOutlineLevel; 3272 } 3273 //<--- 3274 } 3275 break; 3276 case TOKEN_ENTRY: // no difference between Entry and Entry Text 3277 case TOKEN_ENTRY_TEXT: 3278 { 3279 rCurTokenSeq.realloc( 2 ); 3280 beans::PropertyValue* pArr = rCurTokenSeq.getArray(); 3281 3282 pArr[0].Name = C2U("TokenType"); 3283 pArr[0].Value <<= OUString::createFromAscii("TokenEntryText"); 3284 3285 pArr[1].Name = C2U("CharacterStyleName"); 3286 pArr[1].Value <<= aProgCharStyle; 3287 } 3288 break; 3289 case TOKEN_TAB_STOP: 3290 { 3291 rCurTokenSeq.realloc(5); // #i21237# 3292 beans::PropertyValue* pArr = rCurTokenSeq.getArray(); 3293 3294 pArr[0].Name = C2U("TokenType"); 3295 pArr[0].Value <<= OUString::createFromAscii("TokenTabStop"); 3296 3297 if(SVX_TAB_ADJUST_END == aToken.eTabAlign) 3298 { 3299 pArr[1].Name = C2U("TabStopRightAligned"); 3300 sal_Bool bTemp = sal_True; 3301 pArr[1].Value.setValue(&bTemp, ::getCppuBooleanType()); 3302 } 3303 else 3304 { 3305 pArr[1].Name = C2U("TabStopPosition"); 3306 sal_Int32 nPos = (TWIP_TO_MM100(aToken.nTabStopPosition)); 3307 if(nPos < 0) 3308 nPos = 0; 3309 pArr[1].Value <<= (sal_Int32)nPos; 3310 } 3311 pArr[2].Name = C2U("TabStopFillCharacter"); 3312 pArr[2].Value <<= OUString(aToken.cTabFillChar); 3313 pArr[3].Name = C2U("CharacterStyleName"); 3314 pArr[3].Value <<= aProgCharStyle; 3315 // #i21237# 3316 pArr[4].Name = C2U("WithTab"); 3317 pArr[4].Value <<= static_cast<sal_Bool>(aToken.bWithTab); 3318 } 3319 break; 3320 case TOKEN_TEXT: 3321 { 3322 rCurTokenSeq.realloc( 3 ); 3323 beans::PropertyValue* pArr = rCurTokenSeq.getArray(); 3324 3325 pArr[0].Name = C2U("TokenType"); 3326 pArr[0].Value <<= OUString::createFromAscii("TokenText"); 3327 3328 pArr[1].Name = C2U("CharacterStyleName"); 3329 pArr[1].Value <<= aProgCharStyle; 3330 3331 pArr[2].Name = C2U("Text"); 3332 pArr[2].Value <<= OUString(aToken.sText); 3333 } 3334 break; 3335 case TOKEN_PAGE_NUMS: 3336 { 3337 rCurTokenSeq.realloc( 2 ); 3338 beans::PropertyValue* pArr = rCurTokenSeq.getArray(); 3339 3340 pArr[0].Name = C2U("TokenType"); 3341 pArr[0].Value <<= OUString::createFromAscii("TokenPageNumber"); 3342 3343 pArr[1].Name = C2U("CharacterStyleName"); 3344 pArr[1].Value <<= aProgCharStyle; 3345 } 3346 break; 3347 case TOKEN_CHAPTER_INFO: 3348 { 3349 rCurTokenSeq.realloc( 4 ); 3350 beans::PropertyValue* pArr = rCurTokenSeq.getArray(); 3351 3352 pArr[0].Name = C2U("TokenType"); 3353 pArr[0].Value <<= OUString::createFromAscii("TokenChapterInfo"); 3354 3355 pArr[1].Name = C2U("CharacterStyleName"); 3356 pArr[1].Value <<= aProgCharStyle; 3357 3358 pArr[2].Name = C2U("ChapterFormat"); 3359 sal_Int16 nVal = text::ChapterFormat::NUMBER; 3360 switch(aToken.nChapterFormat) 3361 { 3362 case CF_NUMBER: 3363 nVal = text::ChapterFormat::NUMBER; 3364 break; 3365 case CF_TITLE: 3366 nVal = text::ChapterFormat::NAME; 3367 break; 3368 case CF_NUM_TITLE: 3369 nVal = text::ChapterFormat::NAME_NUMBER; 3370 break; 3371 case CF_NUMBER_NOPREPST: 3372 nVal = text::ChapterFormat::NO_PREFIX_SUFFIX; 3373 break; 3374 case CF_NUM_NOPREPST_TITLE: 3375 nVal = text::ChapterFormat::DIGIT; 3376 break; 3377 } 3378 pArr[2].Value <<= nVal; 3379 //--->i53420 3380 pArr[3].Name = C2U("ChapterLevel"); 3381 // 3382 pArr[3].Value <<= aToken.nOutlineLevel; 3383 //<--- 3384 } 3385 break; 3386 case TOKEN_LINK_START: 3387 { 3388 rCurTokenSeq.realloc( 2 ); 3389 beans::PropertyValue* pArr = rCurTokenSeq.getArray(); 3390 3391 pArr[0].Name = C2U("TokenType"); 3392 pArr[0].Value <<= 3393 OUString::createFromAscii("TokenHyperlinkStart"); 3394 pArr[1].Name = C2U("CharacterStyleName"); 3395 pArr[1].Value <<= aProgCharStyle; 3396 } 3397 break; 3398 case TOKEN_LINK_END: 3399 { 3400 rCurTokenSeq.realloc( 1 ); 3401 beans::PropertyValue* pArr = rCurTokenSeq.getArray(); 3402 3403 pArr[0].Name = C2U("TokenType"); 3404 pArr[0].Value <<= 3405 OUString::createFromAscii("TokenHyperlinkEnd"); 3406 } 3407 break; 3408 case TOKEN_AUTHORITY: 3409 { 3410 rCurTokenSeq.realloc( 3 ); 3411 beans::PropertyValue* pArr = rCurTokenSeq.getArray(); 3412 3413 pArr[0].Name = C2U("TokenType"); 3414 pArr[0].Value <<= 3415 OUString::createFromAscii("TokenBibliographyDataField"); 3416 3417 pArr[1].Name = C2U("CharacterStyleName"); 3418 pArr[1].Value <<= aProgCharStyle; 3419 3420 pArr[2].Name = C2U("BibliographyDataField"); 3421 pArr[2].Value <<= sal_Int16(aToken.nAuthorityField); 3422 } 3423 break; 3424 3425 default: 3426 ; 3427 } 3428 3429 aIt++; // #i21237# 3430 } 3431 3432 uno::Any aRet; 3433 aRet <<= aRetSeq; 3434 return aRet; 3435 } 3436 3437 /*-- 13.09.99 16:52:30--------------------------------------------------- 3438 3439 -----------------------------------------------------------------------*/ 3440 uno::Type SAL_CALL 3441 SwXDocumentIndex::TokenAccess_Impl::getElementType() 3442 throw (uno::RuntimeException) 3443 { 3444 return ::getCppuType((uno::Sequence< beans::PropertyValues >*)0); 3445 } 3446 /*-- 13.09.99 16:52:30--------------------------------------------------- 3447 3448 -----------------------------------------------------------------------*/ 3449 sal_Bool SAL_CALL 3450 SwXDocumentIndex::TokenAccess_Impl::hasElements() 3451 throw (uno::RuntimeException) 3452 { 3453 return sal_True; 3454 } 3455 3456