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 28 #define _SVSTDARR_STRINGSDTOR 29 #define _SVSTDARR_USHORTS 30 #define _SVSTDARR_LONGS 31 #define _SVSTDARR_ULONGS 32 #include <hintids.hxx> 33 34 #include <svl/svstdarr.hxx> 35 #include <editeng/unolingu.hxx> 36 #include <editeng/langitem.hxx> 37 #include <swtypes.hxx> 38 #include <tools/resid.hxx> 39 #include <comcore.hrc> 40 #include <authfld.hxx> 41 #include <expfld.hxx> 42 #include <pam.hxx> 43 #include <cntfrm.hxx> 44 #include <tox.hxx> 45 #include <txmsrt.hxx> 46 #include <doctxm.hxx> 47 #include <fmtfld.hxx> 48 #include <txtfld.hxx> 49 #include <ndtxt.hxx> 50 #include <doc.hxx> 51 #include <unofldmid.h> 52 #include <unoprnms.hxx> 53 #include <switerator.hxx> 54 #include <unomid.h> 55 56 using namespace ::com::sun::star::uno; 57 using namespace ::com::sun::star::beans; 58 using namespace ::com::sun::star::lang; 59 using rtl::OUString; 60 61 62 typedef SwAuthEntry* SwAuthEntryPtr; 63 SV_DECL_PTRARR_DEL( SwAuthDataArr, SwAuthEntryPtr, 5, 5 ) 64 SV_IMPL_PTRARR( SwAuthDataArr, SwAuthEntryPtr ) 65 66 67 typedef SwTOXSortKey* TOXSortKeyPtr; 68 SV_DECL_PTRARR_DEL( SortKeyArr, TOXSortKeyPtr, 5, 5 ) 69 SV_IMPL_PTRARR( SortKeyArr, TOXSortKeyPtr ) 70 71 72 SwAuthEntry::SwAuthEntry(const SwAuthEntry& rCopy) 73 : nRefCount(0) 74 { 75 for(sal_uInt16 i = 0; i < AUTH_FIELD_END; i++) 76 aAuthFields[i] = rCopy.aAuthFields[i]; 77 } 78 // -------------------------------------------------------- 79 sal_Bool SwAuthEntry::operator==(const SwAuthEntry& rComp) 80 { 81 for(sal_uInt16 i = 0; i < AUTH_FIELD_END; i++) 82 if(aAuthFields[i] != rComp.aAuthFields[i]) 83 return sal_False; 84 return sal_True; 85 } 86 // -------------------------------------------------------- 87 SwAuthorityFieldType::SwAuthorityFieldType(SwDoc* pDoc) 88 : SwFieldType( RES_AUTHORITY ), 89 m_pDoc(pDoc), 90 m_pDataArr(new SwAuthDataArr ), 91 m_pSequArr(new SvLongs(5, 5)), 92 m_pSortKeyArr(new SortKeyArr(3, 3)), 93 m_cPrefix('['), 94 m_cSuffix(']'), 95 m_bIsSequence(sal_False), 96 m_bSortByDocument(sal_True), 97 m_eLanguage((LanguageType)::GetAppLanguage()) 98 { 99 } 100 101 SwAuthorityFieldType::SwAuthorityFieldType( const SwAuthorityFieldType& rFType) 102 : SwFieldType( RES_AUTHORITY ), 103 m_pDataArr(new SwAuthDataArr ), 104 m_pSequArr(new SvLongs(5, 5)), 105 m_pSortKeyArr(new SortKeyArr(3, 3)), 106 m_cPrefix(rFType.m_cPrefix), 107 m_cSuffix(rFType.m_cSuffix), 108 m_bIsSequence(rFType.m_bIsSequence), 109 m_bSortByDocument(rFType.m_bSortByDocument), 110 m_eLanguage(rFType.m_eLanguage), 111 m_sSortAlgorithm(rFType.m_sSortAlgorithm) 112 { 113 for(sal_uInt16 i = 0; i < rFType.m_pSortKeyArr->Count(); i++) 114 m_pSortKeyArr->Insert((*rFType.m_pSortKeyArr)[i], i); 115 } 116 117 SwAuthorityFieldType::~SwAuthorityFieldType() 118 { 119 // DBG_ASSERT(!m_pDataArr->Count(), "Array is not empty"); 120 m_pSortKeyArr->DeleteAndDestroy(0, m_pSortKeyArr->Count()); 121 delete m_pSortKeyArr; 122 delete m_pSequArr; 123 delete m_pDataArr; 124 } 125 126 SwFieldType* SwAuthorityFieldType::Copy() const 127 { 128 return new SwAuthorityFieldType(m_pDoc); 129 } 130 131 void SwAuthorityFieldType::RemoveField(long nHandle) 132 { 133 #ifdef DBG_UTIL 134 sal_Bool bRemoved = sal_False; 135 #endif 136 for(sal_uInt16 j = 0; j < m_pDataArr->Count(); j++) 137 { 138 SwAuthEntry* pTemp = m_pDataArr->GetObject(j); 139 long nRet = (long)(void*)pTemp; 140 if(nRet == nHandle) 141 { 142 #ifdef DBG_UTIL 143 bRemoved = sal_True; 144 #endif 145 pTemp->RemoveRef(); 146 if(!pTemp->GetRefCount()) 147 { 148 m_pDataArr->DeleteAndDestroy(j, 1); 149 //re-generate positions of the fields 150 DelSequenceArray(); 151 } 152 break; 153 } 154 } 155 #ifdef DBG_UTIL 156 DBG_ASSERT(bRemoved, "Field unknown" ); 157 #endif 158 } 159 160 long SwAuthorityFieldType::AddField(const String& rFieldContents) 161 { 162 long nRet = 0; 163 SwAuthEntry* pEntry = new SwAuthEntry; 164 for( sal_uInt16 i = 0; i < AUTH_FIELD_END; ++i ) 165 pEntry->SetAuthorField( (ToxAuthorityField)i, 166 rFieldContents.GetToken( i, TOX_STYLE_DELIMITER )); 167 168 for(sal_uInt16 j = 0; j < m_pDataArr->Count() && pEntry; j++) 169 { 170 SwAuthEntry* pTemp = m_pDataArr->GetObject(j); 171 if(*pTemp == *pEntry) 172 { 173 DELETEZ(pEntry); 174 nRet = (long)(void*)pTemp; 175 pTemp->AddRef(); 176 } 177 } 178 //if it is a new Entry - insert 179 if(pEntry) 180 { 181 nRet = (long)(void*)pEntry; 182 pEntry->AddRef(); 183 m_pDataArr->Insert(pEntry, m_pDataArr->Count()); 184 //re-generate positions of the fields 185 DelSequenceArray(); 186 } 187 return nRet; 188 } 189 190 sal_Bool SwAuthorityFieldType::AddField(long nHandle) 191 { 192 sal_Bool bRet = sal_False; 193 for( sal_uInt16 j = 0; j < m_pDataArr->Count(); j++ ) 194 { 195 SwAuthEntry* pTemp = m_pDataArr->GetObject(j); 196 long nTmp = (long)(void*)pTemp; 197 if( nTmp == nHandle ) 198 { 199 bRet = sal_True; 200 pTemp->AddRef(); 201 //re-generate positions of the fields 202 DelSequenceArray(); 203 break; 204 } 205 } 206 DBG_ASSERT(bRet, "::AddField(long) failed"); 207 return bRet; 208 } 209 210 const SwAuthEntry* SwAuthorityFieldType::GetEntryByHandle(long nHandle) const 211 { 212 const SwAuthEntry* pRet = 0; 213 for(sal_uInt16 j = 0; j < m_pDataArr->Count(); j++) 214 { 215 const SwAuthEntry* pTemp = m_pDataArr->GetObject(j); 216 long nTmp = (long)(void*)pTemp; 217 if( nTmp == nHandle ) 218 { 219 pRet = pTemp; 220 break; 221 } 222 } 223 ASSERT( pRet, "invalid Handle" ); 224 return pRet; 225 } 226 227 void SwAuthorityFieldType::GetAllEntryIdentifiers( 228 SvStringsDtor& rToFill )const 229 { 230 for(sal_uInt16 j = 0; j < m_pDataArr->Count(); j++) 231 { 232 SwAuthEntry* pTemp = m_pDataArr->GetObject(j); 233 rToFill.Insert( new String( pTemp->GetAuthorField( 234 AUTH_FIELD_IDENTIFIER )), rToFill.Count() ); 235 } 236 } 237 238 const SwAuthEntry* SwAuthorityFieldType::GetEntryByIdentifier( 239 const String& rIdentifier)const 240 { 241 const SwAuthEntry* pRet = 0; 242 for( sal_uInt16 j = 0; j < m_pDataArr->Count(); ++j ) 243 { 244 const SwAuthEntry* pTemp = m_pDataArr->GetObject(j); 245 if( rIdentifier == pTemp->GetAuthorField( AUTH_FIELD_IDENTIFIER )) 246 { 247 pRet = pTemp; 248 break; 249 } 250 } 251 return pRet; 252 } 253 254 bool SwAuthorityFieldType::ChangeEntryContent(const SwAuthEntry* pNewEntry) 255 { 256 bool bChanged = false; 257 for( sal_uInt16 j = 0; j < m_pDataArr->Count(); ++j ) 258 { 259 SwAuthEntry* pTemp = m_pDataArr->GetObject(j); 260 if(pTemp->GetAuthorField(AUTH_FIELD_IDENTIFIER) == 261 pNewEntry->GetAuthorField(AUTH_FIELD_IDENTIFIER)) 262 { 263 for(sal_uInt16 i = 0; i < AUTH_FIELD_END; i++) 264 pTemp->SetAuthorField((ToxAuthorityField) i, 265 pNewEntry->GetAuthorField((ToxAuthorityField)i)); 266 bChanged = true; 267 break; 268 } 269 } 270 return bChanged; 271 } 272 273 /*------------------------------------------------------------------------- 274 appends a new entry (if new) and returns the array position 275 -----------------------------------------------------------------------*/ 276 sal_uInt16 SwAuthorityFieldType::AppendField( const SwAuthEntry& rInsert ) 277 { 278 sal_uInt16 nRet = 0; 279 for( nRet = 0; nRet < m_pDataArr->Count(); ++nRet ) 280 { 281 SwAuthEntry* pTemp = m_pDataArr->GetObject( nRet ); 282 if( *pTemp == rInsert ) 283 { 284 break; 285 //ref count unchanged 286 } 287 } 288 289 //if it is a new Entry - insert 290 if( nRet == m_pDataArr->Count() ) 291 m_pDataArr->Insert( new SwAuthEntry( rInsert ), nRet ); 292 293 return nRet; 294 } 295 296 long SwAuthorityFieldType::GetHandle(sal_uInt16 nPos) 297 { 298 long nRet = 0; 299 if( nPos < m_pDataArr->Count() ) 300 { 301 SwAuthEntry* pTemp = m_pDataArr->GetObject(nPos); 302 nRet = (long)(void*)pTemp; 303 } 304 return nRet; 305 } 306 307 sal_uInt16 SwAuthorityFieldType::GetSequencePos(long nHandle) 308 { 309 //find the field in a sorted array of handles, 310 #ifdef DBG_UTIL 311 sal_Bool bCurrentFieldWithoutTextNode = sal_False; 312 #endif 313 if(m_pSequArr->Count() && m_pSequArr->Count() != m_pDataArr->Count()) 314 DelSequenceArray(); 315 if(!m_pSequArr->Count()) 316 { 317 SwTOXSortTabBases aSortArr; 318 SwIterator<SwFmtFld,SwFieldType> aIter( *this ); 319 320 SwTOXInternational aIntl(m_eLanguage, 0, m_sSortAlgorithm); 321 322 for( SwFmtFld* pFmtFld = aIter.First(); pFmtFld; pFmtFld = aIter.Next() ) 323 { 324 const SwTxtFld* pTxtFld = pFmtFld->GetTxtFld(); 325 if(!pTxtFld || !pTxtFld->GetpTxtNode()) 326 { 327 #ifdef DBG_UTIL 328 if(nHandle == ((SwAuthorityField*)pFmtFld->GetField())->GetHandle()) 329 bCurrentFieldWithoutTextNode = sal_True; 330 #endif 331 continue; 332 } 333 const SwTxtNode& rFldTxtNode = pTxtFld->GetTxtNode(); 334 SwPosition aFldPos(rFldTxtNode); 335 SwDoc& rDoc = *(SwDoc*)rFldTxtNode.GetDoc(); 336 SwCntntFrm *pFrm = rFldTxtNode.getLayoutFrm( rDoc.GetCurrentLayout() ); 337 const SwTxtNode* pTxtNode = 0; 338 if(pFrm && !pFrm->IsInDocBody()) 339 pTxtNode = GetBodyTxtNode( rDoc, aFldPos, *pFrm ); 340 //if no text node could be found or the field is in the document 341 //body the directly available text node will be used 342 if(!pTxtNode) 343 pTxtNode = &rFldTxtNode; 344 if( pTxtNode->GetTxt().Len() && pTxtNode->getLayoutFrm( rDoc.GetCurrentLayout() ) && 345 pTxtNode->GetNodes().IsDocNodes() ) 346 { 347 SwTOXAuthority* pNew = new SwTOXAuthority( *pTxtNode, 348 *pFmtFld, aIntl ); 349 350 for(short i = 0; i < aSortArr.Count(); ++i) 351 { 352 SwTOXSortTabBase* pOld = aSortArr[i]; 353 if(*pOld == *pNew) 354 { 355 //only the first occurence in the document 356 //has to be in the array 357 if(*pOld < *pNew) 358 DELETEZ(pNew); 359 else // remove the old content 360 aSortArr.DeleteAndDestroy( i, 1 ); 361 break; 362 } 363 } 364 //if it still exists - insert at the correct position 365 if(pNew) 366 { 367 short j; 368 369 for( j = 0; j < aSortArr.Count(); ++j) 370 { 371 SwTOXSortTabBase* pOld = aSortArr[j]; 372 if(*pNew < *pOld) 373 break; 374 } 375 aSortArr.Insert(pNew, j ); 376 } 377 } 378 } 379 380 for(sal_uInt16 i = 0; i < aSortArr.Count(); i++) 381 { 382 const SwTOXSortTabBase& rBase = *aSortArr[i]; 383 SwFmtFld& rFmtFld = ((SwTOXAuthority&)rBase).GetFldFmt(); 384 SwAuthorityField* pAFld = (SwAuthorityField*)rFmtFld.GetField(); 385 m_pSequArr->Insert(pAFld->GetHandle(), i); 386 } 387 aSortArr.DeleteAndDestroy(0, aSortArr.Count()); 388 } 389 //find nHandle 390 sal_uInt16 nRet = 0; 391 for(sal_uInt16 i = 0; i < m_pSequArr->Count(); i++) 392 { 393 if((*m_pSequArr)[i] == nHandle) 394 { 395 nRet = i + 1; 396 break; 397 } 398 } 399 ASSERT(bCurrentFieldWithoutTextNode || nRet, "Handle not found") 400 return nRet; 401 } 402 403 sal_Bool SwAuthorityFieldType::QueryValue( Any& rVal, sal_uInt16 nWhichId ) const 404 { 405 switch( nWhichId ) 406 { 407 case FIELD_PROP_PAR1: 408 case FIELD_PROP_PAR2: 409 { 410 OUString sVal; 411 sal_Unicode uRet = FIELD_PROP_PAR1 == nWhichId ? m_cPrefix : m_cSuffix; 412 if(uRet) 413 sVal = OUString(uRet); 414 rVal <<= sVal; 415 } 416 break; 417 case FIELD_PROP_PAR3: 418 rVal <<= OUString(GetSortAlgorithm()); 419 break; 420 421 case FIELD_PROP_BOOL1: 422 case FIELD_PROP_BOOL2: 423 { 424 sal_Bool bVal = FIELD_PROP_BOOL1 == nWhichId ? m_bIsSequence: m_bSortByDocument; 425 rVal.setValue(&bVal, ::getBooleanCppuType()); 426 } 427 break; 428 429 case FIELD_PROP_LOCALE: 430 rVal <<= SvxCreateLocale(GetLanguage()); 431 break; 432 433 case FIELD_PROP_PROP_SEQ: 434 { 435 Sequence<PropertyValues> aRet(m_pSortKeyArr->Count()); 436 PropertyValues* pValues = aRet.getArray(); 437 OUString sProp1( C2U(SW_PROP_NAME_STR(UNO_NAME_SORT_KEY)) ), 438 sProp2( C2U(SW_PROP_NAME_STR(UNO_NAME_IS_SORT_ASCENDING))); 439 for(sal_uInt16 i = 0; i < m_pSortKeyArr->Count(); i++) 440 { 441 const SwTOXSortKey* pKey = (*m_pSortKeyArr)[i]; 442 pValues[i].realloc(2); 443 PropertyValue* pValue = pValues[i].getArray(); 444 pValue[0].Name = sProp1; 445 pValue[0].Value <<= sal_Int16(pKey->eField); 446 pValue[1].Name = sProp2; 447 pValue[1].Value.setValue(&pKey->bSortAscending, ::getBooleanCppuType()); 448 } 449 rVal <<= aRet; 450 } 451 break; 452 default: 453 DBG_ERROR("illegal property"); 454 } 455 return sal_True; 456 } 457 458 sal_Bool SwAuthorityFieldType::PutValue( const Any& rAny, sal_uInt16 nWhichId ) 459 { 460 sal_Bool bRet = sal_True; 461 String sTmp; 462 switch( nWhichId ) 463 { 464 case FIELD_PROP_PAR1: 465 case FIELD_PROP_PAR2: 466 { 467 ::GetString( rAny, sTmp ); 468 sal_Unicode uSet = sTmp.GetChar(0); 469 if( FIELD_PROP_PAR1 == nWhichId ) 470 m_cPrefix = uSet; 471 else 472 m_cSuffix = uSet; 473 } 474 break; 475 case FIELD_PROP_PAR3: 476 SetSortAlgorithm( ::GetString( rAny, sTmp )); 477 break; 478 479 case FIELD_PROP_BOOL1: 480 m_bIsSequence = *(sal_Bool*)rAny.getValue(); 481 break; 482 case FIELD_PROP_BOOL2: 483 m_bSortByDocument = *(sal_Bool*)rAny.getValue(); 484 break; 485 486 case FIELD_PROP_LOCALE: 487 { 488 Locale aLocale; 489 if( 0 != (bRet = rAny >>= aLocale )) 490 SetLanguage( SvxLocaleToLanguage( aLocale )); 491 } 492 break; 493 494 case FIELD_PROP_PROP_SEQ: 495 { 496 Sequence<PropertyValues> aSeq; 497 if( 0 != (bRet = rAny >>= aSeq) ) 498 { 499 m_pSortKeyArr->DeleteAndDestroy(0, m_pSortKeyArr->Count()); 500 const PropertyValues* pValues = aSeq.getConstArray(); 501 for(sal_Int32 i = 0; i < aSeq.getLength() && i < USHRT_MAX / 4; i++) 502 { 503 const PropertyValue* pValue = pValues[i].getConstArray(); 504 SwTOXSortKey* pSortKey = new SwTOXSortKey; 505 for(sal_Int32 j = 0; j < pValues[i].getLength(); j++) 506 { 507 if(pValue[j].Name.equalsAsciiL(SW_PROP_NAME(UNO_NAME_SORT_KEY))) 508 { 509 sal_Int16 nVal = -1; pValue[j].Value >>= nVal; 510 if(nVal >= 0 && nVal < AUTH_FIELD_END) 511 pSortKey->eField = (ToxAuthorityField) nVal; 512 else 513 bRet = sal_False; 514 } 515 else if(pValue[j].Name.equalsAsciiL(SW_PROP_NAME(UNO_NAME_IS_SORT_ASCENDING))) 516 { 517 pSortKey->bSortAscending = *(sal_Bool*)pValue[j].Value.getValue(); 518 } 519 } 520 m_pSortKeyArr->Insert(pSortKey, m_pSortKeyArr->Count()); 521 } 522 } 523 } 524 break; 525 default: 526 DBG_ERROR("illegal property"); 527 } 528 return bRet; 529 } 530 531 void SwAuthorityFieldType::Modify( const SfxPoolItem* pOld, const SfxPoolItem *pNew ) 532 { 533 //re-generate positions of the fields 534 DelSequenceArray(); 535 NotifyClients( pOld, pNew ); 536 } 537 538 sal_uInt16 SwAuthorityFieldType::GetSortKeyCount() const 539 { 540 return m_pSortKeyArr->Count(); 541 } 542 543 const SwTOXSortKey* SwAuthorityFieldType::GetSortKey(sal_uInt16 nIdx) const 544 { 545 SwTOXSortKey* pRet = 0; 546 if(m_pSortKeyArr->Count() > nIdx) 547 pRet = (*m_pSortKeyArr)[nIdx]; 548 DBG_ASSERT(pRet, "Sort key not found"); 549 return pRet; 550 } 551 552 void SwAuthorityFieldType::SetSortKeys(sal_uInt16 nKeyCount, SwTOXSortKey aKeys[]) 553 { 554 m_pSortKeyArr->DeleteAndDestroy(0, m_pSortKeyArr->Count()); 555 sal_uInt16 nArrIdx = 0; 556 for(sal_uInt16 i = 0; i < nKeyCount; i++) 557 if(aKeys[i].eField < AUTH_FIELD_END) 558 m_pSortKeyArr->Insert(new SwTOXSortKey(aKeys[i]), nArrIdx++); 559 } 560 561 SwAuthorityField::SwAuthorityField( SwAuthorityFieldType* pInitType, 562 const String& rFieldContents ) 563 : SwField(pInitType), 564 m_nTempSequencePos( -1 ) 565 { 566 m_nHandle = pInitType->AddField( rFieldContents ); 567 } 568 569 SwAuthorityField::SwAuthorityField( SwAuthorityFieldType* pInitType, 570 long nSetHandle ) 571 : SwField( pInitType ), 572 m_nHandle( nSetHandle ), 573 m_nTempSequencePos( -1 ) 574 { 575 pInitType->AddField( m_nHandle ); 576 } 577 578 SwAuthorityField::~SwAuthorityField() 579 { 580 ((SwAuthorityFieldType* )GetTyp())->RemoveField(m_nHandle); 581 } 582 583 String SwAuthorityField::Expand() const 584 { 585 SwAuthorityFieldType* pAuthType = (SwAuthorityFieldType*)GetTyp(); 586 String sRet; 587 if(pAuthType->GetPrefix()) 588 sRet.Assign(pAuthType->GetPrefix()); 589 590 if( pAuthType->IsSequence() ) 591 { 592 if(!pAuthType->GetDoc()->IsExpFldsLocked()) 593 m_nTempSequencePos = pAuthType->GetSequencePos( m_nHandle ); 594 if( m_nTempSequencePos >= 0 ) 595 sRet += String::CreateFromInt32( m_nTempSequencePos ); 596 } 597 else 598 { 599 const SwAuthEntry* pEntry = pAuthType->GetEntryByHandle(m_nHandle); 600 //TODO: Expand to: identifier, number sequence, ... 601 if(pEntry) 602 sRet += pEntry->GetAuthorField(AUTH_FIELD_IDENTIFIER); 603 } 604 if(pAuthType->GetSuffix()) 605 sRet += pAuthType->GetSuffix(); 606 return sRet; 607 } 608 609 SwField* SwAuthorityField::Copy() const 610 { 611 SwAuthorityFieldType* pAuthType = (SwAuthorityFieldType*)GetTyp(); 612 return new SwAuthorityField(pAuthType, m_nHandle); 613 } 614 615 const String& SwAuthorityField::GetFieldText(ToxAuthorityField eField) const 616 { 617 SwAuthorityFieldType* pAuthType = (SwAuthorityFieldType*)GetTyp(); 618 const SwAuthEntry* pEntry = pAuthType->GetEntryByHandle( m_nHandle ); 619 return pEntry->GetAuthorField( eField ); 620 } 621 622 void SwAuthorityField::SetPar1(const String& rStr) 623 { 624 SwAuthorityFieldType* pInitType = (SwAuthorityFieldType* )GetTyp(); 625 pInitType->RemoveField(m_nHandle); 626 m_nHandle = pInitType->AddField(rStr); 627 } 628 629 String SwAuthorityField::GetDescription() const 630 { 631 return SW_RES(STR_AUTHORITY_ENTRY); 632 } 633 634 635 const char* aFieldNames[] = 636 { 637 "Identifier", 638 "BibiliographicType", 639 "Address", 640 "Annote", 641 "Author", 642 "Booktitle", 643 "Chapter", 644 "Edition", 645 "Editor", 646 "Howpublished", 647 "Institution", 648 "Journal", 649 "Month", 650 "Note", 651 "Number", 652 "Organizations", 653 "Pages", 654 "Publisher", 655 "School", 656 "Series", 657 "Title", 658 "Report_Type", 659 "Volume", 660 "Year", 661 "URL", 662 "Custom1", 663 "Custom2", 664 "Custom3", 665 "Custom4", 666 "Custom5", 667 "ISBN" 668 }; 669 670 sal_Bool SwAuthorityField::QueryValue( Any& rAny, sal_uInt16 /*nWhichId*/ ) const 671 { 672 if(!GetTyp()) 673 return sal_False; 674 const SwAuthEntry* pAuthEntry = ((SwAuthorityFieldType*)GetTyp())->GetEntryByHandle(m_nHandle); 675 if(!pAuthEntry) 676 return sal_False; 677 Sequence <PropertyValue> aRet(AUTH_FIELD_END); 678 PropertyValue* pValues = aRet.getArray(); 679 for(sal_Int16 i = 0; i < AUTH_FIELD_END; i++) 680 { 681 pValues[i].Name = C2U(aFieldNames[i]); 682 const String& rField = pAuthEntry->GetAuthorField((ToxAuthorityField) i); 683 if(i == AUTH_FIELD_AUTHORITY_TYPE) 684 pValues[i].Value <<= sal_Int16(rField.ToInt32()); 685 else 686 pValues[i].Value <<= OUString(rField); 687 } 688 rAny <<= aRet; 689 return sal_False; 690 } 691 692 sal_Int16 lcl_Find(const OUString& rFieldName) 693 { 694 for(sal_Int16 i = 0; i < AUTH_FIELD_END; i++) 695 if(!rFieldName.compareToAscii(aFieldNames[i])) 696 return i; 697 return -1; 698 } 699 //---------------------------------------------------------------------------- 700 sal_Bool SwAuthorityField::PutValue( const Any& rAny, sal_uInt16 /*nWhichId*/ ) 701 { 702 if(!GetTyp() || !((SwAuthorityFieldType*)GetTyp())->GetEntryByHandle(m_nHandle)) 703 return sal_False; 704 705 Sequence <PropertyValue> aParam; 706 if(!(rAny >>= aParam)) 707 return sal_False; 708 709 String sToSet; 710 sToSet.Fill(AUTH_FIELD_ISBN, TOX_STYLE_DELIMITER); 711 const PropertyValue* pParam = aParam.getConstArray(); 712 for(sal_Int32 i = 0; i < aParam.getLength(); i++) 713 { 714 sal_Int16 nFound = lcl_Find(pParam[i].Name); 715 if(nFound >= 0) 716 { 717 OUString sContent; 718 if(AUTH_FIELD_AUTHORITY_TYPE == nFound) 719 { 720 sal_Int16 nVal = 0; 721 pParam[i].Value >>= nVal; 722 sContent = OUString::valueOf((sal_Int32)nVal); 723 } 724 else 725 pParam[i].Value >>= sContent; 726 sToSet.SetToken(nFound, TOX_STYLE_DELIMITER, sContent); 727 } 728 } 729 730 ((SwAuthorityFieldType*)GetTyp())->RemoveField(m_nHandle); 731 m_nHandle = ((SwAuthorityFieldType*)GetTyp())->AddField(sToSet); 732 733 return sal_False; 734 } 735 736 SwFieldType* SwAuthorityField::ChgTyp( SwFieldType* pFldTyp ) 737 { 738 SwAuthorityFieldType* pSrcTyp = (SwAuthorityFieldType*)GetTyp(), 739 * pDstTyp = (SwAuthorityFieldType*)pFldTyp; 740 if( pSrcTyp != pDstTyp ) 741 { 742 743 const SwAuthEntry* pEntry = pSrcTyp->GetEntryByHandle( m_nHandle ); 744 sal_uInt16 nHdlPos = pDstTyp->AppendField( *pEntry ); 745 pSrcTyp->RemoveField( m_nHandle ); 746 m_nHandle = pDstTyp->GetHandle( nHdlPos ); 747 pDstTyp->AddField( m_nHandle ); 748 SwField::ChgTyp( pFldTyp ); 749 } 750 return pSrcTyp; 751 } 752 753