?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
android: Update app-specific/MIME type icons
[LibreOffice.git] / sw / source / core / doc / DocumentFieldsManager.cxx
blobc8703e7f06efc76d1d99b4d1cba5e4b5a7059b88
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 #include <DocumentFieldsManager.hxx>
20 #include <config_features.h>
21 #include <config_fuzzers.h>
22 #include <doc.hxx>
23 #include <IDocumentUndoRedo.hxx>
24 #include <IDocumentState.hxx>
25 #include <IDocumentRedlineAccess.hxx>
26 #include <redline.hxx>
27 #include <rootfrm.hxx>
28 #include <dbmgr.hxx>
29 #include <chpfld.hxx>
30 #include <dbfld.hxx>
31 #include <reffld.hxx>
32 #include <flddropdown.hxx>
33 #include <strings.hrc>
34 #include <SwUndoField.hxx>
35 #include <flddat.hxx>
36 #include <cntfrm.hxx>
37 #include <node2lay.hxx>
38 #include <section.hxx>
39 #include <docufld.hxx>
40 #include <calbck.hxx>
41 #include <cellatr.hxx>
42 #include <swtable.hxx>
43 #include <frmfmt.hxx>
44 #include <fmtfld.hxx>
45 #include <ndtxt.hxx>
46 #include <txtfld.hxx>
47 #include <docfld.hxx>
48 #include <hints.hxx>
49 #include <docary.hxx>
50 #include <fldbas.hxx>
51 #include <expfld.hxx>
52 #include <ddefld.hxx>
53 #include <authfld.hxx>
54 #include <usrfld.hxx>
55 #include <ndindex.hxx>
56 #include <pam.hxx>
57 #include <o3tl/deleter.hxx>
58 #include <osl/diagnose.h>
59 #include <unotools/transliterationwrapper.hxx>
60 #include <comphelper/scopeguard.hxx>
61 #include <com/sun/star/uno/Any.hxx>
62
63 using namespace ::com::sun::star::uno;
64
65 namespace sw
66 {
67 bool IsFieldDeletedInModel(IDocumentRedlineAccess const& rIDRA,
68 SwTextField const& rTextField)
69 {
70 SwRedlineTable::size_type tmp;
71 SwPosition const pos(rTextField.GetTextNode(),
72 rTextField.GetStart());
73 SwRangeRedline const*const pRedline(rIDRA.GetRedline(pos, &tmp));
74 return (pRedline
75 && pRedline->GetType() == RedlineType::Delete
76 && *pRedline->GetPoint() != *pRedline->GetMark());
77 }
78 }
79
80 namespace
81 {
82 #if HAVE_FEATURE_DBCONNECTIVITY && !ENABLE_FUZZERS
83
84 OUString lcl_GetDBVarName( SwDoc& rDoc, SwDBNameInfField& rDBField )
85 {
86 SwDBData aDBData( rDBField.GetDBData( &rDoc ));
87 OUString sDBNumNm;
88 SwDBData aDocData = rDoc.GetDBData();
89
90 if( aDBData != aDocData )
91 {
92 sDBNumNm = aDBData.sDataSource + OUStringChar(DB_DELIM)
93 + aDBData.sCommand + OUStringChar(DB_DELIM);
94 }
95 sDBNumNm += SwFieldType::GetTypeStr(SwFieldTypesEnum::DatabaseSetNumber);
96
97 return sDBNumNm;
98 }
99
100 #endif
101
102 bool IsFieldDeleted(IDocumentRedlineAccess const& rIDRA,
103 SwRootFrame const& rLayout, SwTextField const& rTextField)
104 {
105 SwTextNode const& rNode(rTextField.GetTextNode());
106 bool const isInBody(
107 rNode.GetNodes().GetEndOfExtras().GetIndex() < rNode.GetIndex());
108 if (!isInBody && nullptr == rNode.getLayoutFrame(&rLayout))
109 { // see SwDocUpdateField::GetBodyNode() - fields in hidden sections
110 // don't have layout frames but must be updated, so use the same
111 // check as there, but do it again because GetBodyNode() checks
112 // for *any* layout...
113 return true;
114 }
115 return sw::IsFieldDeletedInModel(rIDRA, rTextField);
116 }
117
118 void lcl_CalcField( SwDoc& rDoc, SwCalc& rCalc, const SetGetExpField& rSGEField,
119 SwDBManager* pMgr, SwRootFrame const*const pLayout)
120 {
121 const SwTextField* pTextField = rSGEField.GetTextField();
122 if( !pTextField )
123 return ;
124
125 if (pLayout && pLayout->IsHideRedlines()
126 && IsFieldDeleted(rDoc.getIDocumentRedlineAccess(), *pLayout, *pTextField))
127 {
128 return;
129 }
130
131 const SwField* pField = pTextField->GetFormatField().GetField();
132 const SwFieldIds nFieldWhich = pField->GetTyp()->Which();
133
134 if( SwFieldIds::SetExp == nFieldWhich )
135 {
136 SwSbxValue aValue;
137 if( nsSwGetSetExpType::GSE_EXPR & pField->GetSubType() )
138 aValue.PutDouble( static_cast<const SwSetExpField*>(pField)->GetValue(pLayout) );
139 else
140 // Extension to calculate with Strings
141 aValue.PutString( static_cast<const SwSetExpField*>(pField)->GetExpStr(pLayout) );
142
143 // set the new value in Calculator
144 rCalc.VarChange( pField->GetTyp()->GetName(), aValue );
145 }
146 else if( pMgr )
147 {
148 #if !HAVE_FEATURE_DBCONNECTIVITY || ENABLE_FUZZERS
149 (void) rDoc;
150 #else
151 switch( nFieldWhich )
152 {
153 case SwFieldIds::DbNumSet:
154 {
155 SwDBNumSetField* pDBField = const_cast<SwDBNumSetField*>(static_cast<const SwDBNumSetField*>(pField));
156
157 SwDBData aDBData(pDBField->GetDBData(&rDoc));
158
159 if( pDBField->IsCondValid() &&
160 pMgr->OpenDataSource( aDBData.sDataSource, aDBData.sCommand ))
161 rCalc.VarChange( lcl_GetDBVarName( rDoc, *pDBField),
162 pDBField->GetFormat() );
163 }
164 break;
165 case SwFieldIds::DbNextSet:
166 {
167 SwDBNextSetField* pDBField = const_cast<SwDBNextSetField*>(static_cast<const SwDBNextSetField*>(pField));
168 SwDBData aDBData(pDBField->GetDBData(&rDoc));
169 if( !pDBField->IsCondValid() ||
170 !pMgr->OpenDataSource( aDBData.sDataSource, aDBData.sCommand ))
171 break;
172
173 OUString sDBNumNm(lcl_GetDBVarName( rDoc, *pDBField));
174 SwCalcExp* pExp = rCalc.VarLook( sDBNumNm );
175 if( pExp )
176 rCalc.VarChange( sDBNumNm, pExp->nValue.GetLong() + 1 );
177 }
178 break;
179
180 default: break;
181 }
182 #endif
183 }
184 }
185 }
186
187 namespace sw
188 {
189
190 DocumentFieldsManager::DocumentFieldsManager( SwDoc& i_rSwdoc ) : m_rDoc( i_rSwdoc ),
191 mbNewFieldLst(true),
192 mpUpdateFields(new SwDocUpdateField(m_rDoc)),
193 mpFieldTypes( new SwFieldTypes ),
194 mnLockExpField( 0 )
195 {
196 }
197
198 const SwFieldTypes* DocumentFieldsManager::GetFieldTypes() const
199 {
200 return mpFieldTypes.get();
201 }
202
203 /** Insert field types
204 *
205 * @param rFieldTyp ???
206 * @return Always returns a pointer to the type, if it's new or already added.
207 */
208 SwFieldType* DocumentFieldsManager::InsertFieldType(const SwFieldType &rFieldTyp)
209 {
210 const SwFieldTypes::size_type nSize = mpFieldTypes->size();
211 const SwFieldIds nFieldWhich = rFieldTyp.Which();
212
213 SwFieldTypes::size_type i = INIT_FLDTYPES;
214
215 switch( nFieldWhich )
216 {
217 case SwFieldIds::SetExp:
218 //JP 29.01.96: SequenceFields start at INIT_FLDTYPES - 3!!
219 // Or we get doubble number circles!!
220 //MIB 14.03.95: From now on also the SW3-Reader relies on this, when
221 //constructing string pools and when reading SetExp fields
222 if( nsSwGetSetExpType::GSE_SEQ & static_cast<const SwSetExpFieldType&>(rFieldTyp).GetType() )
223 i -= INIT_SEQ_FLDTYPES;
224 [[fallthrough]];
225 case SwFieldIds::Database:
226 case SwFieldIds::User:
227 case SwFieldIds::Dde:
228 {
229 const ::utl::TransliterationWrapper& rSCmp = GetAppCmpStrIgnore();
230 OUString sFieldNm( rFieldTyp.GetName() );
231 for( ; i < nSize; ++i )
232 if( nFieldWhich == (*mpFieldTypes)[i]->Which() &&
233 rSCmp.isEqual( sFieldNm, (*mpFieldTypes)[i]->GetName() ))
234 return (*mpFieldTypes)[i].get();
235 }
236 break;
237
238 case SwFieldIds::TableOfAuthorities:
239 for( ; i < nSize; ++i )
240 if( nFieldWhich == (*mpFieldTypes)[i]->Which() )
241 return (*mpFieldTypes)[i].get();
242 break;
243
244 default:
245 for( i = 0; i < nSize; ++i )
246 if( nFieldWhich == (*mpFieldTypes)[i]->Which() )
247 return (*mpFieldTypes)[i].get();
248 }
249
250 std::unique_ptr<SwFieldType> pNew = rFieldTyp.Copy();
251 switch( nFieldWhich )
252 {
253 case SwFieldIds::Dde:
254 static_cast<SwDDEFieldType*>(pNew.get())->SetDoc( &m_rDoc );
255 break;
256
257 case SwFieldIds::Database:
258 case SwFieldIds::Table:
259 case SwFieldIds::DateTime:
260 case SwFieldIds::GetExp:
261 static_cast<SwValueFieldType*>(pNew.get())->SetDoc( &m_rDoc );
262 break;
263
264 case SwFieldIds::User:
265 case SwFieldIds::SetExp:
266 static_cast<SwValueFieldType*>(pNew.get())->SetDoc( &m_rDoc );
267 // JP 29.07.96: Optionally prepare FieldList for Calculator:
268 mpUpdateFields->InsertFieldType( *pNew );
269 break;
270 case SwFieldIds::TableOfAuthorities :
271 static_cast<SwAuthorityFieldType*>(pNew.get())->SetDoc( &m_rDoc );
272 break;
273 default: break;
274 }
275
276 mpFieldTypes->insert( mpFieldTypes->begin() + nSize, std::move(pNew) );
277 m_rDoc.getIDocumentState().SetModified();
278
279 return (*mpFieldTypes)[ nSize ].get();
280 }
281
282 /// @returns the field type of the Doc
283 SwFieldType *DocumentFieldsManager::GetSysFieldType( const SwFieldIds eWhich ) const
284 {
285 for( SwFieldTypes::size_type i = 0; i < INIT_FLDTYPES; ++i )
286 if( eWhich == (*mpFieldTypes)[i]->Which() )
287 return (*mpFieldTypes)[i].get();
288 return nullptr;
289 }
290
291 /// Find first type with ResId and name
292 SwFieldType* DocumentFieldsManager::GetFieldType(
293 SwFieldIds nResId,
294 const OUString& rName,
295 bool bDbFieldMatching // used in some UNO calls for SwFieldIds::Database to use different string matching code #i51815#
296 ) const
297 {
298 const SwFieldTypes::size_type nSize = mpFieldTypes->size();
299 SwFieldTypes::size_type i {0};
300 const ::utl::TransliterationWrapper& rSCmp = GetAppCmpStrIgnore();
301
302 switch( nResId )
303 {
304 case SwFieldIds::SetExp:
305 //JP 29.01.96: SequenceFields start at INIT_FLDTYPES - 3!!
306 // Or we get doubble number circles!!
307 //MIB 14.03.95: From now on also the SW3-Reader relies on this, when
308 //constructing string pools and when reading SetExp fields
309 i = INIT_FLDTYPES - INIT_SEQ_FLDTYPES;
310 break;
311
312 case SwFieldIds::Database:
313 case SwFieldIds::User:
314 case SwFieldIds::Dde:
315 case SwFieldIds::TableOfAuthorities:
316 i = INIT_FLDTYPES;
317 break;
318 default: break;
319 }
320
321 SwFieldType* pRet = nullptr;
322 for( ; i < nSize; ++i )
323 {
324 SwFieldType* pFieldType = (*mpFieldTypes)[i].get();
325
326 if (nResId == pFieldType->Which())
327 {
328 OUString aFieldName( pFieldType->GetName() );
329 if (bDbFieldMatching && nResId == SwFieldIds::Database) // #i51815#
330 aFieldName = aFieldName.replace(DB_DELIM, '.');
331
332 if (rSCmp.isEqual( rName, aFieldName ))
333 {
334 pRet = pFieldType;
335 break;
336 }
337 }
338 }
339 return pRet;
340 }
341
342 /// Remove field type
343 void DocumentFieldsManager::RemoveFieldType(size_t nField)
344 {
345 OSL_ENSURE( INIT_FLDTYPES <= nField, "don't remove InitFields" );
346 /*
347 * Dependent fields present -> ErrRaise
348 */
349 if(nField >= mpFieldTypes->size())
350 return;
351
352 SwFieldType* pTmp = (*mpFieldTypes)[nField].get();
353
354 // JP 29.07.96: Optionally prepare FieldList for Calculator
355 SwFieldIds nWhich = pTmp->Which();
356 switch( nWhich )
357 {
358 case SwFieldIds::SetExp:
359 case SwFieldIds::User:
360 mpUpdateFields->RemoveFieldType( *pTmp );
361 [[fallthrough]];
362 case SwFieldIds::Dde:
363 if( pTmp->HasWriterListeners() && !m_rDoc.IsUsed( *pTmp ) )
364 {
365 if( SwFieldIds::SetExp == nWhich )
366 static_cast<SwSetExpFieldType*>(pTmp)->SetDeleted( true );
367 else if( SwFieldIds::User == nWhich )
368 static_cast<SwUserFieldType*>(pTmp)->SetDeleted( true );
369 else
370 static_cast<SwDDEFieldType*>(pTmp)->SetDeleted( true );
371 nWhich = SwFieldIds::Database;
372 }
373 break;
374 default: break;
375 }
376
377 if( nWhich != SwFieldIds::Database )
378 {
379 OSL_ENSURE( !pTmp->HasWriterListeners(), "Dependent fields present!" );
380 }
381 else
382 {
383 // coverity[leaked_storage] - at this point DB fields are ref-counted and delete themselves
384 (*mpFieldTypes)[nField].release();
385 }
386
387 mpFieldTypes->erase( mpFieldTypes->begin() + nField );
388 m_rDoc.getIDocumentState().SetModified();
389 }
390
391 // All have to be re-evaluated.
392 void DocumentFieldsManager::UpdateFields(bool bCloseDB)
393 {
394 // Tell all types to update their fields
395 for(auto const& pFieldType: *mpFieldTypes)
396 pFieldType->UpdateFields();
397
398 if(!IsExpFieldsLocked())
399 UpdateExpFields(nullptr, false); // update expression fields
400
401 // Tables
402 UpdateTableFields(nullptr);
403
404 // References
405 UpdateRefFields();
406 if(bCloseDB)
407 {
408 #if HAVE_FEATURE_DBCONNECTIVITY && !ENABLE_FUZZERS
409 m_rDoc.GetDBManager()->CloseAll();
410 #endif
411 }
412 // Only evaluate on full update
413 m_rDoc.getIDocumentState().SetModified();
414 }
415
416 void DocumentFieldsManager::InsDeletedFieldType( SwFieldType& rFieldTyp )
417 {
418 // The FieldType was marked as deleted and removed from the array.
419 // One has to look this up again, now.
420 // - If it's not present, it can be re-inserted.
421 // - If the same type is found, the deleted one has to be renamed.
422
423 const SwFieldTypes::size_type nSize = mpFieldTypes->size();
424 const SwFieldIds nFieldWhich = rFieldTyp.Which();
425
426 OSL_ENSURE( SwFieldIds::SetExp == nFieldWhich ||
427 SwFieldIds::User == nFieldWhich ||
428 SwFieldIds::Dde == nFieldWhich, "Wrong FieldType" );
429
430 const ::utl::TransliterationWrapper& rSCmp = GetAppCmpStrIgnore();
431 const OUString& rFieldNm = rFieldTyp.GetName();
432
433 for( SwFieldTypes::size_type i = INIT_FLDTYPES; i < nSize; ++i )
434 {
435 SwFieldType* pFnd = (*mpFieldTypes)[i].get();
436 if( nFieldWhich == pFnd->Which() &&
437 rSCmp.isEqual( rFieldNm, pFnd->GetName() ) )
438 {
439 // find new name
440 SwFieldTypes::size_type nNum = 1;
441 do {
442 OUString sSrch = rFieldNm + OUString::number( nNum );
443 for( i = INIT_FLDTYPES; i < nSize; ++i )
444 {
445 pFnd = (*mpFieldTypes)[i].get();
446 if( nFieldWhich == pFnd->Which() &&
447 rSCmp.isEqual( sSrch, pFnd->GetName() ) )
448 break;
449 }
450 if( i >= nSize ) // not found
451 {
452 const_cast<OUString&>(rFieldNm) = sSrch;
453 break; // exit while loop
454 }
455 ++nNum;
456 } while( true );
457 break;
458 }
459 }
460
461 // not found, so insert, and updated deleted flag
462 mpFieldTypes->insert( mpFieldTypes->begin() + nSize, std::unique_ptr<SwFieldType>(&rFieldTyp) );
463 switch( nFieldWhich )
464 {
465 case SwFieldIds::SetExp:
466 static_cast<SwSetExpFieldType&>(rFieldTyp).SetDeleted( false );
467 break;
468 case SwFieldIds::User:
469 static_cast<SwUserFieldType&>(rFieldTyp).SetDeleted( false );
470 break;
471 case SwFieldIds::Dde:
472 static_cast<SwDDEFieldType&>(rFieldTyp).SetDeleted( false );
473 break;
474 default: break;
475 }
476 }
477
478 void DocumentFieldsManager::PutValueToField(const SwPosition & rPos,
479 const Any& rVal, sal_uInt16 nWhich)
480 {
481 Any aOldVal;
482 SwField * pField = GetFieldAtPos(rPos);
483
484 if (m_rDoc.GetIDocumentUndoRedo().DoesUndo() &&
485 pField->QueryValue(aOldVal, nWhich))
486 {
487 m_rDoc.GetIDocumentUndoRedo().AppendUndo(
488 std::make_unique<SwUndoFieldFromAPI>(rPos, aOldVal, rVal, nWhich));
489 }
490
491 pField->PutValue(rVal, nWhich);
492 }
493
494 bool DocumentFieldsManager::UpdateField(SwTextField* pDstTextField, SwField& rSrcField, bool bUpdateFields)
495 {
496 //static const sw::RefmarkFieldUpdate aRefMarkHint;
497 OSL_ENSURE(pDstTextField, "no field to update!");
498
499 bool bTableSelBreak = false;
500
501 SwFormatField * pDstFormatField = const_cast<SwFormatField*>(&pDstTextField->GetFormatField());
502 SwField * pDstField = pDstFormatField->GetField();
503 SwFieldIds nFieldWhich = rSrcField.GetTyp()->Which();
504 SwNodeIndex aTableNdIdx(pDstTextField->GetTextNode());
505
506 if (pDstField->GetTyp()->Which() ==
507 rSrcField.GetTyp()->Which())
508 {
509 if (m_rDoc.GetIDocumentUndoRedo().DoesUndo())
510 {
511 SwPosition aPosition( pDstTextField->GetTextNode(), pDstTextField->GetStart() );
512 m_rDoc.GetIDocumentUndoRedo().AppendUndo(std::make_unique<SwUndoFieldFromDoc>(aPosition, *pDstField, rSrcField, bUpdateFields));
513 }
514
515 pDstFormatField->SetField(rSrcField.CopyField());
516 SwField* pNewField = pDstFormatField->GetField();
517
518 switch( nFieldWhich )
519 {
520 case SwFieldIds::SetExp:
521 case SwFieldIds::GetExp:
522 case SwFieldIds::HiddenText:
523 case SwFieldIds::HiddenPara:
524 UpdateExpFields( pDstTextField, true );
525 break;
526
527 case SwFieldIds::Table:
528 {
529 const SwTableNode* pTableNd =
530 SwDoc::IsIdxInTable(aTableNdIdx);
531 if( pTableNd )
532 {
533 if (bUpdateFields)
534 UpdateTableFields(&pTableNd->GetTable());
535 else
536 pNewField->GetTyp()->CallSwClientNotify(sw::LegacyModifyHint(nullptr, nullptr));
537
538 if (! bUpdateFields)
539 bTableSelBreak = true;
540 }
541 }
542 break;
543
544 case SwFieldIds::Macro:
545 if( bUpdateFields && pDstTextField->GetpTextNode() )
546 pDstTextField->GetpTextNode()->TriggerNodeUpdate(sw::LegacyModifyHint(nullptr, pDstFormatField));
547 break;
548
549 case SwFieldIds::DatabaseName:
550 case SwFieldIds::DbNextSet:
551 case SwFieldIds::DbNumSet:
552 case SwFieldIds::DbSetNumber:
553 m_rDoc.ChgDBData(static_cast<SwDBNameInfField*>( pNewField)->GetRealDBData());
554 pNewField->GetTyp()->UpdateFields();
555
556 break;
557
558 case SwFieldIds::Database:
559 #if HAVE_FEATURE_DBCONNECTIVITY && !ENABLE_FUZZERS
560 {
561 // JP 10.02.96: call ChgValue, so that the style change sets the
562 // ContentString correctly
563 SwDBField* pDBField = static_cast<SwDBField*>(pNewField);
564 if (pDBField->IsInitialized())
565 pDBField->ChgValue( pDBField->GetValue(), true );
566
567 pDBField->ClearInitialized();
568 pDBField->InitContent();
569 }
570 #endif
571 [[fallthrough]];
572
573 default:
574 pDstFormatField->ForceUpdateTextNode();
575 }
576
577 // The fields we can calculate here are being triggered for an update
578 // here explicitly.
579 if( nFieldWhich == SwFieldIds::User )
580 UpdateUsrFields();
581 }
582
583 return bTableSelBreak;
584 }
585
586 /// Update reference and table fields
587 void DocumentFieldsManager::UpdateRefFields()
588 {
589 for(auto const& pFieldType: *mpFieldTypes)
590 if(SwFieldIds::GetRef == pFieldType->Which())
591 static_cast<SwGetRefFieldType*>(pFieldType.get())->UpdateGetReferences();
592 }
593
594 void DocumentFieldsManager::UpdateTableFields(const SwTable* pTable)
595 {
596 auto pFieldType = GetFieldType( SwFieldIds::Table, OUString(), false );
597 if(pFieldType)
598 {
599 std::vector<SwFormatField*> vFields;
600 pFieldType->GatherFields(vFields);
601 for(auto pFormatField : vFields)
602 {
603 if(!pFormatField->GetTextField()->GetTextNode().FindTableNode())
604 continue;
605 SwTableField* pField = static_cast<SwTableField*>(pFormatField->GetField());
606 // re-set the value flag
607 // JP 17.06.96: internal representation of all formulas
608 // (reference to other table!!!)
609 if(pTable && nsSwExtendedSubType::SUB_CMD & pField->GetSubType())
610 pField->PtrToBoxNm(pTable);
611 else
612 // reset the value flag for all
613 pField->ChgValid(false);
614 }
615 }
616 // process all table box formulas
617 for (const SfxPoolItem* pItem : m_rDoc.GetAttrPool().GetItemSurrogates(RES_BOXATR_FORMULA))
618 {
619 auto pBoxFormula = const_cast<SwTableBoxFormula*>(pItem->DynamicWhichCast(RES_BOXATR_FORMULA));
620 if(pBoxFormula && pBoxFormula->GetDefinedIn())
621 pBoxFormula->ChangeState();
622 }
623
624 SwRootFrame const* pLayout(nullptr);
625 for (SwRootFrame const*const pLay : m_rDoc.GetAllLayouts())
626 {
627 assert(!pLayout || pLay->IsHideRedlines() == pLayout->IsHideRedlines()); // TODO
628 pLayout = pLay;
629 }
630
631 std::optional<SwCalc> oCalc;
632
633 if( pFieldType )
634 {
635 std::vector<SwFormatField*> vFields;
636 pFieldType->GatherFields(vFields);
637 for(SwFormatField* pFormatField: vFields)
638 {
639 // start calculation at the end
640 // new fields are inserted at the beginning of the modify chain
641 // that gives faster calculation on import
642 // mba: do we really need this "optimization"? Is it still valid?
643 SwTableField *const pField(static_cast<SwTableField*>(pFormatField->GetField()));
644 if (nsSwExtendedSubType::SUB_CMD & pField->GetSubType())
645 continue;
646
647 // needs to be recalculated
648 if( !pField->IsValid() )
649 {
650 // table where this field is located
651 const SwTextNode& rTextNd = pFormatField->GetTextField()->GetTextNode();
652 const SwTableNode* pTableNd = rTextNd.FindTableNode();
653 if( !pTableNd )
654 continue;
655
656 // if this field is not in the to-be-updated table, skip it
657 if(pTable && &pTableNd->GetTable() != pTable)
658 continue;
659
660 if( !oCalc )
661 oCalc.emplace( m_rDoc );
662
663 // get the values of all SetExpression fields that are valid
664 // until the table
665 SwFrame* pFrame = nullptr;
666 if( pTableNd->GetIndex() < m_rDoc.GetNodes().GetEndOfExtras().GetIndex() )
667 {
668 // is in the special section, that's expensive!
669 Point aPt; // return the first frame of the layout - Tab.Headline!!
670 std::pair<Point, bool> const tmp(aPt, true);
671 pFrame = rTextNd.getLayoutFrame(pLayout, nullptr, &tmp);
672 if( pFrame )
673 {
674 SwPosition aPos( *pTableNd );
675 if( GetBodyTextNode( m_rDoc, aPos, *pFrame ) )
676 {
677 FieldsToCalc( *oCalc, SetGetExpField(
678 aPos.GetNode(), pFormatField->GetTextField(),
679 aPos.GetContentIndex(), pFrame->GetPhyPageNum()),
680 pLayout);
681 }
682 else
683 pFrame = nullptr;
684 }
685 }
686 if( !pFrame )
687 {
688 // create index to determine the TextNode
689 SwFrame const*const pFrame2 = ::sw::FindNeighbourFrameForNode(rTextNd);
690 FieldsToCalc( *oCalc,
691 SetGetExpField(rTextNd, pFormatField->GetTextField(),
692 std::nullopt,
693 pFrame2 ? pFrame2->GetPhyPageNum() : 0),
694 pLayout);
695 }
696
697 SwTableCalcPara aPara(*oCalc, pTableNd->GetTable(), pLayout);
698 pField->CalcField( aPara );
699 if( aPara.IsStackOverflow() )
700 {
701 bool const bResult = aPara.CalcWithStackOverflow();
702 if (bResult)
703 {
704 pField->CalcField( aPara );
705 }
706 OSL_ENSURE(bResult,
707 "the chained formula could no be calculated");
708 }
709 oCalc->SetCalcError( SwCalcError::NONE );
710 }
711 pFormatField->ForceUpdateTextNode();
712 }
713 }
714
715 // calculate the formula at the boxes
716 for (const SfxPoolItem* pItem : m_rDoc.GetAttrPool().GetItemSurrogates(RES_BOXATR_FORMULA))
717 {
718 auto pFormula = const_cast<SwTableBoxFormula*>(pItem->DynamicWhichCast(RES_BOXATR_FORMULA));
719 if(!pFormula || !pFormula->GetDefinedIn() || pFormula->IsValid())
720 continue;
721 SwTableBox* pBox = pFormula->GetTableBox();
722 if(!pBox || !pBox->GetSttNd() || !pBox->GetSttNd()->GetNodes().IsDocNodes())
723 continue;
724 const SwTableNode* pTableNd = pBox->GetSttNd()->FindTableNode();
725 if(pTable && &pTableNd->GetTable() != pTable)
726 continue;
727 double nValue;
728 if( !oCalc )
729 oCalc.emplace( m_rDoc );
730
731 // get the values of all SetExpression fields that are valid
732 // until the table
733 SwFrame* pFrame = nullptr;
734 if( pTableNd->GetIndex() < m_rDoc.GetNodes().GetEndOfExtras().GetIndex() )
735 {
736 // is in the special section, that's expensive!
737 SwNodeIndex aCNdIdx( *pTableNd, +2 );
738 SwContentNode* pCNd = aCNdIdx.GetNode().GetContentNode();
739 if( !pCNd )
740 pCNd = m_rDoc.GetNodes().GoNext( &aCNdIdx );
741
742 if (pCNd)
743 {
744 Point aPt; // return the first frame of the layout - Tab.Headline!!
745 std::pair<Point, bool> const tmp(aPt, true);
746 pFrame = pCNd->getLayoutFrame(pLayout, nullptr, &tmp);
747 if( pFrame )
748 {
749 SwPosition aPos( *pCNd );
750 if( GetBodyTextNode( m_rDoc, aPos, *pFrame ) )
751 {
752 FieldsToCalc(*oCalc, SetGetExpField(aPos.GetNode(),
753 nullptr, std::nullopt, pFrame->GetPhyPageNum()),
754 pLayout);
755 }
756 else
757 pFrame = nullptr;
758 }
759 }
760 }
761 if( !pFrame )
762 {
763 // create index to determine the TextNode
764 SwFrame const*const pFrame2 = ::sw::FindNeighbourFrameForNode(*pTableNd);
765 FieldsToCalc(*oCalc, SetGetExpField(*pTableNd, nullptr, std::nullopt,
766 pFrame2 ? pFrame2->GetPhyPageNum() : 0),
767 pLayout);
768 }
769
770 SwTableCalcPara aPara(*oCalc, pTableNd->GetTable(), pLayout);
771 pFormula->Calc( aPara, nValue );
772
773 if( aPara.IsStackOverflow() )
774 {
775 bool const bResult = aPara.CalcWithStackOverflow();
776 if (bResult)
777 {
778 pFormula->Calc( aPara, nValue );
779 }
780 OSL_ENSURE(bResult,
781 "the chained formula could no be calculated");
782 }
783
784 SwFrameFormat* pFormat = pBox->ClaimFrameFormat();
785 SfxItemSetFixed<RES_BOXATR_BEGIN,RES_BOXATR_END-1> aTmp( m_rDoc.GetAttrPool() );
786
787 if( oCalc->IsCalcError() )
788 nValue = DBL_MAX;
789 aTmp.Put( SwTableBoxValue( nValue ));
790 if( SfxItemState::SET != pFormat->GetItemState( RES_BOXATR_FORMAT ))
791 aTmp.Put( SwTableBoxNumFormat( 0 ));
792 pFormat->SetFormatAttr( aTmp );
793
794 oCalc->SetCalcError( SwCalcError::NONE );
795 }
796 }
797
798 void DocumentFieldsManager::UpdateExpFields( SwTextField* pUpdateField, bool bUpdRefFields )
799 {
800 if( IsExpFieldsLocked() || m_rDoc.IsInReading() )
801 return;
802
803 bool bOldInUpdateFields = mpUpdateFields->IsInUpdateFields();
804 mpUpdateFields->SetInUpdateFields( true );
805
806 mpUpdateFields->MakeFieldList( m_rDoc, true, GETFLD_ALL );
807 mbNewFieldLst = false;
808
809 if (mpUpdateFields->GetSortList()->empty())
810 {
811 if( bUpdRefFields )
812 UpdateRefFields();
813
814 mpUpdateFields->SetInUpdateFields( bOldInUpdateFields );
815 mpUpdateFields->SetFieldsDirty( false );
816 return ;
817 }
818
819 SwRootFrame const* pLayout(nullptr);
820 SwRootFrame const* pLayoutRLHidden(nullptr);
821 for (SwRootFrame const*const pLay : m_rDoc.GetAllLayouts())
822 {
823 if (pLay->IsHideRedlines())
824 {
825 pLayoutRLHidden = pLay;
826 }
827 else
828 {
829 pLayout = pLay;
830 }
831 }
832 if (pLayout || !pLayoutRLHidden) // always calc *something*...
833 {
834 UpdateExpFieldsImpl(pUpdateField, pLayout);
835 }
836 if (pLayoutRLHidden)
837 {
838 UpdateExpFieldsImpl(pUpdateField, pLayoutRLHidden);
839 }
840
841 // update reference fields
842 if( bUpdRefFields )
843 UpdateRefFields();
844
845 mpUpdateFields->SetInUpdateFields( bOldInUpdateFields );
846 mpUpdateFields->SetFieldsDirty( false );
847 }
848
849 void DocumentFieldsManager::UpdateExpFieldsImpl(
850 SwTextField * pUpdateField, SwRootFrame const*const pLayout)
851 {
852 SwFieldIds nWhich;
853
854 // Hash table for all string replacements is filled on-the-fly.
855 // Try to fabricate an uneven number.
856 const SwFieldTypes::size_type nHashSize {(( mpFieldTypes->size() / 7 ) + 1 ) * 7};
857 const sal_uInt16 nStrFormatCnt = o3tl::narrowing<sal_uInt16>(nHashSize);
858 OSL_ENSURE( nStrFormatCnt == nHashSize, "Downcasting to sal_uInt16 lost information!" );
859 SwHashTable<HashStr> aHashStrTable(nStrFormatCnt);
860
861 {
862 const SwFieldType* pFieldType;
863 // process separately:
864 for( auto n = mpFieldTypes->size(); n; )
865 {
866 pFieldType = (*mpFieldTypes)[ --n ].get();
867 switch( pFieldType->Which() )
868 {
869 case SwFieldIds::User:
870 {
871 // Entry present?
872 sal_uInt32 nPos;
873 const OUString& rNm = pFieldType->GetName();
874 OUString sExpand(const_cast<SwUserFieldType*>(static_cast<const SwUserFieldType*>(pFieldType))->Expand(nsSwGetSetExpType::GSE_STRING, 0, LANGUAGE_SYSTEM));
875 SwHash* pFnd = aHashStrTable.Find( rNm, &nPos );
876 if( pFnd )
877 // modify entry in the hash table
878 static_cast<HashStr*>(pFnd)->aSetStr = sExpand;
879 else
880 // insert the new entry
881 aHashStrTable[nPos].reset( new HashStr( rNm, sExpand,
882 aHashStrTable[nPos].release() ) );
883 }
884 break;
885 default: break;
886 }
887 }
888 }
889
890 // The array is filled with all fields; start calculation.
891 SwCalc aCalc( m_rDoc );
892
893 #if HAVE_FEATURE_DBCONNECTIVITY && !ENABLE_FUZZERS
894 OUString sDBNumNm( SwFieldType::GetTypeStr( SwFieldTypesEnum::DatabaseSetNumber ) );
895
896 // already set the current record number
897 SwDBManager* pMgr = m_rDoc.GetDBManager();
898 pMgr->CloseAll( false );
899
900 SvtSysLocale aSysLocale;
901 const LocaleDataWrapper* pLclData = &aSysLocale.GetLocaleData();
902 const LanguageType nLang = pLclData->getLanguageTag().getLanguageType();
903 bool bCanFill = pMgr->FillCalcWithMergeData( m_rDoc.GetNumberFormatter(), nLang, aCalc );
904 #endif
905
906 // Make sure we don't hide all content, which would lead to a crash. First, count how many visible sections we have.
907 int nShownSections = 0;
908 SwNodeOffset nContentStart = m_rDoc.GetNodes().GetEndOfContent().StartOfSectionIndex() + 1;
909 SwNodeOffset nContentEnd = m_rDoc.GetNodes().GetEndOfContent().GetIndex();
910 SwSectionFormats& rSectFormats = m_rDoc.GetSections();
911 for( SwSectionFormats::size_type n = 0; n<rSectFormats.size(); ++n )
912 {
913 SwSectionFormat& rSectFormat = *rSectFormats[ n ];
914 SwSectionNode* pSectionNode = rSectFormat.GetSectionNode();
915 SwSection* pSect = rSectFormat.GetSection();
916
917 // Usually some of the content is not in a section: count that as a virtual section, so that all real sections can be hidden.
918 // Only look for section gaps at the lowest level, ignoring sub-sections.
919 if ( pSectionNode && !rSectFormat.GetParent() )
920 {
921 SwNodeIndex aNextIdx( *pSectionNode->EndOfSectionNode(), 1 );
922 if ( n == 0 && pSectionNode->GetIndex() != nContentStart )
923 nShownSections++; //document does not start with a section
924 if ( n == rSectFormats.size() - 1 )
925 {
926 if ( aNextIdx.GetIndex() != nContentEnd )
927 nShownSections++; //document does not end in a section
928 }
929 else if ( !aNextIdx.GetNode().IsSectionNode() )
930 nShownSections++; //section is not immediately followed by another section
931 }
932
933 // count only visible sections
934 if ( pSect && !pSect->CalcHiddenFlag())
935 nShownSections++;
936 }
937
938 IDocumentRedlineAccess const& rIDRA(m_rDoc.getIDocumentRedlineAccess());
939 std::unordered_map<SwSetExpFieldType const*, SwTextNode const*> SetExpOutlineNodeMap;
940
941 for (std::unique_ptr<SetGetExpField> const& it : *mpUpdateFields->GetSortList())
942 {
943 SwSection* pSect = const_cast<SwSection*>(it->GetSection());
944 if( pSect )
945 {
946 SwSbxValue aValue = aCalc.Calculate(
947 pSect->GetCondition() );
948 if(!aValue.IsVoidValue())
949 {
950 // Do we want to hide this one?
951 bool bHide = aValue.GetBool();
952 if (bHide && !pSect->IsCondHidden())
953 {
954 // This section will be hidden, but it wasn't before
955 if (nShownSections == 1)
956 {
957 // This would be the last section, so set its condition to false, and avoid hiding it.
958 pSect->SetCondition("0");
959 bHide = false;
960 }
961 nShownSections--;
962 }
963 pSect->SetCondHidden( bHide );
964 }
965 continue;
966 }
967 ::sw::mark::IBookmark *const pBookmark(
968 const_cast<::sw::mark::IBookmark *>(it->GetBookmark()));
969 if (pBookmark)
970 {
971 SwSbxValue const aValue(aCalc.Calculate(pBookmark->GetHideCondition()));
972 if (!aValue.IsVoidValue())
973 {
974 pBookmark->Hide(aValue.GetBool());
975 }
976 continue;
977 }
978
979 SwTextField* pTextField = const_cast<SwTextField*>(it->GetTextField());
980 if( !pTextField )
981 {
982 OSL_ENSURE( false, "what's wrong now'" );
983 continue;
984 }
985
986 if (pLayout && pLayout->IsHideRedlines()
987 && IsFieldDeleted(rIDRA, *pLayout, *pTextField))
988 {
989 continue;
990 }
991
992 SwFormatField* pFormatField = const_cast<SwFormatField*>(&pTextField->GetFormatField());
993 const SwField* pField = pFormatField->GetField();
994
995 nWhich = pField->GetTyp()->Which();
996 switch( nWhich )
997 {
998 case SwFieldIds::HiddenText:
999 {
1000 SwHiddenTextField* pHField = const_cast<SwHiddenTextField*>(static_cast<const SwHiddenTextField*>(pField));
1001 SwSbxValue aValue = aCalc.Calculate( pHField->GetPar1() );
1002 bool bValue = !aValue.GetBool();
1003 if(!aValue.IsVoidValue())
1004 {
1005 pHField->SetValue( bValue );
1006 // evaluate field
1007 pHField->Evaluate(m_rDoc);
1008 }
1009 }
1010 break;
1011 case SwFieldIds::HiddenPara:
1012 {
1013 SwHiddenParaField* pHPField = const_cast<SwHiddenParaField*>(static_cast<const SwHiddenParaField*>(pField));
1014 SwSbxValue aValue = aCalc.Calculate( pHPField->GetPar1() );
1015 bool bValue = aValue.GetBool();
1016 if(!aValue.IsVoidValue())
1017 pHPField->SetHidden( bValue );
1018 }
1019 break;
1020 case SwFieldIds::DbSetNumber:
1021 #if HAVE_FEATURE_DBCONNECTIVITY && !ENABLE_FUZZERS
1022 {
1023 const_cast<SwDBSetNumberField*>(static_cast<const SwDBSetNumberField*>(pField))->Evaluate(m_rDoc);
1024 aCalc.VarChange( sDBNumNm, static_cast<const SwDBSetNumberField*>(pField)->GetSetNumber());
1025 pField->ExpandField(m_rDoc.IsClipBoard(), nullptr);
1026 }
1027 #endif
1028 break;
1029 case SwFieldIds::DbNextSet:
1030 case SwFieldIds::DbNumSet:
1031 #if HAVE_FEATURE_DBCONNECTIVITY && !ENABLE_FUZZERS
1032 {
1033 UpdateDBNumFields( *const_cast<SwDBNameInfField*>(static_cast<const SwDBNameInfField*>(pField)), aCalc );
1034 if( bCanFill )
1035 bCanFill = pMgr->FillCalcWithMergeData( m_rDoc.GetNumberFormatter(), nLang, aCalc );
1036 }
1037 #endif
1038 break;
1039 case SwFieldIds::Database:
1040 {
1041 #if HAVE_FEATURE_DBCONNECTIVITY && !ENABLE_FUZZERS
1042 // evaluate field
1043 const_cast<SwDBField*>(static_cast<const SwDBField*>(pField))->Evaluate();
1044
1045 SwDBData aTmpDBData(static_cast<const SwDBField*>(pField)->GetDBData());
1046
1047 if( pMgr->IsDataSourceOpen(aTmpDBData.sDataSource, aTmpDBData.sCommand, false))
1048 aCalc.VarChange( sDBNumNm, pMgr->GetSelectedRecordId(aTmpDBData.sDataSource, aTmpDBData.sCommand, aTmpDBData.nCommandType));
1049
1050 const OUString& rName = pField->GetTyp()->GetName();
1051
1052 // Add entry to hash table
1053 // Entry present?
1054 sal_uInt32 nPos;
1055 HashStr* pFnd = aHashStrTable.Find( rName, &nPos );
1056 OUString const value(pField->ExpandField(m_rDoc.IsClipBoard(), nullptr));
1057 if( pFnd )
1058 {
1059 // Modify entry in the hash table
1060 pFnd->aSetStr = value;
1061 }
1062 else
1063 {
1064 // insert new entry
1065 aHashStrTable[nPos].reset( new HashStr( rName,
1066 value, aHashStrTable[nPos].release()) );
1067 }
1068 #endif
1069 }
1070 break;
1071 case SwFieldIds::GetExp:
1072 case SwFieldIds::SetExp:
1073 {
1074 if( nsSwGetSetExpType::GSE_STRING & pField->GetSubType() ) // replace String
1075 {
1076 if( SwFieldIds::GetExp == nWhich )
1077 {
1078 SwGetExpField* pGField = const_cast<SwGetExpField*>(static_cast<const SwGetExpField*>(pField));
1079
1080 if( (!pUpdateField || pUpdateField == pTextField )
1081 && pGField->IsInBodyText() )
1082 {
1083 OUString aNew = LookString( aHashStrTable, pGField->GetFormula() );
1084 pGField->ChgExpStr( aNew, pLayout );
1085 }
1086 }
1087 else
1088 {
1089 SwSetExpField* pSField = const_cast<SwSetExpField*>(static_cast<const SwSetExpField*>(pField));
1090 // is the "formula" a field?
1091 OUString aNew = LookString( aHashStrTable, pSField->GetFormula() );
1092
1093 if( aNew.isEmpty() ) // nothing found then the formula is the new value
1094 aNew = pSField->GetFormula();
1095
1096 // only update one field
1097 if( !pUpdateField || pUpdateField == pTextField )
1098 pSField->ChgExpStr( aNew, pLayout );
1099
1100 // lookup the field's name
1101 aNew = static_cast<SwSetExpFieldType*>(pSField->GetTyp())->GetSetRefName();
1102 // Entry present?
1103 sal_uInt32 nPos;
1104 HashStr* pFnd = aHashStrTable.Find( aNew, &nPos );
1105 if( pFnd )
1106 // Modify entry in the hash table
1107 pFnd->aSetStr = pSField->GetExpStr(pLayout);
1108 else
1109 {
1110 // insert new entry
1111 aHashStrTable[nPos].reset( new HashStr( aNew,
1112 pSField->GetExpStr(pLayout),
1113 aHashStrTable[nPos].release() ) );
1114 pFnd = aHashStrTable[nPos].get();
1115 }
1116
1117 // Extension for calculation with Strings
1118 SwSbxValue aValue;
1119 aValue.PutString( pFnd->aSetStr );
1120 aCalc.VarChange( aNew, aValue );
1121 }
1122 }
1123 else // recalculate formula
1124 {
1125 if( SwFieldIds::GetExp == nWhich )
1126 {
1127 SwGetExpField* pGField = const_cast<SwGetExpField*>(static_cast<const SwGetExpField*>(pField));
1128
1129 if( (!pUpdateField || pUpdateField == pTextField )
1130 && pGField->IsInBodyText() )
1131 {
1132 SwSbxValue aValue = aCalc.Calculate(
1133 pGField->GetFormula());
1134 if(!aValue.IsVoidValue())
1135 pGField->SetValue(aValue.GetDouble(), pLayout);
1136 }
1137 }
1138 else
1139 {
1140 SwSetExpField* pSField = const_cast<SwSetExpField*>(static_cast<const SwSetExpField*>(pField));
1141 SwSetExpFieldType* pSFieldTyp = static_cast<SwSetExpFieldType*>(pField->GetTyp());
1142 OUString aNew = pSFieldTyp->GetName();
1143
1144 SwNode* pSeqNd = nullptr;
1145
1146 if( pSField->IsSequenceField() )
1147 {
1148 const sal_uInt8 nLvl = pSFieldTyp->GetOutlineLvl();
1149 if( MAXLEVEL > nLvl )
1150 {
1151 // test if the Number needs to be updated
1152 pSeqNd = m_rDoc.GetNodes()[ it->GetNode() ];
1153
1154 const SwTextNode* pOutlNd = pSeqNd->
1155 FindOutlineNodeOfLevel(nLvl, pLayout);
1156 auto const iter(SetExpOutlineNodeMap.find(pSFieldTyp));
1157 if (iter == SetExpOutlineNodeMap.end()
1158 || iter->second != pOutlNd)
1159 {
1160 SetExpOutlineNodeMap[pSFieldTyp] = pOutlNd;
1161 aCalc.VarChange( aNew, 0 );
1162 }
1163 }
1164 }
1165
1166 aNew += "=" + pSField->GetFormula();
1167
1168 SwSbxValue aValue = aCalc.Calculate( aNew );
1169 if (!aCalc.IsCalcError())
1170 {
1171 double nErg = aValue.GetDouble();
1172 // only update one field
1173 if( !aValue.IsVoidValue() && (!pUpdateField || pUpdateField == pTextField) )
1174 {
1175 pSField->SetValue(nErg, pLayout);
1176
1177 if( pSeqNd )
1178 pSFieldTyp->SetChapter(*pSField, *pSeqNd, pLayout);
1179 }
1180 }
1181 }
1182 }
1183 }
1184 break;
1185 default: break;
1186 } // switch
1187
1188 {
1189 // avoid calling ReplaceText() for input fields, it is pointless
1190 // here and moves the cursor if it's inside the field ...
1191 SwTextInputField *const pInputField(
1192 pUpdateField == pTextField // ... except once, when the dialog
1193 ? nullptr // is used to change content via UpdateOneField()
1194 : dynamic_cast<SwTextInputField *>(pTextField));
1195 if (pInputField)
1196 {
1197 bool const tmp = pInputField->LockNotifyContentChange();
1198 (void) tmp;
1199 assert(tmp && "should not be locked here?");
1200 }
1201 ::comphelper::ScopeGuard g([pInputField]()
1202 {
1203 if (pInputField)
1204 {
1205 pInputField->UnlockNotifyContentChange();
1206 }
1207 });
1208 pFormatField->ForceUpdateTextNode();
1209 }
1210
1211 if (pUpdateField == pTextField) // if only this one is updated
1212 {
1213 if( SwFieldIds::GetExp == nWhich || // only GetField or
1214 SwFieldIds::HiddenText == nWhich || // HiddenText?
1215 SwFieldIds::HiddenPara == nWhich) // HiddenParaField?
1216 break; // quit
1217 pUpdateField = nullptr; // update all from here on
1218 }
1219 }
1220
1221 #if HAVE_FEATURE_DBCONNECTIVITY && !ENABLE_FUZZERS
1222 pMgr->CloseAll(false);
1223 #endif
1224 }
1225
1226 /// Insert field type that was marked as deleted
1227 void DocumentFieldsManager::UpdateUsrFields()
1228 {
1229 SwCalc* pCalc = nullptr;
1230 for( SwFieldTypes::size_type i = INIT_FLDTYPES; i < mpFieldTypes->size(); ++i )
1231 {
1232 const SwFieldType* pFieldType = (*mpFieldTypes)[i].get();
1233 if( SwFieldIds::User == pFieldType->Which() )
1234 {
1235 if( !pCalc )
1236 pCalc = new SwCalc( m_rDoc );
1237 const_cast<SwUserFieldType*>(static_cast<const SwUserFieldType*>(pFieldType))->GetValue( *pCalc );
1238 }
1239 }
1240
1241 if( pCalc )
1242 {
1243 delete pCalc;
1244 m_rDoc.getIDocumentState().SetModified();
1245 }
1246 }
1247
1248 sal_Int32 DocumentFieldsManager::GetRecordsPerDocument() const
1249 {
1250 sal_Int32 nRecords = 1;
1251
1252 mpUpdateFields->MakeFieldList( m_rDoc, true, GETFLD_ALL );
1253 if (mpUpdateFields->GetSortList()->empty())
1254 return nRecords;
1255
1256 for (std::unique_ptr<SetGetExpField> const& it : *mpUpdateFields->GetSortList())
1257 {
1258 const SwTextField *pTextField = it->GetTextField();
1259 if( !pTextField )
1260 continue;
1261
1262 const SwFormatField &pFormatField = pTextField->GetFormatField();
1263 const SwField* pField = pFormatField.GetField();
1264
1265 switch( pField->GetTyp()->Which() )
1266 {
1267 case SwFieldIds::DbNextSet:
1268 case SwFieldIds::DbNumSet:
1269 nRecords++;
1270 break;
1271 default:
1272 break;
1273 }
1274 }
1275
1276 return nRecords;
1277 }
1278
1279 void DocumentFieldsManager::UpdatePageFields(const SwTwips nDocPos)
1280 {
1281 for(SwFieldTypes::size_type i = 0; i < INIT_FLDTYPES; ++i)
1282 {
1283 SwFieldType* pFieldType = (*mpFieldTypes)[i].get();
1284 switch(pFieldType->Which())
1285 {
1286 case SwFieldIds::PageNumber:
1287 case SwFieldIds::Chapter:
1288 case SwFieldIds::GetExp:
1289 case SwFieldIds::RefPageGet:
1290 pFieldType->UpdateDocPos(nDocPos);
1291 break;
1292 case SwFieldIds::DocStat:
1293 pFieldType->CallSwClientNotify(sw::LegacyModifyHint(nullptr, nullptr));
1294 break;
1295 default: break;
1296 }
1297 }
1298 SetNewFieldLst(true);
1299 }
1300
1301 void DocumentFieldsManager::LockExpFields()
1302 {
1303 ++mnLockExpField;
1304 }
1305
1306 void DocumentFieldsManager::UnlockExpFields()
1307 {
1308 assert(mnLockExpField != 0);
1309 if( mnLockExpField )
1310 --mnLockExpField;
1311 }
1312
1313 bool DocumentFieldsManager::IsExpFieldsLocked() const
1314 {
1315 return 0 != mnLockExpField;
1316 }
1317
1318 SwDocUpdateField& DocumentFieldsManager::GetUpdateFields() const
1319 {
1320 return *mpUpdateFields;
1321 }
1322
1323 bool DocumentFieldsManager::SetFieldsDirty( bool b, const SwNode* pChk, SwNodeOffset nLen )
1324 {
1325 // See if the supplied nodes actually contain fields.
1326 // If they don't, the flag doesn't need to be changed.
1327 bool bFieldsFnd = false;
1328 if( b && pChk && !GetUpdateFields().IsFieldsDirty() && !m_rDoc.IsInDtor()
1329 // ?? what's up with Undo, this is also wanted there!
1330 /*&& &pChk->GetNodes() == &GetNodes()*/ )
1331 {
1332 b = false;
1333 if( !nLen )
1334 ++nLen;
1335 SwNodeOffset nStt = pChk->GetIndex();
1336 const SwNodes& rNds = pChk->GetNodes();
1337 while( nLen-- )
1338 {
1339 const SwTextNode* pTNd = rNds[ nStt++ ]->GetTextNode();
1340 if( pTNd )
1341 {
1342 if( pTNd->GetAttrOutlineLevel() != 0 )
1343 // update chapter fields
1344 b = true;
1345 else if( pTNd->GetpSwpHints() && pTNd->GetSwpHints().Count() )
1346 {
1347 const size_t nEnd = pTNd->GetSwpHints().Count();
1348 for( size_t n = 0 ; n < nEnd; ++n )
1349 {
1350 const SwTextAttr* pAttr = pTNd->GetSwpHints().Get(n);
1351 if ( pAttr->Which() == RES_TXTATR_FIELD
1352 || pAttr->Which() == RES_TXTATR_INPUTFIELD)
1353 {
1354 b = true;
1355 break;
1356 }
1357 }
1358 }
1359
1360 if( b )
1361 break;
1362 }
1363 }
1364 bFieldsFnd = b;
1365 }
1366 GetUpdateFields().SetFieldsDirty( b );
1367 return bFieldsFnd;
1368 }
1369
1370 void DocumentFieldsManager::SetFixFields( const DateTime* pNewDateTime )
1371 {
1372 bool bIsModified = m_rDoc.getIDocumentState().IsModified();
1373
1374 sal_Int32 nDate;
1375 sal_Int64 nTime;
1376 if( pNewDateTime )
1377 {
1378 nDate = pNewDateTime->GetDate();
1379 nTime = pNewDateTime->GetTime();
1380 }
1381 else
1382 {
1383 DateTime aDateTime( DateTime::SYSTEM );
1384 nDate = aDateTime.GetDate();
1385 nTime = aDateTime.GetTime();
1386 }
1387
1388 SwFieldIds const aTypes[] {
1389 /*0*/ SwFieldIds::DocInfo,
1390 /*1*/ SwFieldIds::Author,
1391 /*2*/ SwFieldIds::ExtUser,
1392 /*3*/ SwFieldIds::Filename,
1393 /*4*/ SwFieldIds::DateTime }; // MUST be at the end!
1394
1395 for(SwFieldIds aType : aTypes)
1396 {
1397 std::vector<SwFormatField*> vFields;
1398 GetSysFieldType(aType)->GatherFields(vFields);
1399 for(auto pFormatField: vFields)
1400 {
1401 if (pFormatField->GetTextField())
1402 {
1403 bool bChgd = false;
1404 switch( aType )
1405 {
1406 case SwFieldIds::DocInfo:
1407 if( static_cast<SwDocInfoField*>(pFormatField->GetField())->IsFixed() )
1408 {
1409 bChgd = true;
1410 SwDocInfoField* pDocInfField = static_cast<SwDocInfoField*>(pFormatField->GetField());
1411 pDocInfField->SetExpansion( static_cast<SwDocInfoFieldType*>(
1412 pDocInfField->GetTyp())->Expand(
1413 pDocInfField->GetSubType(),
1414 pDocInfField->GetFormat(),
1415 pDocInfField->GetLanguage(),
1416 pDocInfField->GetName() ) );
1417 }
1418 break;
1419
1420 case SwFieldIds::Author:
1421 if( static_cast<SwAuthorField*>(pFormatField->GetField())->IsFixed() )
1422 {
1423 bChgd = true;
1424 SwAuthorField* pAuthorField = static_cast<SwAuthorField*>(pFormatField->GetField());
1425 pAuthorField->SetExpansion( SwAuthorFieldType::Expand( pAuthorField->GetFormat() ) );
1426 }
1427 break;
1428
1429 case SwFieldIds::ExtUser:
1430 if( static_cast<SwExtUserField*>(pFormatField->GetField())->IsFixed() )
1431 {
1432 bChgd = true;
1433 SwExtUserField* pExtUserField = static_cast<SwExtUserField*>(pFormatField->GetField());
1434 pExtUserField->SetExpansion( SwExtUserFieldType::Expand(pExtUserField->GetSubType()) );
1435 }
1436 break;
1437
1438 case SwFieldIds::DateTime:
1439 if( static_cast<SwDateTimeField*>(pFormatField->GetField())->IsFixed() )
1440 {
1441 bChgd = true;
1442 static_cast<SwDateTimeField*>(pFormatField->GetField())->SetDateTime(
1443 DateTime(Date(nDate), tools::Time(nTime)) );
1444 }
1445 break;
1446
1447 case SwFieldIds::Filename:
1448 if( static_cast<SwFileNameField*>(pFormatField->GetField())->IsFixed() )
1449 {
1450 bChgd = true;
1451 SwFileNameField* pFileNameField =
1452 static_cast<SwFileNameField*>(pFormatField->GetField());
1453 pFileNameField->SetExpansion( static_cast<SwFileNameFieldType*>(
1454 pFileNameField->GetTyp())->Expand(
1455 pFileNameField->GetFormat() ) );
1456 }
1457 break;
1458 default: break;
1459 }
1460
1461 // Trigger formatting
1462 if( bChgd )
1463 pFormatField->ForceUpdateTextNode();
1464 }
1465 }
1466 }
1467
1468 if( !bIsModified )
1469 m_rDoc.getIDocumentState().ResetModified();
1470 }
1471
1472 void DocumentFieldsManager::FieldsToCalc(SwCalc& rCalc,
1473 const SetGetExpField& rToThisField, SwRootFrame const*const pLayout)
1474 {
1475 // create the sorted list of all SetFields
1476 mpUpdateFields->MakeFieldList( m_rDoc, mbNewFieldLst, GETFLD_CALC );
1477 mbNewFieldLst = false;
1478
1479 #if !HAVE_FEATURE_DBCONNECTIVITY || ENABLE_FUZZERS
1480 SwDBManager* pMgr = NULL;
1481 #else
1482 SwDBManager* pMgr = m_rDoc.GetDBManager();
1483 pMgr->CloseAll(false);
1484 #endif
1485
1486 if (!mpUpdateFields->GetSortList()->empty())
1487 {
1488 SetGetExpFields::const_iterator const itLast =
1489 mpUpdateFields->GetSortList()->upper_bound(
1490 &rToThisField);
1491 for (auto it = mpUpdateFields->GetSortList()->begin(); it != itLast; ++it)
1492 {
1493 lcl_CalcField(m_rDoc, rCalc, **it, pMgr, pLayout);
1494 }
1495 }
1496 #if HAVE_FEATURE_DBCONNECTIVITY && !ENABLE_FUZZERS
1497 pMgr->CloseAll(false);
1498 #endif
1499 }
1500
1501 void DocumentFieldsManager::FieldsToCalc(SwCalc& rCalc,
1502 SwNodeOffset const nLastNd, sal_Int32 const nLastCnt)
1503 {
1504 // create the sorted list of all SetFields
1505 mpUpdateFields->MakeFieldList( m_rDoc, mbNewFieldLst, GETFLD_CALC );
1506 mbNewFieldLst = false;
1507
1508 #if !HAVE_FEATURE_DBCONNECTIVITY || ENABLE_FUZZERS
1509 SwDBManager* pMgr = NULL;
1510 #else
1511 SwDBManager* pMgr = m_rDoc.GetDBManager();
1512 pMgr->CloseAll(false);
1513 #endif
1514
1515 SwRootFrame const* pLayout(nullptr);
1516 SwRootFrame const* pLayoutRLHidden(nullptr);
1517 for (SwRootFrame const*const pLay : m_rDoc.GetAllLayouts())
1518 {
1519 if (pLay->IsHideRedlines())
1520 {
1521 pLayoutRLHidden = pLay;
1522 }
1523 else
1524 {
1525 pLayout = pLay;
1526 }
1527 }
1528
1529 // note this is not duplicate of the other FieldsToCalc because there is
1530 // (currently) no SetGetExpField that compares only a position
1531 for(auto it = mpUpdateFields->GetSortList()->begin();
1532 it != mpUpdateFields->GetSortList()->end() &&
1533 ( (*it)->GetNode() < nLastNd ||
1534 ( (*it)->GetNode() == nLastNd && (*it)->GetContent() <= nLastCnt )
1535 );
1536 ++it )
1537 {
1538 if (pLayout || !pLayoutRLHidden) // always calc *something*...
1539 {
1540 lcl_CalcField( m_rDoc, rCalc, **it, pMgr, pLayout );
1541 }
1542 if (pLayoutRLHidden)
1543 {
1544 lcl_CalcField( m_rDoc, rCalc, **it, pMgr, pLayoutRLHidden );
1545 }
1546 }
1547
1548 #if HAVE_FEATURE_DBCONNECTIVITY && !ENABLE_FUZZERS
1549 pMgr->CloseAll(false);
1550 #endif
1551 }
1552
1553 void DocumentFieldsManager::FieldsToExpand( SwHashTable<HashStr> & rHashTable,
1554 const SetGetExpField& rToThisField, SwRootFrame const& rLayout)
1555 {
1556 // create the sorted list of all SetFields
1557 mpUpdateFields->MakeFieldList( m_rDoc, mbNewFieldLst, GETFLD_EXPAND );
1558 mbNewFieldLst = false;
1559
1560 IDocumentRedlineAccess const& rIDRA(m_rDoc.getIDocumentRedlineAccess());
1561
1562 // Hash table for all string replacements is filled on-the-fly.
1563 // Try to fabricate an uneven number.
1564 sal_uInt16 nTableSize = ((mpUpdateFields->GetSortList()->size() / 7) + 1) * 7;
1565 rHashTable.resize(nTableSize);
1566
1567 SetGetExpFields::const_iterator const itLast =
1568 mpUpdateFields->GetSortList()->upper_bound(&rToThisField);
1569
1570 for (auto it = mpUpdateFields->GetSortList()->begin(); it != itLast; ++it)
1571 {
1572 const SwTextField* pTextField = (*it)->GetTextField();
1573 if( !pTextField )
1574 continue;
1575
1576 if (rLayout.IsHideRedlines()
1577 && IsFieldDeleted(rIDRA, rLayout, *pTextField))
1578 {
1579 continue;
1580 }
1581
1582 const SwField* pField = pTextField->GetFormatField().GetField();
1583 switch( pField->GetTyp()->Which() )
1584 {
1585 case SwFieldIds::SetExp:
1586 if( nsSwGetSetExpType::GSE_STRING & pField->GetSubType() )
1587 {
1588 // set the new value in the hash table
1589 // is the formula a field?
1590 SwSetExpField* pSField = const_cast<SwSetExpField*>(static_cast<const SwSetExpField*>(pField));
1591 OUString aNew = LookString( rHashTable, pSField->GetFormula() );
1592
1593 if( aNew.isEmpty() ) // nothing found, then the formula is
1594 aNew = pSField->GetFormula(); // the new value
1595
1596 // #i3141# - update expression of field as in method
1597 // <SwDoc::UpdateExpFields(..)> for string/text fields
1598 pSField->ChgExpStr(aNew, &rLayout);
1599
1600 // look up the field's name
1601 aNew = static_cast<SwSetExpFieldType*>(pSField->GetTyp())->GetSetRefName();
1602 // Entry present?
1603 sal_uInt32 nPos;
1604 SwHash* pFnd = rHashTable.Find( aNew, &nPos );
1605 if( pFnd )
1606 // modify entry in the hash table
1607 static_cast<HashStr*>(pFnd)->aSetStr = pSField->GetExpStr(&rLayout);
1608 else
1609 // insert the new entry
1610 rHashTable[nPos].reset( new HashStr( aNew,
1611 pSField->GetExpStr(&rLayout), rHashTable[nPos].release()));
1612 }
1613 break;
1614 case SwFieldIds::Database:
1615 {
1616 const OUString& rName = pField->GetTyp()->GetName();
1617
1618 // Insert entry in the hash table
1619 // Entry present?
1620 sal_uInt32 nPos;
1621 HashStr* pFnd = rHashTable.Find( rName, &nPos );
1622 OUString const value(pField->ExpandField(m_rDoc.IsClipBoard(), nullptr));
1623 if( pFnd )
1624 {
1625 // modify entry in the hash table
1626 pFnd->aSetStr = value;
1627 }
1628 else
1629 {
1630 // insert the new entry
1631 rHashTable[nPos].reset( new HashStr( rName,
1632 value, rHashTable[nPos].release()) );
1633 }
1634 }
1635 break;
1636 default: break;
1637 }
1638 }
1639 }
1640
1641
1642 bool DocumentFieldsManager::IsNewFieldLst() const
1643 {
1644 return mbNewFieldLst;
1645 }
1646
1647 void DocumentFieldsManager::SetNewFieldLst(bool bFlag)
1648 {
1649 mbNewFieldLst = bFlag;
1650 }
1651
1652 void DocumentFieldsManager::InsDelFieldInFieldLst( bool bIns, const SwTextField& rField )
1653 {
1654 if (!mbNewFieldLst && !m_rDoc.IsInDtor())
1655 mpUpdateFields->InsDelFieldInFieldLst( bIns, rField );
1656 }
1657
1658 SwField * DocumentFieldsManager::GetFieldAtPos(const SwPosition & rPos)
1659 {
1660 SwTextField * const pAttr = GetTextFieldAtPos(rPos);
1661
1662 return pAttr ? const_cast<SwField *>( pAttr->GetFormatField().GetField() ) : nullptr;
1663 }
1664
1665 SwTextField * DocumentFieldsManager::GetTextFieldAtPos(const SwPosition & rPos)
1666 {
1667 SwTextNode * const pNode = rPos.GetNode().GetTextNode();
1668
1669 return (pNode != nullptr)
1670 ? pNode->GetFieldTextAttrAt(rPos.GetContentIndex(), ::sw::GetTextAttrMode::Default)
1671 : nullptr;
1672 }
1673
1674 /// @note For simplicity assume that all field types have updatable contents so
1675 /// optimization currently only available when no fields exist.
1676 bool DocumentFieldsManager::containsUpdatableFields()
1677 {
1678 std::vector<SwFormatField*> vFields;
1679 for (auto const& pFieldType: *mpFieldTypes)
1680 {
1681 pFieldType->GatherFields(vFields);
1682 if(vFields.size()>0)
1683 return true;
1684 }
1685 return false;
1686 }
1687
1688 /// Remove all unreferenced field types of a document
1689 void DocumentFieldsManager::GCFieldTypes()
1690 {
1691 for( auto n = mpFieldTypes->size(); n > INIT_FLDTYPES; )
1692 if( !(*mpFieldTypes)[ --n ]->HasWriterListeners() )
1693 RemoveFieldType( n );
1694 }
1695
1696 void DocumentFieldsManager::InitFieldTypes() // is being called by the CTOR
1697 {
1698 // Field types
1699 mpFieldTypes->emplace_back( new SwDateTimeFieldType(&m_rDoc) );
1700 mpFieldTypes->emplace_back( new SwChapterFieldType );
1701 mpFieldTypes->emplace_back( new SwPageNumberFieldType );
1702 mpFieldTypes->emplace_back( new SwAuthorFieldType );
1703 mpFieldTypes->emplace_back( new SwFileNameFieldType(m_rDoc) );
1704 mpFieldTypes->emplace_back( new SwDBNameFieldType(&m_rDoc) );
1705 mpFieldTypes->emplace_back( new SwGetExpFieldType(&m_rDoc) );
1706 mpFieldTypes->emplace_back( new SwGetRefFieldType(m_rDoc) );
1707 mpFieldTypes->emplace_back( new SwHiddenTextFieldType );
1708 mpFieldTypes->emplace_back( new SwPostItFieldType(m_rDoc) );
1709 mpFieldTypes->emplace_back( new SwDocStatFieldType(m_rDoc) );
1710 mpFieldTypes->emplace_back( new SwDocInfoFieldType(&m_rDoc) );
1711 mpFieldTypes->emplace_back( new SwInputFieldType( &m_rDoc ) );
1712 mpFieldTypes->emplace_back( new SwTableFieldType( &m_rDoc ) );
1713 mpFieldTypes->emplace_back( new SwMacroFieldType(m_rDoc) );
1714 mpFieldTypes->emplace_back( new SwHiddenParaFieldType );
1715 mpFieldTypes->emplace_back( new SwDBNextSetFieldType );
1716 mpFieldTypes->emplace_back( new SwDBNumSetFieldType );
1717 mpFieldTypes->emplace_back( new SwDBSetNumberFieldType );
1718 mpFieldTypes->emplace_back( new SwTemplNameFieldType(m_rDoc) );
1719 mpFieldTypes->emplace_back( new SwTemplNameFieldType(m_rDoc) );
1720 mpFieldTypes->emplace_back( new SwExtUserFieldType );
1721 mpFieldTypes->emplace_back( new SwRefPageSetFieldType );
1722 mpFieldTypes->emplace_back( new SwRefPageGetFieldType(m_rDoc) );
1723 mpFieldTypes->emplace_back( new SwJumpEditFieldType(m_rDoc) );
1724 mpFieldTypes->emplace_back( new SwScriptFieldType(m_rDoc) );
1725 mpFieldTypes->emplace_back( new SwCombinedCharFieldType );
1726 mpFieldTypes->emplace_back( new SwDropDownFieldType );
1727
1728 // Types have to be at the end!
1729 // We expect this in the InsertFieldType!
1730 // MIB 14.04.95: In Sw3StringPool::Setup (sw3imp.cxx) and
1731 // lcl_sw3io_InSetExpField (sw3field.cxx) now also
1732 mpFieldTypes->emplace_back( new SwSetExpFieldType(&m_rDoc,
1733 SwResId(STR_POOLCOLL_LABEL_ABB), nsSwGetSetExpType::GSE_SEQ) );
1734 mpFieldTypes->emplace_back( new SwSetExpFieldType(&m_rDoc,
1735 SwResId(STR_POOLCOLL_LABEL_TABLE), nsSwGetSetExpType::GSE_SEQ) );
1736 mpFieldTypes->emplace_back( new SwSetExpFieldType(&m_rDoc,
1737 SwResId(STR_POOLCOLL_LABEL_FRAME), nsSwGetSetExpType::GSE_SEQ) );
1738 mpFieldTypes->emplace_back( new SwSetExpFieldType(&m_rDoc,
1739 SwResId(STR_POOLCOLL_LABEL_DRAWING), nsSwGetSetExpType::GSE_SEQ) );
1740 mpFieldTypes->emplace_back( new SwSetExpFieldType(&m_rDoc,
1741 SwResId(STR_POOLCOLL_LABEL_FIGURE), nsSwGetSetExpType::GSE_SEQ) );
1742
1743 assert( mpFieldTypes->size() == INIT_FLDTYPES );
1744 }
1745
1746 void DocumentFieldsManager::ClearFieldTypes()
1747 {
1748 mpFieldTypes->erase( mpFieldTypes->begin() + INIT_FLDTYPES, mpFieldTypes->end() );
1749 }
1750
1751 void DocumentFieldsManager::UpdateDBNumFields( SwDBNameInfField& rDBField, SwCalc& rCalc )
1752 {
1753 #if !HAVE_FEATURE_DBCONNECTIVITY || ENABLE_FUZZERS
1754 (void) rDBField;
1755 (void) rCalc;
1756 #else
1757 SwDBManager* pMgr = m_rDoc.GetDBManager();
1758
1759 SwFieldIds nFieldType = rDBField.Which();
1760
1761 bool bPar1 = rCalc.Calculate( rDBField.GetPar1() ).GetBool();
1762
1763 if( SwFieldIds::DbNextSet == nFieldType )
1764 static_cast<SwDBNextSetField&>(rDBField).SetCondValid( bPar1 );
1765 else
1766 static_cast<SwDBNumSetField&>(rDBField).SetCondValid( bPar1 );
1767
1768 if( !rDBField.GetRealDBData().sDataSource.isEmpty() )
1769 {
1770 // Edit a certain database
1771 if( SwFieldIds::DbNextSet == nFieldType )
1772 static_cast<SwDBNextSetField&>(rDBField).Evaluate(m_rDoc);
1773 else
1774 static_cast<SwDBNumSetField&>(rDBField).Evaluate(m_rDoc);
1775
1776 SwDBData aTmpDBData( rDBField.GetDBData(&m_rDoc) );
1777
1778 if( pMgr->OpenDataSource( aTmpDBData.sDataSource, aTmpDBData.sCommand ))
1779 rCalc.VarChange( lcl_GetDBVarName( m_rDoc, rDBField),
1780 pMgr->GetSelectedRecordId(aTmpDBData.sDataSource, aTmpDBData.sCommand, aTmpDBData.nCommandType) );
1781 }
1782 else
1783 {
1784 OSL_FAIL("TODO: what should happen with unnamed DBFields?");
1785 }
1786 #endif
1787 }
1788
1789 DocumentFieldsManager::~DocumentFieldsManager()
1790 {
1791 mpUpdateFields.reset();
1792 mpFieldTypes.reset();
1793 }
1794
1795 }
1796
1797 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE