sw/source/core/fields/authfld.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <sal/config.h>
  21
  22 #include <memory>
  23
  24 #include <libxml/xmlwriter.h>
  25
  26 #include <comphelper/processfactory.hxx>
  27 #include <comphelper/string.hxx>
  28 #include <i18nlangtag/languagetag.hxx>
  29 #include <o3tl/any.hxx>
  30 #include <o3tl/string_view.hxx>
  31 #include <officecfg/Office/Common.hxx>
  32 #include <osl/diagnose.h>
  33 #include <tools/urlobj.hxx>
  34 #include <swtypes.hxx>
  35 #include <strings.hrc>
  36 #include <authfld.hxx>
  37 #include <expfld.hxx>
  38 #include <pam.hxx>
  39 #include <cntfrm.hxx>
  40 #include <rootfrm.hxx>
  41 #include <tox.hxx>
  42 #include <txmsrt.hxx>
  43 #include <fmtfld.hxx>
  44 #include <txtfld.hxx>
  45 #include <ndtxt.hxx>
  46 #include <doc.hxx>
  47 #include <IDocumentFieldsAccess.hxx>
  48 #include <IDocumentLayoutAccess.hxx>
  49 #include <unofldmid.h>
  50 #include <unoprnms.hxx>
  51 #include <docsh.hxx>
  52
  53 #include <com/sun/star/beans/PropertyValues.hpp>
  54 #include <com/sun/star/uri/UriReferenceFactory.hpp>
  55
  56 using namespace ::com::sun::star::uno;
  57 using namespace ::com::sun::star::beans;
  58 using namespace ::com::sun::star::lang;
  59
  60 SwAuthEntry::SwAuthEntry(const SwAuthEntry& rCopy)
  61     : SimpleReferenceObject()
  62 {
  63     for(int i = 0; i < AUTH_FIELD_END; ++i)
  64         m_aAuthFields[i] = rCopy.m_aAuthFields[i];
  65 }
  66
  67 bool SwAuthEntry::operator==(const SwAuthEntry& rComp) const
  68 {
  69     for(int i = 0; i < AUTH_FIELD_END; ++i)
  70         if(m_aAuthFields[i] != rComp.m_aAuthFields[i])
  71             return false;
  72     return true;
  73 }
  74
  75 SwAuthorityFieldType::SwAuthorityFieldType(SwDoc* pDoc)
  76     : SwFieldType( SwFieldIds::TableOfAuthorities ),
  77     m_pDoc(pDoc),
  78     m_cPrefix('['),
  79     m_cSuffix(']'),
  80     m_bIsSequence(false),
  81     m_bSortByDocument(true),
  82     m_eLanguage(::GetAppLanguage())
  83 {
  84 }
  85
  86 SwAuthorityFieldType::~SwAuthorityFieldType()
  87 {
  88 }
  89
  90 std::unique_ptr<SwFieldType> SwAuthorityFieldType::Copy()  const
  91 {
  92     return std::make_unique<SwAuthorityFieldType>(m_pDoc);
  93 }
  94
  95 void SwAuthorityFieldType::RemoveField(const SwAuthEntry* pEntry)
  96 {
  97     for(SwAuthDataArr::size_type j = 0; j < m_DataArr.size(); ++j)
  98     {
  99         if(m_DataArr[j].get() == pEntry)
 100         {
 101             if (m_DataArr[j]->m_nCount <= 1)
 102             {
 103                 m_DataArr.erase(m_DataArr.begin() + j);
 104                 //re-generate positions of the fields
 105                 DelSequenceArray();
 106             }
 107             return;
 108         }
 109     }
 110     assert(false && "SwAuthorityFieldType::RemoveField: pEntry was not added previously");
 111 }
 112
 113 SwAuthEntry* SwAuthorityFieldType::AddField(std::u16string_view rFieldContents)
 114 {
 115     rtl::Reference<SwAuthEntry> pEntry(new SwAuthEntry);
 116     sal_Int32 nIdx{ 0 };
 117     for( sal_Int32 i = 0; i < AUTH_FIELD_END; ++i )
 118         pEntry->SetAuthorField( static_cast<ToxAuthorityField>(i),
 119                         OUString(o3tl::getToken(rFieldContents, 0, TOX_STYLE_DELIMITER, nIdx )));
 120
 121     for (const auto &rpTemp : m_DataArr)
 122     {
 123         if (*rpTemp == *pEntry)
 124         {
 125             return rpTemp.get();
 126         }
 127     }
 128
 129     //if it is a new Entry - insert
 130     m_DataArr.push_back(std::move(pEntry));
 131     //re-generate positions of the fields
 132     DelSequenceArray();
 133     return m_DataArr.back().get();
 134 }
 135
 136 void SwAuthorityFieldType::GetAllEntryIdentifiers(
 137     std::vector<OUString>& rToFill )const
 138 {
 139     for (const auto & rpTemp : m_DataArr)
 140     {
 141         rToFill.push_back(rpTemp->GetAuthorField(AUTH_FIELD_IDENTIFIER));
 142     }
 143 }
 144
 145 SwAuthEntry* SwAuthorityFieldType::GetEntryByIdentifier(
 146                                 std::u16string_view rIdentifier)const
 147 {
 148     for (const auto &rpTemp : m_DataArr)
 149     {
 150         if (rIdentifier == rpTemp->GetAuthorField(AUTH_FIELD_IDENTIFIER))
 151         {
 152             return rpTemp.get();
 153         }
 154     }
 155     return nullptr;
 156 }
 157
 158 bool SwAuthorityFieldType::ChangeEntryContent(const SwAuthEntry* pNewEntry)
 159 {
 160     for (auto &rpTemp : m_DataArr)
 161     {
 162         if (rpTemp->GetAuthorField(AUTH_FIELD_IDENTIFIER) ==
 163                     pNewEntry->GetAuthorField(AUTH_FIELD_IDENTIFIER))
 164         {
 165             for(int i = 0; i < AUTH_FIELD_END; ++i)
 166             {
 167                 rpTemp->SetAuthorField(static_cast<ToxAuthorityField>(i),
 168                     pNewEntry->GetAuthorField(static_cast<ToxAuthorityField>(i)));
 169             }
 170             return true;
 171         }
 172     }
 173     return false;
 174 }
 175
 176 /// appends a new entry (if new) and returns the copied entry
 177 SwAuthEntry* SwAuthorityFieldType::AppendField( const SwAuthEntry& rInsert )
 178 {
 179     for( SwAuthDataArr::size_type nRet = 0; nRet < m_DataArr.size(); ++nRet )
 180     {
 181         if( *m_DataArr[ nRet ] == rInsert )
 182             return m_DataArr[ nRet ].get();
 183     }
 184
 185     //if it is a new Entry - insert
 186     m_DataArr.push_back(new SwAuthEntry(rInsert));
 187     return m_DataArr.back().get();
 188 }
 189
 190 std::unique_ptr<SwTOXInternational> SwAuthorityFieldType::CreateTOXInternational() const
 191 {
 192     return std::make_unique<SwTOXInternational>(m_eLanguage, SwTOIOptions::NONE, m_sSortAlgorithm);
 193 }
 194
 195 sal_uInt16 SwAuthorityFieldType::GetSequencePos(const SwAuthEntry* pAuthEntry,
 196         SwRootFrame const*const pLayout)
 197 {
 198     //find the field in a sorted array of handles,
 199     if(!m_SequArr.empty() && m_SequArr.size() != m_DataArr.size())
 200         DelSequenceArray();
 201     if(m_SequArr.empty())
 202     {
 203         IDocumentRedlineAccess const& rIDRA(m_pDoc->getIDocumentRedlineAccess());
 204         std::unique_ptr<SwTOXInternational> pIntl = CreateTOXInternational();
 205         // sw_redlinehide: need 2 arrays because the sorting may be different,
 206         // if multiple fields refer to the same entry and first one is deleted
 207         std::vector<std::unique_ptr<SwTOXSortTabBase>> aSortArr;
 208         std::vector<std::unique_ptr<SwTOXSortTabBase>> aSortArrRLHidden;
 209         std::vector<SwFormatField*> vFields;
 210         GatherFields(vFields);
 211         for(SwFormatField* pFormatField : vFields)
 212         {
 213             const SwTextField* pTextField = pFormatField->GetTextField();
 214             if(!pTextField || !pTextField->GetpTextNode())
 215             {
 216                 continue;
 217             }
 218             const SwTextNode& rFieldTextNode = pTextField->GetTextNode();
 219             SwPosition aFieldPos(rFieldTextNode);
 220             SwDoc& rDoc = const_cast<SwDoc&>(rFieldTextNode.GetDoc());
 221             SwContentFrame *pFrame = rFieldTextNode.getLayoutFrame( rDoc.getIDocumentLayoutAccess().GetCurrentLayout() );
 222             const SwTextNode* pTextNode = nullptr;
 223             if(pFrame && !pFrame->IsInDocBody())
 224                 pTextNode = GetBodyTextNode( rDoc, aFieldPos, *pFrame );
 225             //if no text node could be found or the field is in the document
 226             //body the directly available text node will be used
 227             if(!pTextNode)
 228                 pTextNode = &rFieldTextNode;
 229             if (pTextNode->GetText().isEmpty()
 230                 || !pTextNode->getLayoutFrame(rDoc.getIDocumentLayoutAccess().GetCurrentLayout())
 231                 || !pTextNode->GetNodes().IsDocNodes())
 232             {
 233                 continue;
 234             }
 235             auto const InsertImpl = [&pIntl, pTextNode, pFormatField]
 236                 (std::vector<std::unique_ptr<SwTOXSortTabBase>> & rSortArr)
 237             {
 238                 std::unique_ptr<SwTOXAuthority> pNew(
 239                     new SwTOXAuthority(*pTextNode, *pFormatField, *pIntl));
 240
 241                 for (size_t i = 0; i < rSortArr.size(); ++i)
 242                 {
 243                     SwTOXSortTabBase* pOld = rSortArr[i].get();
 244                     if (pOld->equivalent(*pNew))
 245                     {
 246                         //only the first occurrence in the document
 247                         //has to be in the array
 248                         if (pOld->sort_lt(*pNew))
 249                             pNew.reset();
 250                         else // remove the old content
 251                             rSortArr.erase(rSortArr.begin() + i);
 252                         break;
 253                     }
 254                 }
 255                 //if it still exists - insert at the correct position
 256                 if (pNew)
 257                 {
 258                     size_t j {0};
 259
 260                     while (j < rSortArr.size())
 261                     {
 262                         SwTOXSortTabBase* pOld = rSortArr[j].get();
 263                         if (pNew->sort_lt(*pOld))
 264                             break;
 265                         ++j;
 266                     }
 267                     rSortArr.insert(rSortArr.begin() + j, std::move(pNew));
 268                 }
 269             };
 270             InsertImpl(aSortArr);
 271             if (!sw::IsFieldDeletedInModel(rIDRA, *pTextField))
 272             {
 273                 InsertImpl(aSortArrRLHidden);
 274             }
 275         }
 276
 277         for(auto & pBase : aSortArr)
 278         {
 279             SwFormatField& rFormatField = static_cast<SwTOXAuthority&>(*pBase).GetFieldFormat();
 280             SwAuthorityField* pAField = static_cast<SwAuthorityField*>(rFormatField.GetField());
 281             m_SequArr.push_back(pAField->GetAuthEntry());
 282         }
 283         for (auto & pBase : aSortArrRLHidden)
 284         {
 285             SwFormatField& rFormatField = static_cast<SwTOXAuthority&>(*pBase).GetFieldFormat();
 286             SwAuthorityField* pAField = static_cast<SwAuthorityField*>(rFormatField.GetField());
 287             m_SequArrRLHidden.push_back(pAField->GetAuthEntry());
 288         }
 289     }
 290     //find nHandle
 291     auto const& rSequArr(pLayout && pLayout->IsHideRedlines() ? m_SequArrRLHidden : m_SequArr);
 292     for (std::vector<sal_IntPtr>::size_type i = 0; i < rSequArr.size(); ++i)
 293     {
 294         if (rSequArr[i] == pAuthEntry)
 295         {
 296             return i + 1;
 297         }
 298     }
 299     return 0;
 300 }
 301
 302 void SwAuthorityFieldType::QueryValue( Any& rVal, sal_uInt16 nWhichId ) const
 303 {
 304     switch( nWhichId )
 305     {
 306     case FIELD_PROP_PAR1:
 307     case FIELD_PROP_PAR2:
 308         {
 309             OUString sVal;
 310             sal_Unicode uRet = FIELD_PROP_PAR1 == nWhichId ? m_cPrefix : m_cSuffix;
 311             if(uRet)
 312                 sVal = OUString(uRet);
 313             rVal <<= sVal;
 314         }
 315         break;
 316     case FIELD_PROP_PAR3:
 317         rVal <<= GetSortAlgorithm();
 318         break;
 319
 320     case FIELD_PROP_BOOL1:
 321         rVal <<= m_bIsSequence;
 322         break;
 323
 324     case FIELD_PROP_BOOL2:
 325         rVal <<= m_bSortByDocument;
 326         break;
 327
 328     case FIELD_PROP_LOCALE:
 329         rVal <<= LanguageTag(GetLanguage()).getLocale();
 330         break;
 331
 332     case FIELD_PROP_PROP_SEQ:
 333         {
 334             Sequence<PropertyValues> aRet(m_SortKeyArr.size());
 335             PropertyValues* pValues = aRet.getArray();
 336             for(SortKeyArr::size_type i = 0; i < m_SortKeyArr.size(); ++i)
 337             {
 338                 const SwTOXSortKey* pKey = &m_SortKeyArr[i];
 339                 pValues[i].realloc(2);
 340                 PropertyValue* pValue = pValues[i].getArray();
 341                 pValue[0].Name = UNO_NAME_SORT_KEY;
 342                 pValue[0].Value <<= sal_Int16(pKey->eField);
 343                 pValue[1].Name = UNO_NAME_IS_SORT_ASCENDING;
 344                 pValue[1].Value <<= pKey->bSortAscending;
 345             }
 346             rVal <<= aRet;
 347         }
 348         break;
 349     default:
 350         assert(false);
 351     }
 352 }
 353
 354 void SwAuthorityFieldType::PutValue( const Any& rAny, sal_uInt16 nWhichId )
 355 {
 356     switch( nWhichId )
 357     {
 358     case FIELD_PROP_PAR1:
 359     case FIELD_PROP_PAR2:
 360     {
 361         OUString sTmp;
 362         rAny >>= sTmp;
 363         const sal_Unicode uSet = !sTmp.isEmpty() ? sTmp[0] : 0;
 364         if( FIELD_PROP_PAR1 == nWhichId )
 365             m_cPrefix = uSet;
 366         else
 367             m_cSuffix = uSet;
 368     }
 369     break;
 370     case FIELD_PROP_PAR3:
 371     {
 372         OUString sTmp;
 373         rAny >>= sTmp;
 374         SetSortAlgorithm(sTmp);
 375         break;
 376     }
 377     case FIELD_PROP_BOOL1:
 378         m_bIsSequence = *o3tl::doAccess<bool>(rAny);
 379         break;
 380     case FIELD_PROP_BOOL2:
 381         m_bSortByDocument = *o3tl::doAccess<bool>(rAny);
 382         break;
 383
 384     case FIELD_PROP_LOCALE:
 385         {
 386             css::lang::Locale aLocale;
 387             if( rAny >>= aLocale )
 388                 SetLanguage( LanguageTag::convertToLanguageType( aLocale ));
 389         }
 390         break;
 391
 392     case FIELD_PROP_PROP_SEQ:
 393         {
 394             Sequence<PropertyValues> aSeq;
 395             if( rAny >>= aSeq )
 396             {
 397                 m_SortKeyArr.clear();
 398                 const PropertyValues* pValues = aSeq.getConstArray();
 399                 //TODO: Limiting to the first SAL_MAX_UINT16 elements of aSeq so that size of
 400                 // m_SortKeyArr remains in range of sal_uInt16, as GetSortKeyCount and GetSortKey
 401                 // still expect m_SortKeyArr to be indexed by sal_uInt16:
 402                 auto nSize = std::min<sal_Int32>(aSeq.getLength(), SAL_MAX_UINT16);
 403                 for(sal_Int32 i = 0; i < nSize; i++)
 404                 {
 405                     SwTOXSortKey aSortKey;
 406                     for(const PropertyValue& rValue : pValues[i])
 407                     {
 408                         if(rValue.Name == UNO_NAME_SORT_KEY)
 409                         {
 410                             sal_Int16 nVal = -1; rValue.Value >>= nVal;
 411                             if(nVal >= 0 && nVal < AUTH_FIELD_END)
 412                                 aSortKey.eField = static_cast<ToxAuthorityField>(nVal);
 413                         }
 414                         else if(rValue.Name == UNO_NAME_IS_SORT_ASCENDING)
 415                         {
 416                             aSortKey.bSortAscending = *o3tl::doAccess<bool>(rValue.Value);
 417                         }
 418                     }
 419                     m_SortKeyArr.push_back(aSortKey);
 420                 }
 421             }
 422         }
 423         break;
 424     default:
 425         assert(false);
 426     }
 427 }
 428
 429 void SwAuthorityFieldType::SwClientNotify(const SwModify&, const SfxHint& rHint)
 430 {
 431     //re-generate positions of the fields
 432     DelSequenceArray();
 433     CallSwClientNotify(rHint);
 434 }
 435
 436 sal_uInt16 SwAuthorityFieldType::GetSortKeyCount() const
 437 {
 438     return m_SortKeyArr.size();
 439 }
 440
 441 const SwTOXSortKey*  SwAuthorityFieldType::GetSortKey(sal_uInt16 nIdx) const
 442 {
 443     if(m_SortKeyArr.size() > nIdx)
 444         return &m_SortKeyArr[nIdx];
 445     OSL_FAIL("Sort key not found");
 446     return nullptr;
 447 }
 448
 449 void SwAuthorityFieldType::SetSortKeys(sal_uInt16 nKeyCount, SwTOXSortKey  const aKeys[])
 450 {
 451     m_SortKeyArr.clear();
 452     for(sal_uInt16 i = 0; i < nKeyCount; i++)
 453         if(aKeys[i].eField < AUTH_FIELD_END)
 454             m_SortKeyArr.push_back(aKeys[i]);
 455 }
 456
 457 SwAuthorityField::SwAuthorityField( SwAuthorityFieldType* pInitType,
 458                                     std::u16string_view rFieldContents )
 459     : SwField(pInitType)
 460     , m_nTempSequencePos( -1 )
 461     , m_nTempSequencePosRLHidden( -1 )
 462 {
 463     m_xAuthEntry = pInitType->AddField( rFieldContents );
 464 }
 465
 466 SwAuthorityField::SwAuthorityField( SwAuthorityFieldType* pInitType,
 467                                     SwAuthEntry* pAuthEntry )
 468     : SwField( pInitType )
 469     , m_xAuthEntry( pAuthEntry )
 470     , m_nTempSequencePos( -1 )
 471     , m_nTempSequencePosRLHidden( -1 )
 472 {
 473 }
 474
 475 SwAuthorityField::~SwAuthorityField()
 476 {
 477     static_cast<SwAuthorityFieldType* >(GetTyp())->RemoveField(m_xAuthEntry.get());
 478 }
 479
 480 OUString SwAuthorityField::ExpandImpl(SwRootFrame const*const pLayout) const
 481 {
 482     return ConditionalExpandAuthIdentifier(pLayout);
 483 }
 484
 485 OUString SwAuthorityField::ConditionalExpandAuthIdentifier(
 486         SwRootFrame const*const pLayout) const
 487 {
 488     SwAuthorityFieldType* pAuthType = static_cast<SwAuthorityFieldType*>(GetTyp());
 489     OUString sRet;
 490     if(pAuthType->GetPrefix())
 491         sRet = OUString(pAuthType->GetPrefix());
 492
 493     if( pAuthType->IsSequence() )
 494     {
 495         sal_IntPtr & rnTempSequencePos(pLayout && pLayout->IsHideRedlines()
 496                 ? m_nTempSequencePosRLHidden : m_nTempSequencePos);
 497         if(!pAuthType->GetDoc()->getIDocumentFieldsAccess().IsExpFieldsLocked())
 498             rnTempSequencePos = pAuthType->GetSequencePos(m_xAuthEntry.get(), pLayout);
 499         if (0 <= rnTempSequencePos)
 500             sRet += OUString::number(rnTempSequencePos);
 501     }
 502     else
 503     {
 504         //TODO: Expand to: identifier, number sequence, ...
 505         if(m_xAuthEntry)
 506         {
 507             OUString sIdentifier(m_xAuthEntry->GetAuthorField(AUTH_FIELD_IDENTIFIER));
 508             // tdf#107784 Use title if it's a ooxml citation
 509             if (o3tl::starts_with(o3tl::trim(sIdentifier), u"CITATION"))
 510                 return m_xAuthEntry->GetAuthorField(AUTH_FIELD_TITLE);
 511             else
 512                 sRet += sIdentifier;
 513         }
 514     }
 515     if(pAuthType->GetSuffix())
 516         sRet += OUStringChar(pAuthType->GetSuffix());
 517     return sRet;
 518 }
 519
 520 OUString SwAuthorityField::ExpandCitation(ToxAuthorityField eField,
 521         SwRootFrame const*const pLayout) const
 522 {
 523     SwAuthorityFieldType* pAuthType = static_cast<SwAuthorityFieldType*>(GetTyp());
 524     OUString sRet;
 525
 526     if( pAuthType->IsSequence() )
 527     {
 528         sal_IntPtr & rnTempSequencePos(pLayout && pLayout->IsHideRedlines()
 529                 ? m_nTempSequencePosRLHidden : m_nTempSequencePos);
 530         if(!pAuthType->GetDoc()->getIDocumentFieldsAccess().IsExpFieldsLocked())
 531             rnTempSequencePos = pAuthType->GetSequencePos(m_xAuthEntry.get(), pLayout);
 532         if (0 <= rnTempSequencePos)
 533             sRet += OUString::number(rnTempSequencePos);
 534     }
 535     else
 536     {
 537         //TODO: Expand to: identifier, number sequence, ...
 538         if(m_xAuthEntry)
 539             sRet += m_xAuthEntry->GetAuthorField(eField);
 540     }
 541     return sRet;
 542 }
 543
 544 std::unique_ptr<SwField> SwAuthorityField::Copy() const
 545 {
 546     SwAuthorityFieldType* pAuthType = static_cast<SwAuthorityFieldType*>(GetTyp());
 547     return std::make_unique<SwAuthorityField>(pAuthType, m_xAuthEntry.get());
 548 }
 549
 550 const OUString & SwAuthorityField::GetFieldText(ToxAuthorityField eField) const
 551 {
 552     return m_xAuthEntry->GetAuthorField( eField );
 553 }
 554
 555 void SwAuthorityField::SetPar1(const OUString& rStr)
 556 {
 557     SwAuthorityFieldType* pInitType = static_cast<SwAuthorityFieldType* >(GetTyp());
 558     pInitType->RemoveField(m_xAuthEntry.get());
 559     m_xAuthEntry = pInitType->AddField(rStr);
 560 }
 561
 562 OUString SwAuthorityField::GetDescription() const
 563 {
 564     return SwResId(STR_AUTHORITY_ENTRY);
 565 }
 566
 567 OUString SwAuthorityField::GetAuthority(const SwRootFrame* pLayout, const SwForm* pTOX) const
 568 {
 569     OUString aText;
 570
 571     std::unique_ptr<SwForm> pDefaultTOX;
 572     if (!pTOX)
 573     {
 574         pDefaultTOX = std::make_unique<SwForm>(TOX_AUTHORITIES);
 575         pTOX = pDefaultTOX.get();
 576     }
 577
 578     SwAuthorityFieldType* pFieldType = static_cast<SwAuthorityFieldType*>(GetTyp());
 579     std::unique_ptr<SwTOXInternational> pIntl(pFieldType->CreateTOXInternational());
 580
 581     // This is based on SwTOXAuthority::GetLevel()
 582     OUString sText = GetFieldText(AUTH_FIELD_AUTHORITY_TYPE);
 583     ToxAuthorityType nAuthorityKind = AUTH_TYPE_ARTICLE;
 584     if (pIntl->IsNumeric(sText))
 585         nAuthorityKind = static_cast<ToxAuthorityType>(sText.toUInt32());
 586     if (nAuthorityKind > AUTH_TYPE_END)
 587         nAuthorityKind = AUTH_TYPE_ARTICLE;
 588
 589     // Must be incremented by 1, since the pattern 0 is for the heading
 590     const SwFormTokens& aPattern = pTOX->GetPattern(static_cast<int>(nAuthorityKind) + 1);
 591
 592     for (const auto& rToken : aPattern)
 593     {
 594         switch (rToken.eTokenType)
 595         {
 596             case TOKEN_TAB_STOP:
 597             {
 598                 aText += "\t";
 599                 break;
 600             }
 601             case TOKEN_TEXT:
 602             {
 603                 aText += rToken.sText;
 604                 break;
 605             }
 606             case TOKEN_AUTHORITY:
 607             {
 608                 ToxAuthorityField eField = static_cast<ToxAuthorityField>(rToken.nAuthorityField);
 609
 610                 if (AUTH_FIELD_IDENTIFIER == eField)
 611                 {
 612                     // Why isn't there a way to get the identifier without parentheses???
 613                     OUString sTmp = ExpandField(true, pLayout);
 614                     if (sal_Unicode cPref = pFieldType->GetPrefix(); cPref && cPref != ' ')
 615                         sTmp = sTmp.copy(1);
 616                     if (sal_Unicode cSuff = pFieldType->GetSuffix(); cSuff && cSuff != ' ')
 617                         sTmp = sTmp.copy(0, sTmp.getLength() - 1);
 618                     aText += sTmp;
 619                 }
 620                 else if (AUTH_FIELD_AUTHORITY_TYPE == eField)
 621                 {
 622                     aText += SwAuthorityFieldType::GetAuthTypeName(nAuthorityKind);
 623                 }
 624                 else if (AUTH_FIELD_URL == eField)
 625                 {
 626                     aText += GetURI(true);
 627                 }
 628                 else
 629                 {
 630                     aText += GetFieldText(eField);
 631                 }
 632                 break;
 633             }
 634             default:
 635                 break;
 636         }
 637     }
 638
 639     return aText;
 640 }
 641
 642 SwAuthorityField::TargetType SwAuthorityField::GetTargetType() const
 643 {
 644     return SwAuthorityField::TargetType(GetAuthEntry()->GetAuthorField(AUTH_FIELD_TARGET_TYPE).toInt32());
 645 }
 646
 647 OUString SwAuthorityField::GetAbsoluteURL() const
 648 {
 649     const OUString& rURL = GetAuthEntry()->GetAuthorField(
 650         GetTargetType() == SwAuthorityField::TargetType::UseDisplayURL
 651             ? AUTH_FIELD_URL : AUTH_FIELD_TARGET_URL);
 652     SwDoc* pDoc = static_cast<SwAuthorityFieldType*>(GetTyp())->GetDoc();
 653     SwDocShell* pDocShell = pDoc->GetDocShell();
 654     OUString aBasePath = pDocShell->getDocumentBaseURL();
 655     return INetURLObject::GetAbsURL(aBasePath, rURL, INetURLObject::EncodeMechanism::WasEncoded,
 656                                     INetURLObject::DecodeMechanism::WithCharset);
 657 }
 658
 659 OUString SwAuthorityField::GetURI(bool bRelative) const
 660 {
 661     OUString sTmp = GetFieldText(AUTH_FIELD_URL);
 662
 663     SwDoc* pDoc = static_cast<SwAuthorityFieldType*>(GetTyp())->GetDoc();
 664     SwDocShell* pDocShell = pDoc->GetDocShell();
 665     const OUString aBaseURL = pDocShell->getDocumentBaseURL();
 666     std::u16string_view aBaseURIScheme;
 667     sal_Int32 nSep = aBaseURL.indexOf(':');
 668     if (nSep != -1)
 669     {
 670         aBaseURIScheme = aBaseURL.subView(0, nSep);
 671     }
 672
 673     uno::Reference<uri::XUriReferenceFactory> xUriReferenceFactory
 674         = uri::UriReferenceFactory::create(comphelper::getProcessComponentContext());
 675     uno::Reference<uri::XUriReference> xUriRef;
 676     try
 677     {
 678         xUriRef = xUriReferenceFactory->parse(sTmp);
 679     }
 680     catch (const uno::Exception& rException)
 681     {
 682         SAL_WARN("sw.core",
 683                  "SwTOXAuthority::GetSourceURL: failed to parse url: " << rException.Message);
 684     }
 685     if (xUriRef.is() && xUriRef->getFragment().startsWith("page="))
 686     {
 687         xUriRef->clearFragment();
 688         sTmp = xUriRef->getUriReference();
 689     }
 690
 691     // If the URI is not supposed to be relative, we return here the full URI
 692     if (!bRelative)
 693         return sTmp;
 694
 695     bool bSaveRelFSys = officecfg::Office::Common::Save::URL::FileSystem::get();
 696     if (xUriRef.is() && bSaveRelFSys && xUriRef->getScheme() == aBaseURIScheme)
 697     {
 698         sTmp = INetURLObject::GetRelURL(aBaseURL, sTmp);
 699     }
 700     return sTmp;
 701 }
 702
 703 void SwAuthorityField::dumpAsXml(xmlTextWriterPtr pWriter) const
 704 {
 705     (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwAuthorityField"));
 706     SwField::dumpAsXml(pWriter);
 707
 708     (void)xmlTextWriterStartElement(pWriter, BAD_CAST("m_xAuthEntry"));
 709     (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", m_xAuthEntry.get());
 710     if (m_xAuthEntry.is())
 711     {
 712         m_xAuthEntry->dumpAsXml(pWriter);
 713     }
 714     (void)xmlTextWriterEndElement(pWriter);
 715     (void)xmlTextWriterStartElement(pWriter, BAD_CAST("m_nTempSequencePos"));
 716     (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
 717                                 BAD_CAST(OString::number(m_nTempSequencePos).getStr()));
 718     (void)xmlTextWriterEndElement(pWriter);
 719     (void)xmlTextWriterStartElement(pWriter, BAD_CAST("m_nTempSequencePosRLHidden"));
 720     (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
 721                                 BAD_CAST(OString::number(m_nTempSequencePosRLHidden).getStr()));
 722     (void)xmlTextWriterEndElement(pWriter);
 723
 724     (void)xmlTextWriterEndElement(pWriter);
 725 }
 726
 727 const char* const aFieldNames[] =
 728 {
 729     "Identifier",
 730     "BibiliographicType",
 731     "Address",
 732     "Annote",
 733     "Author",
 734     "Booktitle",
 735     "Chapter",
 736     "Edition",
 737     "Editor",
 738     "Howpublished",
 739     "Institution",
 740     "Journal",
 741     "Month",
 742     "Note",
 743     "Number",
 744     "Organizations",
 745     "Pages",
 746     "Publisher",
 747     "School",
 748     "Series",
 749     "Title",
 750     "Report_Type",
 751     "Volume",
 752     "Year",
 753     "URL",
 754     "Custom1",
 755     "Custom2",
 756     "Custom3",
 757     "Custom4",
 758     "Custom5",
 759     "ISBN",
 760     "LocalURL",
 761     "TargetType",
 762     "TargetURL",
 763 };
 764
 765 void SwAuthEntry::dumpAsXml(xmlTextWriterPtr pWriter) const
 766 {
 767     (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwAuthEntry"));
 768
 769     for (int i = 0; i < AUTH_FIELD_END; ++i)
 770     {
 771         (void)xmlTextWriterStartElement(pWriter, BAD_CAST("m_aAuthField"));
 772         (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("key"), BAD_CAST(aFieldNames[i]));
 773         (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(m_aAuthFields[i].toUtf8().getStr()));
 774         (void)xmlTextWriterEndElement(pWriter);
 775     }
 776
 777     (void)xmlTextWriterEndElement(pWriter);
 778 }
 779
 780 bool    SwAuthorityField::QueryValue( Any& rAny, sal_uInt16 /*nWhichId*/ ) const
 781 {
 782     if(!GetTyp())
 783         return false;
 784     if(!m_xAuthEntry)
 785         return false;
 786     Sequence <PropertyValue> aRet(AUTH_FIELD_END);
 787     PropertyValue* pValues = aRet.getArray();
 788     for(int i = 0; i < AUTH_FIELD_END; ++i)
 789     {
 790         pValues[i].Name = OUString::createFromAscii(aFieldNames[i]);
 791         const OUString& sField = m_xAuthEntry->GetAuthorField(static_cast<ToxAuthorityField>(i));
 792         if(i == AUTH_FIELD_AUTHORITY_TYPE)
 793             pValues[i].Value <<= sal_Int16(sField.toInt32());
 794         else
 795             pValues[i].Value <<= sField;
 796     }
 797     rAny <<= aRet;
 798     /* FIXME: it is weird that we always return false here */
 799     return false;
 800 }
 801
 802 static sal_Int32 lcl_Find(std::u16string_view rFieldName)
 803 {
 804     for(sal_Int32 i = 0; i < AUTH_FIELD_END; ++i)
 805         if(o3tl::equalsAscii(rFieldName, aFieldNames[i]))
 806             return i;
 807     return -1;
 808 }
 809
 810 bool    SwAuthorityField::PutValue( const Any& rAny, sal_uInt16 /*nWhichId*/ )
 811 {
 812     if(!GetTyp() || !m_xAuthEntry)
 813         return false;
 814
 815     Sequence <PropertyValue> aParam;
 816     if(!(rAny >>= aParam))
 817         return false;
 818
 819     OUStringBuffer sBuf(+(AUTH_FIELD_END - 1));
 820     comphelper::string::padToLength(sBuf, (AUTH_FIELD_END - 1), TOX_STYLE_DELIMITER);
 821     OUString sToSet(sBuf.makeStringAndClear());
 822     for(const PropertyValue& rParam : std::as_const(aParam))
 823     {
 824         const sal_Int32 nFound = lcl_Find(rParam.Name);
 825         if(nFound >= 0)
 826         {
 827             OUString sContent;
 828             if(AUTH_FIELD_AUTHORITY_TYPE == nFound)
 829             {
 830                 sal_Int16 nVal = 0;
 831                 rParam.Value >>= nVal;
 832                 sContent = OUString::number(nVal);
 833             }
 834             else
 835                 rParam.Value >>= sContent;
 836             sToSet = comphelper::string::setToken(sToSet, nFound, TOX_STYLE_DELIMITER, sContent);
 837         }
 838     }
 839
 840     static_cast<SwAuthorityFieldType*>(GetTyp())->RemoveField(m_xAuthEntry.get());
 841     m_xAuthEntry = static_cast<SwAuthorityFieldType*>(GetTyp())->AddField(sToSet);
 842
 843     /* FIXME: it is weird that we always return false here */
 844     return false;
 845 }
 846
 847 SwFieldType* SwAuthorityField::ChgTyp( SwFieldType* pFieldTyp )
 848 {
 849     SwAuthorityFieldType* pSrcTyp = static_cast<SwAuthorityFieldType*>(GetTyp()),
 850                         * pDstTyp = static_cast<SwAuthorityFieldType*>(pFieldTyp);
 851     if( pSrcTyp != pDstTyp )
 852     {
 853         const SwAuthEntry* pSrcEntry = m_xAuthEntry.get();
 854         m_xAuthEntry = pDstTyp->AppendField( *pSrcEntry );
 855         pSrcTyp->RemoveField( pSrcEntry );
 856         SwField::ChgTyp( pFieldTyp );
 857     }
 858     return pSrcTyp;
 859 }
 860
 861 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */