?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Revert "tdf#158280 Replace usage of InputDialog with SvxNameDialog"
[LibreOffice.git] / sw / source / core / fields / authfld.cxx
blob0a3de0e91bb5a0c2336f2d2c0584085226ee0c20
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 += GetRelativeURI();
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 if (!pDocShell)
655 return OUString();
656 OUString aBasePath = pDocShell->getDocumentBaseURL();
657 return INetURLObject::GetAbsURL(aBasePath, rURL, INetURLObject::EncodeMechanism::WasEncoded,
658 INetURLObject::DecodeMechanism::WithCharset);
659 }
660
661 OUString SwAuthorityField::GetRelativeURI() const
662 {
663 OUString sTmp = GetFieldText(AUTH_FIELD_URL);
664
665 SwDoc* pDoc = static_cast<SwAuthorityFieldType*>(GetTyp())->GetDoc();
666 SwDocShell* pDocShell = pDoc->GetDocShell();
667 if (!pDocShell)
668 return OUString();
669 const OUString aBaseURL = pDocShell->getDocumentBaseURL();
670 std::u16string_view aBaseURIScheme;
671 sal_Int32 nSep = aBaseURL.indexOf(':');
672 if (nSep != -1)
673 {
674 aBaseURIScheme = aBaseURL.subView(0, nSep);
675 }
676
677 uno::Reference<uri::XUriReferenceFactory> xUriReferenceFactory
678 = uri::UriReferenceFactory::create(comphelper::getProcessComponentContext());
679 uno::Reference<uri::XUriReference> xUriRef;
680 try
681 {
682 xUriRef = xUriReferenceFactory->parse(sTmp);
683 }
684 catch (const uno::Exception& rException)
685 {
686 SAL_WARN("sw.core",
687 "SwTOXAuthority::GetSourceURL: failed to parse url: " << rException.Message);
688 }
689 if (xUriRef.is() && xUriRef->getFragment().startsWith("page="))
690 {
691 xUriRef->clearFragment();
692 sTmp = xUriRef->getUriReference();
693 }
694
695 // convert to relative
696 bool bSaveRelFSys = officecfg::Office::Common::Save::URL::FileSystem::get();
697 if (xUriRef.is() && bSaveRelFSys && xUriRef->getScheme() == aBaseURIScheme)
698 {
699 sTmp = INetURLObject::GetRelURL(aBaseURL, sTmp);
700 }
701 return sTmp;
702 }
703
704 void SwAuthorityField::dumpAsXml(xmlTextWriterPtr pWriter) const
705 {
706 (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwAuthorityField"));
707 SwField::dumpAsXml(pWriter);
708
709 (void)xmlTextWriterStartElement(pWriter, BAD_CAST("m_xAuthEntry"));
710 (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", m_xAuthEntry.get());
711 if (m_xAuthEntry.is())
712 {
713 m_xAuthEntry->dumpAsXml(pWriter);
714 }
715 (void)xmlTextWriterEndElement(pWriter);
716 (void)xmlTextWriterStartElement(pWriter, BAD_CAST("m_nTempSequencePos"));
717 (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
718 BAD_CAST(OString::number(m_nTempSequencePos).getStr()));
719 (void)xmlTextWriterEndElement(pWriter);
720 (void)xmlTextWriterStartElement(pWriter, BAD_CAST("m_nTempSequencePosRLHidden"));
721 (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
722 BAD_CAST(OString::number(m_nTempSequencePosRLHidden).getStr()));
723 (void)xmlTextWriterEndElement(pWriter);
724
725 (void)xmlTextWriterEndElement(pWriter);
726 }
727
728 constexpr OUString aFieldNames[]
729 {
730 u"Identifier"_ustr,
731 u"BibiliographicType"_ustr,
732 u"Address"_ustr,
733 u"Annote"_ustr,
734 u"Author"_ustr,
735 u"Booktitle"_ustr,
736 u"Chapter"_ustr,
737 u"Edition"_ustr,
738 u"Editor"_ustr,
739 u"Howpublished"_ustr,
740 u"Institution"_ustr,
741 u"Journal"_ustr,
742 u"Month"_ustr,
743 u"Note"_ustr,
744 u"Number"_ustr,
745 u"Organizations"_ustr,
746 u"Pages"_ustr,
747 u"Publisher"_ustr,
748 u"School"_ustr,
749 u"Series"_ustr,
750 u"Title"_ustr,
751 u"Report_Type"_ustr,
752 u"Volume"_ustr,
753 u"Year"_ustr,
754 u"URL"_ustr,
755 u"Custom1"_ustr,
756 u"Custom2"_ustr,
757 u"Custom3"_ustr,
758 u"Custom4"_ustr,
759 u"Custom5"_ustr,
760 u"ISBN"_ustr,
761 u"LocalURL"_ustr,
762 u"TargetType"_ustr,
763 u"TargetURL"_ustr,
764 };
765
766 void SwAuthEntry::dumpAsXml(xmlTextWriterPtr pWriter) const
767 {
768 (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwAuthEntry"));
769
770 for (int i = 0; i < AUTH_FIELD_END; ++i)
771 {
772 (void)xmlTextWriterStartElement(pWriter, BAD_CAST("m_aAuthField"));
773 (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("key"), BAD_CAST(aFieldNames[i].toUtf8().getStr()));
774 (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(m_aAuthFields[i].toUtf8().getStr()));
775 (void)xmlTextWriterEndElement(pWriter);
776 }
777
778 (void)xmlTextWriterEndElement(pWriter);
779 }
780
781 bool SwAuthorityField::QueryValue( Any& rAny, sal_uInt16 /*nWhichId*/ ) const
782 {
783 if(!GetTyp())
784 return false;
785 if(!m_xAuthEntry)
786 return false;
787 Sequence <PropertyValue> aRet(AUTH_FIELD_END);
788 PropertyValue* pValues = aRet.getArray();
789 for(int i = 0; i < AUTH_FIELD_END; ++i)
790 {
791 pValues[i].Name = aFieldNames[i];
792 const OUString& sField = m_xAuthEntry->GetAuthorField(static_cast<ToxAuthorityField>(i));
793 if(i == AUTH_FIELD_AUTHORITY_TYPE)
794 pValues[i].Value <<= sal_Int16(sField.toInt32());
795 else
796 pValues[i].Value <<= sField;
797 }
798 rAny <<= aRet;
799 /* FIXME: it is weird that we always return false here */
800 return false;
801 }
802
803 static sal_Int32 lcl_Find(std::u16string_view rFieldName)
804 {
805 for(sal_Int32 i = 0; i < AUTH_FIELD_END; ++i)
806 if(aFieldNames[i] == rFieldName)
807 return i;
808 return -1;
809 }
810
811 bool SwAuthorityField::PutValue( const Any& rAny, sal_uInt16 /*nWhichId*/ )
812 {
813 if(!GetTyp() || !m_xAuthEntry)
814 return false;
815
816 Sequence <PropertyValue> aParam;
817 if(!(rAny >>= aParam))
818 return false;
819
820 OUStringBuffer sBuf(+(AUTH_FIELD_END - 1));
821 comphelper::string::padToLength(sBuf, (AUTH_FIELD_END - 1), TOX_STYLE_DELIMITER);
822 OUString sToSet(sBuf.makeStringAndClear());
823 for (const PropertyValue& rParam : aParam)
824 {
825 const sal_Int32 nFound = lcl_Find(rParam.Name);
826 if(nFound >= 0)
827 {
828 OUString sContent;
829 if(AUTH_FIELD_AUTHORITY_TYPE == nFound)
830 {
831 sal_Int16 nVal = 0;
832 rParam.Value >>= nVal;
833 sContent = OUString::number(nVal);
834 }
835 else
836 rParam.Value >>= sContent;
837 sToSet = comphelper::string::setToken(sToSet, nFound, TOX_STYLE_DELIMITER, sContent);
838 }
839 }
840
841 static_cast<SwAuthorityFieldType*>(GetTyp())->RemoveField(m_xAuthEntry.get());
842 m_xAuthEntry = static_cast<SwAuthorityFieldType*>(GetTyp())->AddField(sToSet);
843
844 /* FIXME: it is weird that we always return false here */
845 return false;
846 }
847
848 SwFieldType* SwAuthorityField::ChgTyp( SwFieldType* pFieldTyp )
849 {
850 SwAuthorityFieldType* pSrcTyp = static_cast<SwAuthorityFieldType*>(GetTyp()),
851 * pDstTyp = static_cast<SwAuthorityFieldType*>(pFieldTyp);
852 if( pSrcTyp != pDstTyp )
853 {
854 const SwAuthEntry* pSrcEntry = m_xAuthEntry.get();
855 m_xAuthEntry = pDstTyp->AppendField( *pSrcEntry );
856 pSrcTyp->RemoveField( pSrcEntry );
857 SwField::ChgTyp( pFieldTyp );
858 }
859 return pSrcTyp;
860 }
861
862 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE