/home/maarten/src/libreoffice/core/sw/source/core/unocore/unofield.cxx

Bug Summary

File:	home/maarten/src/libreoffice/core/sw/source/core/unocore/unofield.cxx
Warning:	line 1309, column 9 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name unofield.cxx -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -mframe-pointer=all -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/11.0.0 -isystem /usr/include/libxml2 -D BOOST_ERROR_CODE_HEADER_ONLY -D BOOST_SYSTEM_NO_DEPRECATED -D CPPU_ENV=gcc3 -D LINUX -D OSL_DEBUG_LEVEL=1 -D SAL_LOG_INFO -D SAL_LOG_WARN -D UNIX -D UNX -D X86_64 -D _PTHREADS -D _REENTRANT -D SW_DLLIMPLEMENTATION -D SWUI_DLL_NAME="libswuilo.so" -D SYSTEM_LIBXML -D EXCEPTIONS_ON -D LIBO_INTERNAL_ONLY -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source/i18n -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source/common -I /home/maarten/src/libreoffice/core/external/boost/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/boost -I /home/maarten/src/libreoffice/core/sw/source/core/inc -I /home/maarten/src/libreoffice/core/sw/source/filter/inc -I /home/maarten/src/libreoffice/core/sw/source/uibase/inc -I /home/maarten/src/libreoffice/core/sw/inc -I /home/maarten/src/libreoffice/core/workdir/SdiTarget/sw/sdi -I /home/maarten/src/libreoffice/core/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include/linux -I /home/maarten/src/libreoffice/core/config_host -I /home/maarten/src/libreoffice/core/workdir/CustomTarget/officecfg/registry -I /home/maarten/src/libreoffice/core/workdir/CustomTarget/sw/generated -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/udkapi/normal -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/offapi/normal -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/oovbaapi/normal -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10 -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/x86_64-redhat-linux -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/11.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O0 -Wno-missing-braces -std=c++17 -fdeprecated-macro -fdebug-compilation-dir /home/maarten/src/libreoffice/core -ferror-limit 19 -fvisibility hidden -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcxx-exceptions -fexceptions -debug-info-kind=constructor -analyzer-output=html -faddrsig -o /home/maarten/tmp/wis/scan-build-libreoffice/output/report/2020-10-07-141433-9725-1 -x c++ /home/maarten/src/libreoffice/core/sw/source/core/unocore/unofield.cxx

/home/maarten/src/libreoffice/core/sw/source/core/unocore/unofield.cxx

→

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
*   Licensed to the Apache Software Foundation (ASF) under one or more
*   contributor license agreements. See the NOTICE file distributed
*   with this work for additional information regarding copyright
*   ownership. The ASF licenses this file to you under the Apache
*   License, Version 2.0 (the "License"); you may not use this file
*   except in compliance with the License. You may obtain a copy of
*   the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/

20#include <sal/config.h>
21#include <algorithm>
22#include <memory>

24#include <unofield.hxx>
25#include <unofieldcoll.hxx>
26#include <swtypes.hxx>
27#include <cmdid.h>
28#include <doc.hxx>
29#include <IDocumentFieldsAccess.hxx>
30#include <IDocumentStatistics.hxx>
31#include <IDocumentStylePoolAccess.hxx>
32#include <IDocumentLayoutAccess.hxx>
33#include <IDocumentState.hxx>
34#include <hints.hxx>
35#include <fmtfld.hxx>
36#include <txtfld.hxx>
37#include <ndtxt.hxx>
38#include <unomap.hxx>
39#include <unoprnms.hxx>
40#include <unotextrange.hxx>
41#include <unotextcursor.hxx>
42#include <unocoll.hxx>
43#include <sfx2/linkmgr.hxx>
44#include <editsh.hxx>
45#include <viewsh.hxx>
46#include <comphelper/servicehelper.hxx>
47#include <comphelper/string.hxx>
48#include <cppuhelper/supportsservice.hxx>
49#include <com/sun/star/util/DateTime.hpp>
50#include <com/sun/star/util/Date.hpp>
51#include <com/sun/star/beans/PropertyAttribute.hpp>

53//undef to prevent error (from sfx2/docfile.cxx)
54#undef SEQUENCE
55#include <com/sun/star/text/SetVariableType.hpp>
56#include <com/sun/star/text/WrapTextMode.hpp>
57#include <com/sun/star/text/TextContentAnchorType.hpp>
58#include <authfld.hxx>
59#include <flddat.hxx>
60#include <dbfld.hxx>
61#include <usrfld.hxx>
62#include <docufld.hxx>
63#include <expfld.hxx>
64#include <chpfld.hxx>
65#include <flddropdown.hxx>
66#include <poolfmt.hxx>
67#include <strings.hrc>
68#include <pagedesc.hxx>
69#include <docary.hxx>
70#include <reffld.hxx>
71#include <ddefld.hxx>
72#include <SwStyleNameMapper.hxx>
73#include <swunohelper.hxx>
74#include <unofldmid.h>
75#include <scriptinfo.hxx>
76#include <tools/datetime.hxx>
77#include <tools/urlobj.hxx>
78#include <svl/itemprop.hxx>
79#include <svl/listener.hxx>
80#include <svx/dataaccessdescriptor.hxx>
81#include <o3tl/any.hxx>
82#include <o3tl/safeint.hxx>
83#include <osl/mutex.hxx>
84#include <vcl/svapp.hxx>
85#include <textapi.hxx>
86#include <fmtmeta.hxx>
87#include <vector>

89using namespace ::com::sun::star;
90using namespace nsSwDocInfoSubType;

92// case-corrected version of the first part for the service names (see #i67811)
93#define COM_TEXT_FLDMASTER_CC"com.sun.star.text.fieldmaster."   "com.sun.star.text.fieldmaster."

95// note: this thing is indexed as an array, so do not insert/remove entries!
96const sal_uInt16 aDocInfoSubTypeFromService[] =
97{
  DI_CHANGE | DI_SUB_AUTHOR,  //PROPERTY_MAP_FLDTYP_DOCINFO_CHANGE_AUTHOR
  DI_CHANGE | DI_SUB_DATE,    //PROPERTY_MAP_FLDTYP_DOCINFO_CHANGE_DATE_TIME
  DI_EDIT | DI_SUB_TIME,      //PROPERTY_MAP_FLDTYP_DOCINFO_EDIT_TIME
  DI_COMMENT,                 //PROPERTY_MAP_FLDTYP_DOCINFO_DESCRIPTION
  DI_CREATE | DI_SUB_AUTHOR,  //PROPERTY_MAP_FLDTYP_DOCINFO_CREATE_AUTHOR
  DI_CREATE | DI_SUB_DATE,    //PROPERTY_MAP_FLDTYP_DOCINFO_CREATE_DATE_TIME
  0,                          //DUMMY
  0,                          //DUMMY
  0,                          //DUMMY
  0,                          //DUMMY
  DI_CUSTOM,                  //PROPERTY_MAP_FLDTYP_DOCINFO_CUSTOM
  DI_PRINT | DI_SUB_AUTHOR,   //PROPERTY_MAP_FLDTYP_DOCINFO_PRINT_AUTHOR
  DI_PRINT | DI_SUB_DATE,     //PROPERTY_MAP_FLDTYP_DOCINFO_PRINT_DATE_TIME
  DI_KEYS,                    //PROPERTY_MAP_FLDTYP_DOCINFO_KEY_WORDS
  DI_SUBJECT,                 //PROPERTY_MAP_FLDTYP_DOCINFO_SUBJECT
  DI_TITLE,                   //PROPERTY_MAP_FLDTYP_DOCINFO_TITLE
  DI_DOCNO                    //PROPERTY_MAP_FLDTYP_DOCINFO_REVISION
115};

117namespace {

119struct ServiceIdResId
120{
  SwFieldIds    nResId;
  SwServiceType nServiceId;
123};

125}

127const ServiceIdResId aServiceToRes[] =
128{
  {SwFieldIds::DateTime,           SwServiceType::FieldTypeDateTime              },
  {SwFieldIds::User,               SwServiceType::FieldTypeUser                  },
  {SwFieldIds::SetExp,             SwServiceType::FieldTypeSetExp                },
  {SwFieldIds::GetExp,             SwServiceType::FieldTypeGetExp                },
  {SwFieldIds::Filename,           SwServiceType::FieldTypeFileName              },
  {SwFieldIds::PageNumber,         SwServiceType::FieldTypePageNum               },
  {SwFieldIds::Author,             SwServiceType::FieldTypeAuthor                },
  {SwFieldIds::Chapter,            SwServiceType::FieldTypeChapter               },
  {SwFieldIds::GetRef,             SwServiceType::FieldTypeGetReference          },
  {SwFieldIds::HiddenText,         SwServiceType::FieldTypeConditionedText       },
  {SwFieldIds::Postit,             SwServiceType::FieldTypeAnnotation            },
  {SwFieldIds::Input,              SwServiceType::FieldTypeInput                 },
  {SwFieldIds::Macro,              SwServiceType::FieldTypeMacro                 },
  {SwFieldIds::Dde,                SwServiceType::FieldTypeDDE                   },
  {SwFieldIds::HiddenPara,         SwServiceType::FieldTypeHiddenPara            },
  {SwFieldIds::DocInfo,            SwServiceType::FieldTypeDocInfo               },
  {SwFieldIds::TemplateName,       SwServiceType::FieldTypeTemplateName          },
  {SwFieldIds::ExtUser,            SwServiceType::FieldTypeUserExt               },
  {SwFieldIds::RefPageSet,         SwServiceType::FieldTypeRefPageSet            },
  {SwFieldIds::RefPageGet,         SwServiceType::FieldTypeRefPageGet            },
  {SwFieldIds::JumpEdit,           SwServiceType::FieldTypeJumpEdit              },
  {SwFieldIds::Script,             SwServiceType::FieldTypeScript                },
  {SwFieldIds::DbNextSet,          SwServiceType::FieldTypeDatabaseNextSet       },
  {SwFieldIds::DbNumSet,           SwServiceType::FieldTypeDatabaseNumSet        },
  {SwFieldIds::DbSetNumber,        SwServiceType::FieldTypeDatabaseSetNum        },
  {SwFieldIds::Database,           SwServiceType::FieldTypeDatabase              },
  {SwFieldIds::DatabaseName,       SwServiceType::FieldTypeDatabaseName          },
  {SwFieldIds::DocStat,            SwServiceType::FieldTypePageCount             },
  {SwFieldIds::DocStat,            SwServiceType::FieldTypeParagraphCount        },
  {SwFieldIds::DocStat,            SwServiceType::FieldTypeWordCount             },
  {SwFieldIds::DocStat,            SwServiceType::FieldTypeCharacterCount        },
  {SwFieldIds::DocStat,            SwServiceType::FieldTypeTableCount            },
  {SwFieldIds::DocStat,            SwServiceType::FieldTypeGraphicObjectCount    },
  {SwFieldIds::DocStat,            SwServiceType::FieldTypeEmbeddedObjectCount   },
  {SwFieldIds::DocInfo,            SwServiceType::FieldTypeDocInfoChangeAuthor   },
  {SwFieldIds::DocInfo,            SwServiceType::FieldTypeDocInfoChangeDateTime },
  {SwFieldIds::DocInfo,            SwServiceType::FieldTypeDocInfoEditTime       },
  {SwFieldIds::DocInfo,            SwServiceType::FieldTypeDocInfoDescription    },
  {SwFieldIds::DocInfo,            SwServiceType::FieldTypeDocInfoCreateAuthor   },
  {SwFieldIds::DocInfo,            SwServiceType::FieldTypeDocInfoCreateDateTime },
  {SwFieldIds::DocInfo,            SwServiceType::FieldTypeDocInfoCustom         },
  {SwFieldIds::DocInfo,            SwServiceType::FieldTypeDocInfoPrintAuthor    },
  {SwFieldIds::DocInfo,            SwServiceType::FieldTypeDocInfoPrintDateTime  },
  {SwFieldIds::DocInfo,            SwServiceType::FieldTypeDocInfoKeywords       },
  {SwFieldIds::DocInfo,            SwServiceType::FieldTypeDocInfoSubject        },
  {SwFieldIds::DocInfo,            SwServiceType::FieldTypeDocInfoTitle          },
  {SwFieldIds::Input,              SwServiceType::FieldTypeInputUser             },
  {SwFieldIds::HiddenText,         SwServiceType::FieldTypeHiddenText            },
  {SwFieldIds::TableOfAuthorities, SwServiceType::FieldTypeBibliography          },
  {SwFieldIds::CombinedChars,      SwServiceType::FieldTypeCombinedCharacters    },
  {SwFieldIds::Dropdown,           SwServiceType::FieldTypeDropdown              },
  {SwFieldIds::Table,              SwServiceType::FieldTypeTableFormula          }
181};

183static SwFieldIds lcl_ServiceIdToResId(SwServiceType nServiceId)
184{
  for (size_t i=0; i<SAL_N_ELEMENTS(aServiceToRes)(sizeof(sal_n_array_size(aServiceToRes))); ++i)
      if (aServiceToRes[i].nServiceId == nServiceId)
          return aServiceToRes[i].nResId;
188#if OSL_DEBUG_LEVEL1 > 0
  OSL_FAIL("service id not found")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unofield.cxx"
 ":" "189" ": "), "%s", "service id not found"); } } while (false
);
190#endif
  return SwFieldIds::Unknown;
192}

194static SwServiceType lcl_GetServiceForField( const SwField& rField )
195{
  const SwFieldIds nWhich = rField.Which();
  SwServiceType nSrvId = SwServiceType::Invalid;
  //special handling for some fields
  switch( nWhich )
  {
  case SwFieldIds::Input:
      if( INP_USR == (rField.GetSubType() & 0x00ff) )
          nSrvId = SwServiceType::FieldTypeInputUser;
      break;

  case SwFieldIds::DocInfo:
      {
          const sal_uInt16 nSubType = rField.GetSubType();
          switch( nSubType & 0xff )
          {
          case DI_CHANGE:
              nSrvId = ((nSubType&0x300) == DI_SUB_AUTHOR)
                      ? SwServiceType::FieldTypeDocInfoChangeAuthor
                      : SwServiceType::FieldTypeDocInfoChangeDateTime;
              break;
          case DI_CREATE:
              nSrvId = ((nSubType&0x300) == DI_SUB_AUTHOR)
                      ? SwServiceType::FieldTypeDocInfoCreateAuthor
                      : SwServiceType::FieldTypeDocInfoCreateDateTime;
              break;
          case DI_PRINT:
              nSrvId = ((nSubType&0x300) == DI_SUB_AUTHOR)
                      ? SwServiceType::FieldTypeDocInfoPrintAuthor
                      : SwServiceType::FieldTypeDocInfoPrintDateTime;
              break;
          case DI_EDIT:   nSrvId = SwServiceType::FieldTypeDocInfoEditTime;break;
          case DI_COMMENT:nSrvId = SwServiceType::FieldTypeDocInfoDescription;break;
          case DI_KEYS:   nSrvId = SwServiceType::FieldTypeDocInfoKeywords;break;
          case DI_SUBJECT:nSrvId = SwServiceType::FieldTypeDocInfoSubject;  break;
          case DI_TITLE:  nSrvId = SwServiceType::FieldTypeDocInfoTitle;    break;
          case DI_DOCNO:  nSrvId = SwServiceType::FieldTypeDocInfoRevision; break;
          case DI_CUSTOM: nSrvId = SwServiceType::FieldTypeDocInfoCustom;   break;
          }
      }
      break;

  case SwFieldIds::HiddenText:
      nSrvId = SwFieldTypesEnum::ConditionalText == static_cast<SwFieldTypesEnum>(rField.GetSubType())
                      ? SwServiceType::FieldTypeConditionedText
                      : SwServiceType::FieldTypeHiddenText;
      break;

  case SwFieldIds::DocStat:
      {
          switch( rField.GetSubType() )
          {
          case DS_PAGE: nSrvId = SwServiceType::FieldTypePageCount; break;
          case DS_PARA: nSrvId = SwServiceType::FieldTypeParagraphCount; break;
          case DS_WORD: nSrvId = SwServiceType::FieldTypeWordCount     ; break;
          case DS_CHAR: nSrvId = SwServiceType::FieldTypeCharacterCount; break;
          case DS_TBL:  nSrvId = SwServiceType::FieldTypeTableCount    ; break;
          case DS_GRF:  nSrvId = SwServiceType::FieldTypeGraphicObjectCount; break;
          case DS_OLE:  nSrvId = SwServiceType::FieldTypeEmbeddedObjectCount; break;
          }
      }
      break;
  default: break;
  }
  if( SwServiceType::Invalid == nSrvId )
  {
      for( const ServiceIdResId* pMap = aServiceToRes;
              SwFieldIds::Unknown != pMap->nResId; ++pMap )
          if( nWhich == pMap->nResId )
          {
              nSrvId = pMap->nServiceId;
              break;
          }
  }
269#if OSL_DEBUG_LEVEL1 > 0
  if( SwServiceType::Invalid == nSrvId )
      OSL_FAIL("resid not found")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unofield.cxx"
 ":" "271" ": "), "%s", "resid not found"); } } while (false);
272#endif
  return nSrvId;
274}

276static sal_uInt16 lcl_GetPropMapIdForFieldType( SwFieldIds nWhich )
277{
  sal_uInt16 nId;
  switch( nWhich )
  {
  case SwFieldIds::User:     nId = PROPERTY_MAP_FLDMSTR_USER80;            break;
  case SwFieldIds::Database: nId = PROPERTY_MAP_FLDMSTR_DATABASE83;        break;
  case SwFieldIds::SetExp:   nId = PROPERTY_MAP_FLDMSTR_SET_EXP82;         break;
  case SwFieldIds::Dde:      nId = PROPERTY_MAP_FLDMSTR_DDE81;             break;
  case SwFieldIds::TableOfAuthorities:
                             nId = PROPERTY_MAP_FLDMSTR_BIBLIOGRAPHY86;    break;
  default:                   nId = PROPERTY_MAP_FLDMSTR_DUMMY084;
  }
  return nId;
290}

292static sal_Int32 lcl_PropName2TokenPos(const OUString& rPropertyName)
293{
  if (rPropertyName == UNO_NAME_DDE_COMMAND_TYPE"DDECommandType")
      return 0;

  if (rPropertyName == UNO_NAME_DDE_COMMAND_FILE"DDECommandFile")
      return 1;

  if (rPropertyName == UNO_NAME_DDE_COMMAND_ELEMENT"DDECommandElement")
      return 2;

  if (rPropertyName == UNO_NAME_IS_AUTOMATIC_UPDATE"IsAutomaticUpdate")
      return 3;

  return SAL_MAX_INT32((sal_Int32) 0x7FFFFFFF);
307}

309static sal_uInt16 GetFieldTypeMId( const OUString& rProperty, const SwFieldType& rTyp )
310{
  sal_uInt16 nId = lcl_GetPropMapIdForFieldType( rTyp.Which() );
  const SfxItemPropertySet* pSet = aSwMapProvider.GetPropertySet( nId );
  if( !pSet )
      nId = USHRT_MAX(32767 *2 +1);
  else
  {
      const SfxItemPropertySimpleEntry* pEntry = pSet->getPropertyMap().getByName(rProperty);
      nId = pEntry ? pEntry->nWID : USHRT_MAX(32767 *2 +1);
  }
  return nId;
321}

323static sal_uInt16 lcl_GetPropertyMapOfService( SwServiceType nServiceId )
324{
  sal_uInt16 nRet;
  switch ( nServiceId)
  {
  case SwServiceType::FieldTypeDateTime: nRet = PROPERTY_MAP_FLDTYP_DATETIME41; break;
  case SwServiceType::FieldTypeUser: nRet = PROPERTY_MAP_FLDTYP_USER42; break;
  case SwServiceType::FieldTypeSetExp: nRet = PROPERTY_MAP_FLDTYP_SET_EXP43; break;
  case SwServiceType::FieldTypeGetExp: nRet = PROPERTY_MAP_FLDTYP_GET_EXP44; break;
  case SwServiceType::FieldTypeFileName: nRet = PROPERTY_MAP_FLDTYP_FILE_NAME45; break;
  case SwServiceType::FieldTypePageNum: nRet = PROPERTY_MAP_FLDTYP_PAGE_NUM46; break;
  case SwServiceType::FieldTypeAuthor: nRet = PROPERTY_MAP_FLDTYP_AUTHOR47; break;
  case SwServiceType::FieldTypeChapter: nRet = PROPERTY_MAP_FLDTYP_CHAPTER48; break;
  case SwServiceType::FieldTypeGetReference: nRet = PROPERTY_MAP_FLDTYP_GET_REFERENCE49; break;
  case SwServiceType::FieldTypeConditionedText: nRet = PROPERTY_MAP_FLDTYP_CONDITIONED_TEXT50; break;
  case SwServiceType::FieldTypeAnnotation: nRet = PROPERTY_MAP_FLDTYP_ANNOTATION52; break;
  case SwServiceType::FieldTypeInputUser:
  case SwServiceType::FieldTypeInput: nRet = PROPERTY_MAP_FLDTYP_INPUT53; break;
  case SwServiceType::FieldTypeMacro: nRet = PROPERTY_MAP_FLDTYP_MACRO54; break;
  case SwServiceType::FieldTypeDDE: nRet = PROPERTY_MAP_FLDTYP_DDE55; break;
  case SwServiceType::FieldTypeHiddenPara: nRet = PROPERTY_MAP_FLDTYP_HIDDEN_PARA56; break;
  case SwServiceType::FieldTypeDocInfo: nRet = PROPERTY_MAP_FLDTYP_DOC_INFO57; break;
  case SwServiceType::FieldTypeTemplateName: nRet = PROPERTY_MAP_FLDTYP_TEMPLATE_NAME58; break;
  case SwServiceType::FieldTypeUserExt: nRet = PROPERTY_MAP_FLDTYP_USER_EXT59; break;
  case SwServiceType::FieldTypeRefPageSet: nRet = PROPERTY_MAP_FLDTYP_REF_PAGE_SET60; break;
  case SwServiceType::FieldTypeRefPageGet: nRet = PROPERTY_MAP_FLDTYP_REF_PAGE_GET61; break;
  case SwServiceType::FieldTypeJumpEdit: nRet = PROPERTY_MAP_FLDTYP_JUMP_EDIT62; break;
  case SwServiceType::FieldTypeScript: nRet = PROPERTY_MAP_FLDTYP_SCRIPT63; break;
  case SwServiceType::FieldTypeDatabaseNextSet: nRet = PROPERTY_MAP_FLDTYP_DATABASE_NEXT_SET64; break;
  case SwServiceType::FieldTypeDatabaseNumSet: nRet = PROPERTY_MAP_FLDTYP_DATABASE_NUM_SET65; break;
  case SwServiceType::FieldTypeDatabaseSetNum: nRet = PROPERTY_MAP_FLDTYP_DATABASE_SET_NUM66; break;
  case SwServiceType::FieldTypeDatabase: nRet = PROPERTY_MAP_FLDTYP_DATABASE67; break;
  case SwServiceType::FieldTypeDatabaseName: nRet = PROPERTY_MAP_FLDTYP_DATABASE_NAME68; break;
  case SwServiceType::FieldTypeTableFormula: nRet = PROPERTY_MAP_FLDTYP_TABLE_FORMULA79; break;
  case SwServiceType::FieldTypePageCount:
  case SwServiceType::FieldTypeParagraphCount:
  case SwServiceType::FieldTypeWordCount:
  case SwServiceType::FieldTypeCharacterCount:
  case SwServiceType::FieldTypeTableCount:
  case SwServiceType::FieldTypeGraphicObjectCount:
  case SwServiceType::FieldTypeEmbeddedObjectCount: nRet = PROPERTY_MAP_FLDTYP_DOCSTAT69; break;
  case SwServiceType::FieldTypeDocInfoChangeAuthor:
  case SwServiceType::FieldTypeDocInfoCreateAuthor:
  case SwServiceType::FieldTypeDocInfoPrintAuthor: nRet = PROPERTY_MAP_FLDTYP_DOCINFO_AUTHOR70; break;
  case SwServiceType::FieldTypeDocInfoChangeDateTime:
  case SwServiceType::FieldTypeDocInfoCreateDateTime:
  case SwServiceType::FieldTypeDocInfoPrintDateTime: nRet = PROPERTY_MAP_FLDTYP_DOCINFO_DATE_TIME71; break;
  case SwServiceType::FieldTypeDocInfoEditTime: nRet = PROPERTY_MAP_FLDTYP_DOCINFO_EDIT_TIME74; break;
  case SwServiceType::FieldTypeDocInfoCustom: nRet = PROPERTY_MAP_FLDTYP_DOCINFO_CUSTOM97; break;
  case SwServiceType::FieldTypeDocInfoDescription:
  case SwServiceType::FieldTypeDocInfoKeywords:
  case SwServiceType::FieldTypeDocInfoSubject:
  case SwServiceType::FieldTypeDocInfoTitle: nRet = PROPERTY_MAP_FLDTYP_DOCINFO_MISC75; break;
  case SwServiceType::FieldTypeDocInfoRevision: nRet = PROPERTY_MAP_FLDTYP_DOCINFO_REVISION76; break;
  case SwServiceType::FieldTypeBibliography: nRet = PROPERTY_MAP_FLDTYP_BIBLIOGRAPHY85; break;
  case SwServiceType::FieldTypeDummy0:
  case SwServiceType::FieldTypeCombinedCharacters: nRet = PROPERTY_MAP_FLDTYP_COMBINED_CHARACTERS77; break;
  case SwServiceType::FieldTypeDropdown: nRet = PROPERTY_MAP_FLDTYP_DROPDOWN90; break;
  case SwServiceType::FieldTypeDummy4:
  case SwServiceType::FieldTypeDummy5:
  case SwServiceType::FieldTypeDummy6:
  case SwServiceType::FieldTypeDummy7:
              nRet = PROPERTY_MAP_FLDTYP_DUMMY_078; break;
  case SwServiceType::FieldMasterUser: nRet = PROPERTY_MAP_FLDMSTR_USER80; break;
  case SwServiceType::FieldMasterDDE: nRet = PROPERTY_MAP_FLDMSTR_DDE81; break;
  case SwServiceType::FieldMasterSetExp: nRet = PROPERTY_MAP_FLDMSTR_SET_EXP82; break;
  case SwServiceType::FieldMasterDatabase: nRet = PROPERTY_MAP_FLDMSTR_DATABASE83; break;
  case SwServiceType::FieldMasterBibliography: nRet = PROPERTY_MAP_FLDMSTR_BIBLIOGRAPHY86; break;
  case SwServiceType::FieldMasterDummy2:
  case SwServiceType::FieldMasterDummy3:
  case SwServiceType::FieldMasterDummy4:
  case SwServiceType::FieldMasterDummy5: nRet = PROPERTY_MAP_FLDMSTR_DUMMY084; break;
  case SwServiceType::FieldTypeHiddenText: nRet = PROPERTY_MAP_FLDTYP_HIDDEN_TEXT51; break;
  default:
      nRet = USHRT_MAX(32767 *2 +1);
  }
  assert(nRet != USHRT_MAX && "wrong service id")(static_cast <bool> (nRet != (32767 *2 +1) && "wrong service id"
) ? void (0) : __assert_fail ("nRet != USHRT_MAX && \"wrong service id\""
, "/home/maarten/src/libreoffice/core/sw/source/core/unocore/unofield.cxx"
, 399, __extension__ __PRETTY_FUNCTION__));
  return nRet;
401}

403class SwXFieldMaster::Impl
  : public SvtListener
405{
406private:
  ::osl::Mutex m_Mutex; // just for OInterfaceContainerHelper2

409public:
  uno::WeakReference<uno::XInterface> m_wThis;
  ::comphelper::OInterfaceContainerHelper2 m_EventListeners;

  SwDoc*          m_pDoc;
  SwFieldType* m_pType;

  SwFieldIds      m_nResTypeId;

  OUString        m_sParam1;  // Content / Database / NumberingSeparator
  OUString        m_sParam2;  // -    /DataTablename
  OUString        m_sParam3;  // -    /DataFieldName
  OUString        m_sParam5;  // -    /DataBaseURL
  double          m_fParam1;  // Value / -
  sal_Int8        m_nParam1;  // ChapterNumberingLevel
  bool            m_bParam1;  // IsExpression
  sal_Int32       m_nParam2;

  Impl(SwPageDesc* const pPageDesc, SwDoc* pDoc, SwFieldIds nResId)
      : m_EventListeners(m_Mutex)
      , m_pDoc(pDoc)
      , m_pType(nullptr)
      , m_nResTypeId(nResId)
      , m_fParam1(0.0)
      , m_nParam1(-1)
      , m_bParam1(false)
      , m_nParam2(0)
  {
      StartListening(pPageDesc->GetNotifier());
  }

  Impl(SwFieldType* const pType, SwDoc* pDoc, SwFieldIds nResId)
      : m_EventListeners(m_Mutex)
      , m_pDoc(pDoc)
      , m_pType(pType)
      , m_nResTypeId(nResId)
      , m_fParam1(0.0)
      , m_nParam1(-1)
      , m_bParam1(false)
      , m_nParam2(0)
  {
      StartListening(m_pType->GetNotifier());
  }
  void SetFieldType(SwFieldType* pType)
  {
      EndListeningAll();
      m_pType = pType;
      StartListening(m_pType->GetNotifier());
  }
458protected:
  virtual void Notify(const SfxHint& rHint) override;
460};

462namespace
463{
  class theSwXFieldMasterUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theSwXFieldMasterUnoTunnelId > {};
465}

467const uno::Sequence< sal_Int8 > & SwXFieldMaster::getUnoTunnelId()
468{
  return theSwXFieldMasterUnoTunnelId::get().getSeq();
470}

472sal_Int64 SAL_CALL
473SwXFieldMaster::getSomething(const uno::Sequence< sal_Int8 >& rId)
474{
  return ::sw::UnoTunnelImpl<SwXFieldMaster>(rId, this);
476}

478OUString SAL_CALL
479SwXFieldMaster::getImplementationName()
480{
  return "SwXFieldMaster";
482}

484namespace
485{

487OUString getServiceName(const SwFieldIds aId)
488{
  const char* pEntry;
  switch (aId)
  {
      case SwFieldIds::User:
          pEntry = "User";
          break;
      case SwFieldIds::Database:
          pEntry = "Database";
          break;
      case SwFieldIds::SetExp:
          pEntry = "SetExpression";
          break;
      case SwFieldIds::Dde:
          pEntry = "DDE";
          break;
      case SwFieldIds::TableOfAuthorities:
          pEntry = "Bibliography";
          break;
      default:
          return OUString();
  }

  return "com.sun.star.text.fieldmaster." + OUString::createFromAscii(pEntry);
512}

514}

516sal_Bool SAL_CALL SwXFieldMaster::supportsService(const OUString& rServiceName)
517{
  return cppu::supportsService(this, rServiceName);
519}

521uno::Sequence< OUString > SAL_CALL
522SwXFieldMaster::getSupportedServiceNames()
523{
  return { "com.sun.star.text.TextFieldMaster", getServiceName(m_pImpl->m_nResTypeId) };
525}

527SwXFieldMaster::SwXFieldMaster(SwDoc *const pDoc, SwFieldIds const nResId)
  : m_pImpl(new Impl(pDoc->getIDocumentStylePoolAccess().GetPageDescFromPool(RES_POOLPAGE_STANDARD), pDoc, nResId))
529{
530}

532SwXFieldMaster::SwXFieldMaster(SwFieldType& rType, SwDoc * pDoc)
  : m_pImpl(new Impl(&rType, pDoc, rType.Which()))
534{
535}

537SwXFieldMaster::~SwXFieldMaster()
538{
539}

541uno::Reference<beans::XPropertySet>
542SwXFieldMaster::CreateXFieldMaster(SwDoc * pDoc, SwFieldType *const pType,
      SwFieldIds nResId)
544{
  // re-use existing SwXFieldMaster
  uno::Reference<beans::XPropertySet> xFM;
  if (pType)
  {
      xFM = pType->GetXObject();
  }
  if (!xFM.is())
  {
      SwXFieldMaster *const pFM( pType
              ? new SwXFieldMaster(*pType, pDoc)
              : new SwXFieldMaster(pDoc, nResId));
      xFM.set(pFM);
      if (pType)
      {
          pType->SetXObject(xFM);
      }
      // need a permanent Reference to initialize m_wThis
      pFM->m_pImpl->m_wThis = xFM;
  }
  return xFM;
565}

567uno::Reference<beans::XPropertySetInfo> SAL_CALL
568SwXFieldMaster::getPropertySetInfo()
569{
  SolarMutexGuard aGuard;
  uno::Reference< beans::XPropertySetInfo >  aRef =
                      aSwMapProvider.GetPropertySet(
          lcl_GetPropMapIdForFieldType(m_pImpl->m_nResTypeId))->getPropertySetInfo();
  return aRef;
575}

577void SAL_CALL SwXFieldMaster::setPropertyValue(
      const OUString& rPropertyName, const uno::Any& rValue)
579{
  SolarMutexGuard aGuard;
  SwFieldType* pType = GetFieldType(true);
  if(pType)
  {
      bool bSetValue = true;
      if( rPropertyName == UNO_NAME_SUB_TYPE"SubType" )
      {
          const std::vector<OUString>& rExtraArr(
                  SwStyleNameMapper::GetExtraUINameArray());
          const OUString sTypeName = pType->GetName();
          static sal_uInt16 nIds[] =
          {
              RES_POOLCOLL_LABEL_DRAWING - RES_POOLCOLL_EXTRA_BEGIN,
              RES_POOLCOLL_LABEL_ABB - RES_POOLCOLL_EXTRA_BEGIN,
              RES_POOLCOLL_LABEL_TABLE - RES_POOLCOLL_EXTRA_BEGIN,
              RES_POOLCOLL_LABEL_FRAME- RES_POOLCOLL_EXTRA_BEGIN,
              RES_POOLCOLL_LABEL_FIGURE - RES_POOLCOLL_EXTRA_BEGIN,
              0
          };
          for(const sal_uInt16 * pIds = nIds; *pIds; ++pIds)
          {
              if(sTypeName == rExtraArr[ *pIds ] )
              {
                  bSetValue = false;
                  break;
              }
          }
      }
      if ( bSetValue )
      {
          // nothing special to be done here for the properties
          // UNO_NAME_DATA_BASE_NAME and UNO_NAME_DATA_BASE_URL.
          // We just call PutValue (empty string is allowed).
          // Thus the last property set will be used as Data Source.

          const sal_uInt16 nMemberValueId = GetFieldTypeMId( rPropertyName, *pType );
          if ( USHRT_MAX(32767 *2 +1) == nMemberValueId )
          {
              throw beans::UnknownPropertyException(
                  "Unknown property: " + rPropertyName,
                  static_cast< cppu::OWeakObject * >( this ) );
          }

          pType->PutValue( rValue, nMemberValueId );
          if ( pType->Which() == SwFieldIds::User )
          {
              // trigger update of User field in order to get depending Input Fields updated.
              pType->UpdateFields();
          }

      }
  }
  else if (m_pImpl->m_pDoc && rPropertyName == UNO_NAME_NAME"Name")
  {
      OUString sTypeName;
      rValue >>= sTypeName;
      SwFieldType * pType2 = m_pImpl->m_pDoc->getIDocumentFieldsAccess().GetFieldType(
              m_pImpl->m_nResTypeId, sTypeName, false);

      if(pType2 ||
          (SwFieldIds::SetExp == m_pImpl->m_nResTypeId &&
          ( sTypeName == SwResId(STR_POOLCOLL_LABEL_TABLEreinterpret_cast<char const *>("STR_POOLCOLL_LABEL_TABLE"
 "\004" u8"Table")) ||
            sTypeName == SwResId(STR_POOLCOLL_LABEL_DRAWINGreinterpret_cast<char const *>("STR_POOLCOLL_LABEL_DRAWING"
 "\004" u8"Drawing")) ||
            sTypeName == SwResId(STR_POOLCOLL_LABEL_FRAMEreinterpret_cast<char const *>("STR_POOLCOLL_LABEL_FRAME"
 "\004" u8"Text")) ||
            sTypeName == SwResId(STR_POOLCOLL_LABEL_ABBreinterpret_cast<char const *>("STR_POOLCOLL_LABEL_ABB"
 "\004" u8"Illustration")) ||
            sTypeName == SwResId(STR_POOLCOLL_LABEL_FIGUREreinterpret_cast<char const *>("STR_POOLCOLL_LABEL_FIGURE"
 "\004" u8"Figure")) )))
      {
          throw lang::IllegalArgumentException();
      }

      switch (m_pImpl->m_nResTypeId)
      {
          case SwFieldIds::User :
          {
              SwUserFieldType aType(m_pImpl->m_pDoc, sTypeName);
              pType2 = m_pImpl->m_pDoc->getIDocumentFieldsAccess().InsertFieldType(aType);
              static_cast<SwUserFieldType*>(pType2)->SetContent(m_pImpl->m_sParam1);
              static_cast<SwUserFieldType*>(pType2)->SetValue(m_pImpl->m_fParam1);
              static_cast<SwUserFieldType*>(pType2)->SetType(m_pImpl->m_bParam1
                  ? nsSwGetSetExpType::GSE_EXPR : nsSwGetSetExpType::GSE_STRING);
          }
          break;
          case SwFieldIds::Dde :
          {
              SwDDEFieldType aType(sTypeName, m_pImpl->m_sParam1,
                  m_pImpl->m_bParam1 ? SfxLinkUpdateMode::ALWAYS : SfxLinkUpdateMode::ONCALL);
              pType2 = m_pImpl->m_pDoc->getIDocumentFieldsAccess().InsertFieldType(aType);
          }
          break;
          case SwFieldIds::SetExp :
          {
              SwSetExpFieldType aType(m_pImpl->m_pDoc, sTypeName);
              if (!m_pImpl->m_sParam1.isEmpty())
                  aType.SetDelimiter(OUString(m_pImpl->m_sParam1[0]));
              if (m_pImpl->m_nParam1 > -1 && m_pImpl->m_nParam1 < MAXLEVEL)
                  aType.SetOutlineLvl(m_pImpl->m_nParam1);
              pType2 = m_pImpl->m_pDoc->getIDocumentFieldsAccess().InsertFieldType(aType);
          }
          break;
          case SwFieldIds::Database :
          {
              rValue >>= m_pImpl->m_sParam3;
              pType2 = GetFieldType();
          }
          break;
          default: break;
      }
      if (!pType2)
      {
          throw uno::RuntimeException("no field type found!", *this);
      }
      m_pImpl->SetFieldType(pType2);
  }
  else
  {
      switch (m_pImpl->m_nResTypeId)
      {
      case SwFieldIds::User:
          if(rPropertyName == UNO_NAME_CONTENT"Content")
              rValue >>= m_pImpl->m_sParam1;
          else if(rPropertyName == UNO_NAME_VALUE"Value")
          {
              if(rValue.getValueType() != ::cppu::UnoType<double>::get())
                  throw lang::IllegalArgumentException();
              rValue >>= m_pImpl->m_fParam1;
          }
          else if(rPropertyName == UNO_NAME_IS_EXPRESSION"IsExpression")
          {
              if(rValue.getValueType() != cppu::UnoType<bool>::get())
                  throw lang::IllegalArgumentException();
              rValue >>= m_pImpl->m_bParam1;
          }

          break;
      case SwFieldIds::Database:
          if(rPropertyName == UNO_NAME_DATA_BASE_NAME"DataBaseName")
              rValue >>= m_pImpl->m_sParam1;
          else if(rPropertyName == UNO_NAME_DATA_TABLE_NAME"DataTableName")
              rValue >>= m_pImpl->m_sParam2;
          else if(rPropertyName == UNO_NAME_DATA_COLUMN_NAME"DataColumnName")
              rValue >>= m_pImpl->m_sParam3;
          else if(rPropertyName == UNO_NAME_DATA_COMMAND_TYPE"DataCommandType")
              rValue >>= m_pImpl->m_nParam2;
          if(rPropertyName == UNO_NAME_DATA_BASE_URL"DataBaseURL")
              rValue >>= m_pImpl->m_sParam5;

          if (  (   !m_pImpl->m_sParam1.isEmpty()
                 || !m_pImpl->m_sParam5.isEmpty())
              && !m_pImpl->m_sParam2.isEmpty()
              && !m_pImpl->m_sParam3.isEmpty())
          {
              GetFieldType();
          }
          break;
      case  SwFieldIds::SetExp:
          if(rPropertyName == UNO_NAME_NUMBERING_SEPARATOR"NumberingSeparator")
              rValue >>= m_pImpl->m_sParam1;
          else if(rPropertyName == UNO_NAME_CHAPTER_NUMBERING_LEVEL"ChapterNumberingLevel")
              rValue >>= m_pImpl->m_nParam1;
          break;
      case SwFieldIds::Dde:
          {
              sal_Int32 nPart = lcl_PropName2TokenPos(rPropertyName);
              if(nPart  < 3 )
              {
                  if (m_pImpl->m_sParam1.isEmpty())
                  {
                      m_pImpl->m_sParam1
                          = OUStringChar(sfx2::cTokenSeparator)
                          + OUStringChar(sfx2::cTokenSeparator);
                  }
                  OUString sTmp;
                  rValue >>= sTmp;
                  sal_Int32 nIndex(0);
                  sal_Int32 nStart(0);
                  while (nIndex < m_pImpl->m_sParam1.getLength())
                  {
                      if (m_pImpl->m_sParam1[nIndex] == sfx2::cTokenSeparator)
                      {
                          if (0 == nPart)
                              break;
                          nStart = nIndex + 1;
                          --nPart;
                      }
                      ++nIndex;
                  }
                  assert(0 == nPart)(static_cast <bool> (0 == nPart) ? void (0) : __assert_fail
 ("0 == nPart", "/home/maarten/src/libreoffice/core/sw/source/core/unocore/unofield.cxx"
, 766, __extension__ __PRETTY_FUNCTION__));
                  m_pImpl->m_sParam1 = m_pImpl->m_sParam1.replaceAt(
                          nStart, nIndex - nStart, sTmp);
              }
              else if(3 == nPart)
              {
                  rValue >>= m_pImpl->m_bParam1;
              }
          }
          break;
      default:
          throw beans::UnknownPropertyException( "Unknown property: " + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) );
      }
  }
780}

782SwFieldType* SwXFieldMaster::GetFieldType(bool const bDontCreate) const
783{
  if (!bDontCreate && SwFieldIds::Database == m_pImpl->m_nResTypeId
      && !m_pImpl->m_pType && m_pImpl->m_pDoc)
  {
      SwDBData aData;

      // set DataSource
      svx::ODataAccessDescriptor aAcc;
      if (!m_pImpl->m_sParam1.isEmpty())
          aAcc[svx::DataAccessDescriptorProperty::DataSource]        <<= m_pImpl->m_sParam1; // DataBaseName
      else if (!m_pImpl->m_sParam5.isEmpty())
          aAcc[svx::DataAccessDescriptorProperty::DatabaseLocation]  <<= m_pImpl->m_sParam5; // DataBaseURL
      aData.sDataSource = aAcc.getDataSource();

      aData.sCommand = m_pImpl->m_sParam2;
      aData.nCommandType = m_pImpl->m_nParam2;

      SwDBFieldType aType(m_pImpl->m_pDoc, m_pImpl->m_sParam3, aData);
      SwFieldType *const pType = m_pImpl->m_pDoc->getIDocumentFieldsAccess().InsertFieldType(aType);
      m_pImpl->SetFieldType(pType);
  }
  return m_pImpl->m_pType;
805}

807uno::Any SAL_CALL
808SwXFieldMaster::getPropertyValue(const OUString& rPropertyName)
809{
  SolarMutexGuard aGuard;
  uno::Any aRet;
  SwFieldType* pType = GetFieldType(true);
  if( rPropertyName == UNO_NAME_INSTANCE_NAME"InstanceName" )
  {
      OUString sName;
      if(pType)
          SwXTextFieldMasters::getInstanceName(*pType, sName);
      aRet <<= sName;
  }
  else if(pType)
  {
      if(rPropertyName == UNO_NAME_NAME"Name")
      {
          aRet <<= SwXFieldMaster::GetProgrammaticName(*pType, *m_pImpl->m_pDoc);
      }
      else if(rPropertyName == UNO_NAME_DEPENDENT_TEXT_FIELDS"DependentTextFields")
      {
          //fill all text fields into a sequence
          std::vector<SwFormatField*> vpFields;
          pType->GatherFields(vpFields);
          uno::Sequence<uno::Reference <text::XDependentTextField> > aSeq(vpFields.size());
          std::transform(vpFields.begin(), vpFields.end(), aSeq.begin(),
                  [this](SwFormatField* pF) { return uno::Reference<text::XDependentTextField>(SwXTextField::CreateXTextField(m_pImpl->m_pDoc, pF), uno::UNO_QUERY); });
          aRet <<= aSeq;
      }
      else
      {
          //TODO: add properties for the other field types
          const sal_uInt16 nMId = GetFieldTypeMId( rPropertyName, *pType );
          if (USHRT_MAX(32767 *2 +1) == nMId)
          {
              throw beans::UnknownPropertyException(
                      "Unknown property: " + rPropertyName,
                      static_cast<cppu::OWeakObject *>(this));
          }
          pType->QueryValue( aRet, nMId );

          if (rPropertyName == UNO_NAME_DATA_BASE_NAME"DataBaseName" ||
              rPropertyName == UNO_NAME_DATA_BASE_URL"DataBaseURL")
          {
              OUString aDataSource;
              aRet >>= aDataSource;
              aRet <<= OUString();

              OUString *pStr = nullptr;     // only one of this properties will return
                                      // a non-empty string.
              INetURLObject aObj;
              aObj.SetURL( aDataSource );
              bool bIsURL = aObj.GetProtocol() != INetProtocol::NotValid;
              if (bIsURL && rPropertyName == UNO_NAME_DATA_BASE_URL"DataBaseURL")
                  pStr = &aDataSource;        // DataBaseURL
              else if (!bIsURL && rPropertyName == UNO_NAME_DATA_BASE_NAME"DataBaseName")
                  pStr = &aDataSource;        // DataBaseName

              if (pStr)
                  aRet <<= *pStr;
          }
      }
  }
  else
  {
      if(rPropertyName == UNO_NAME_DATA_COMMAND_TYPE"DataCommandType")
          aRet <<= m_pImpl->m_nParam2;
      else if(rPropertyName == UNO_NAME_DEPENDENT_TEXT_FIELDS"DependentTextFields" )
      {
          uno::Sequence<uno::Reference <text::XDependentTextField> > aRetSeq(0);
          aRet <<= aRetSeq;
      }
      else
      {
          switch (m_pImpl->m_nResTypeId)
          {
          case SwFieldIds::User:
              if( rPropertyName == UNO_NAME_CONTENT"Content" )
                  aRet <<= m_pImpl->m_sParam1;
              else if(rPropertyName == UNO_NAME_VALUE"Value")
                  aRet <<= m_pImpl->m_fParam1;
              else if(rPropertyName == UNO_NAME_IS_EXPRESSION"IsExpression")
                  aRet <<= m_pImpl->m_bParam1;
              break;
          case SwFieldIds::Database:
              if(rPropertyName == UNO_NAME_DATA_BASE_NAME"DataBaseName" ||
                 rPropertyName == UNO_NAME_DATA_BASE_URL"DataBaseURL")
              {
                   // only one of these properties returns a non-empty string.
                  INetURLObject aObj;
                  aObj.SetURL(m_pImpl->m_sParam5); // SetSmartURL
                  bool bIsURL = aObj.GetProtocol() != INetProtocol::NotValid;
                  if (bIsURL && rPropertyName == UNO_NAME_DATA_BASE_URL"DataBaseURL")
                      aRet <<= m_pImpl->m_sParam5; // DataBaseURL
                  else if ( rPropertyName == UNO_NAME_DATA_BASE_NAME"DataBaseName")
                      aRet <<= m_pImpl->m_sParam1; // DataBaseName
              }
              else if(rPropertyName == UNO_NAME_DATA_TABLE_NAME"DataTableName")
                  aRet <<= m_pImpl->m_sParam2;
              else if(rPropertyName == UNO_NAME_DATA_COLUMN_NAME"DataColumnName")
                  aRet <<= m_pImpl->m_sParam3;
              break;
          case SwFieldIds::SetExp:
              if(rPropertyName == UNO_NAME_NUMBERING_SEPARATOR"NumberingSeparator")
                  aRet <<= m_pImpl->m_sParam1;
              else if(rPropertyName == UNO_NAME_CHAPTER_NUMBERING_LEVEL"ChapterNumberingLevel")
                  aRet <<= m_pImpl->m_nParam1;
              break;
          case SwFieldIds::Dde:
              {
                  const sal_Int32 nPart = lcl_PropName2TokenPos(rPropertyName);
                  if(nPart  < 3 )
                      aRet <<= m_pImpl->m_sParam1.getToken(nPart, sfx2::cTokenSeparator);
                  else if(3 == nPart)
                      aRet <<= m_pImpl->m_bParam1;
              }
              break;
          default:
              throw beans::UnknownPropertyException( "Unknown property: " + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) );
          }
      }
  }
  return aRet;
930}

932void SwXFieldMaster::addPropertyChangeListener(const OUString& /*PropertyName*/, const uno::Reference< beans::XPropertyChangeListener > & /*aListener*/)
933{
  OSL_FAIL("not implemented")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unofield.cxx"
 ":" "934" ": "), "%s", "not implemented"); } } while (false);
935}

937void SwXFieldMaster::removePropertyChangeListener(const OUString& /*PropertyName*/, const uno::Reference< beans::XPropertyChangeListener > & /*aListener*/)
938{
  OSL_FAIL("not implemented")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unofield.cxx"
 ":" "939" ": "), "%s", "not implemented"); } } while (false);
940}

942void SwXFieldMaster::addVetoableChangeListener(const OUString& /*PropertyName*/, const uno::Reference< beans::XVetoableChangeListener > & /*aListener*/)
943{
  OSL_FAIL("not implemented")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unofield.cxx"
 ":" "944" ": "), "%s", "not implemented"); } } while (false);
945}

947void SwXFieldMaster::removeVetoableChangeListener(const OUString& /*PropertyName*/, const uno::Reference< beans::XVetoableChangeListener > & /*aListener*/)
948{
  OSL_FAIL("not implemented")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unofield.cxx"
 ":" "949" ": "), "%s", "not implemented"); } } while (false);
950}

952void SAL_CALL SwXFieldMaster::dispose()
953{
  SolarMutexGuard aGuard;
  SwFieldType *const pFieldType = GetFieldType(true);
  if (!pFieldType)
      throw uno::RuntimeException();
  size_t nTypeIdx = SIZE_MAX(18446744073709551615UL);
  const SwFieldTypes* pTypes = m_pImpl->m_pDoc->getIDocumentFieldsAccess().GetFieldTypes();
  for( size_t i = 0; i < pTypes->size(); i++ )
  {
      if((*pTypes)[i].get()== pFieldType)
          nTypeIdx = i;
  }

  // first delete all fields
  std::vector<SwFormatField*> vpFields;
  pFieldType->GatherFields(vpFields);
  for(auto pField : vpFields)
      SwTextField::DeleteTextField(*pField->GetTextField());
  // then delete FieldType
  m_pImpl->m_pDoc->getIDocumentFieldsAccess().RemoveFieldType(nTypeIdx);
973}

975void SAL_CALL SwXFieldMaster::addEventListener(
      const uno::Reference<lang::XEventListener> & xListener)
977{
  // no need to lock here as m_pImpl is const and container threadsafe
  m_pImpl->m_EventListeners.addInterface(xListener);
980}

982void SAL_CALL SwXFieldMaster::removeEventListener(
      const uno::Reference<lang::XEventListener> & xListener)
984{
  // no need to lock here as m_pImpl is const and container threadsafe
  m_pImpl->m_EventListeners.removeInterface(xListener);
987}

989void SwXFieldMaster::Impl::Notify(const SfxHint& rHint)
990{
  if(rHint.GetId() == SfxHintId::Dying)
  {
      m_pDoc = nullptr;
      m_pType = nullptr;
      uno::Reference<uno::XInterface> const xThis(m_wThis);
      if (!xThis.is())
      {   // fdo#72695: if UNO object is already dead, don't revive it with event
          return;
      }
      lang::EventObject const ev(xThis);
      m_EventListeners.disposeAndClear(ev);
  }
1003}

1005OUString SwXFieldMaster::GetProgrammaticName(const SwFieldType& rType, SwDoc& rDoc)
1006{
  const OUString sName(rType.GetName());
  if(SwFieldIds::SetExp == rType.Which())
  {
      const SwFieldTypes* pTypes = rDoc.getIDocumentFieldsAccess().GetFieldTypes();
      for( size_t i = 0; i <= o3tl::make_unsigned(INIT_FLDTYPES33); i++ )
      {
          if((*pTypes)[i].get() == &rType)
          {
              return SwStyleNameMapper::GetProgName( sName, SwGetPoolIdFromName::TxtColl );
          }
      }
  }
  return sName;
1020}

1022OUString SwXFieldMaster::LocalizeFormula(
  const SwSetExpField& rField,
  const OUString& rFormula,
  bool bQuery)
1026{
  const OUString sTypeName(rField.GetTyp()->GetName());
  const OUString sProgName(
      SwStyleNameMapper::GetProgName(sTypeName, SwGetPoolIdFromName::TxtColl ));
  if(sProgName != sTypeName)
  {
      const OUString sSource = bQuery ? sTypeName : sProgName;
      const OUString sDest = bQuery ? sProgName : sTypeName;
      if(rFormula.startsWith(sSource))
      {
          return sDest + rFormula.copy(sSource.getLength());
      }
  }
  return rFormula;
1040}

1042namespace {

1044struct SwFieldProperties_Impl
1045{
  OUString    sPar1;
  OUString    sPar2;
  OUString    sPar3;
  OUString    sPar4;
  Date            aDate;
  double          fDouble;
  uno::Sequence<beans::PropertyValue> aPropSeq;
  uno::Sequence<OUString> aStrings;
  std::unique_ptr<util::DateTime> pDateTime;

  sal_Int32       nSubType;
  sal_Int32       nFormat;
  sal_uInt16      nUSHORT1;
  sal_uInt16      nUSHORT2;
  sal_Int16       nSHORT1;
  sal_Int8        nByte1;
  bool            bFormatIsDefault;
  bool        bBool1;
  bool        bBool2;
  bool        bBool3;
  bool        bBool4;

  SwFieldProperties_Impl():
      aDate( Date::EMPTY ),
      fDouble(0.),
      nSubType(0),
      nFormat(0),
      nUSHORT1(0),
      nUSHORT2(0),
      nSHORT1(0),
      nByte1(0),
      bFormatIsDefault(true),
      bBool1(false),
      bBool2(false),
      bBool3(false),
      bBool4(true) //Automatic language
      {}
1083};

1085}

1087class SwXTextField::Impl
  : public SvtListener
1089{
1090private:
  ::osl::Mutex m_Mutex; // just for OInterfaceContainerHelper2
  SwFieldType* m_pFieldType;
  SwFormatField* m_pFormatField;

1095public:
  uno::WeakReference<uno::XInterface> m_wThis;
  ::comphelper::OInterfaceContainerHelper2 m_EventListeners;

  SwDoc* m_pDoc;
  rtl::Reference<SwTextAPIObject> m_xTextObject;
  bool m_bIsDescriptor;
  bool m_bCallUpdate;
  SwServiceType m_nServiceId;
  OUString m_sTypeName;
  std::unique_ptr<SwFieldProperties_Impl> m_pProps;

  Impl(SwDoc *const pDoc, SwFormatField *const pFormat, SwServiceType nServiceId)
      : m_pFieldType(nullptr)
      , m_pFormatField(pFormat)
      , m_EventListeners(m_Mutex)
      , m_pDoc(pDoc)
      , m_bIsDescriptor(pFormat == nullptr)
      , m_bCallUpdate(false)
      , m_nServiceId(pFormat
              ? lcl_GetServiceForField(*pFormat->GetField())
              : nServiceId)
      , m_pProps(pFormat ? nullptr : new SwFieldProperties_Impl)
  {
      if(m_pFormatField)
          StartListening(m_pFormatField->GetNotifier());
  }

  virtual ~Impl() override
  {
      if (m_xTextObject.is())
      {
          m_xTextObject->DisposeEditSource();
      }
  }

  void SetFormatField(SwFormatField* pFormatField, SwDoc* pDoc)
  {
      m_pFormatField = pFormatField;
      m_pDoc = pDoc;
      if(m_pFormatField)
      {
          EndListeningAll();
          StartListening(m_pFormatField->GetNotifier());
      }
  }
  SwFormatField* GetFormatField()
  {
      return m_pFormatField;
  }
  bool IsDescriptor() const
  {
      // ideally should be: !m_pFormatField && m_pDoc
      // but: SwXServiceProvider::MakeInstance() passes nullptr SwDoc, see comment there
      return m_bIsDescriptor;
  }
  void Invalidate();

  const SwField* GetField() const;

  SwFieldType* GetFieldType() const
  {
      if(!m_pDoc && !IsDescriptor())
          throw uno::RuntimeException();
      else if (IsDescriptor())
          return m_pFieldType;

      return m_pFormatField->GetField()->GetTyp();
  }
  void SetFieldType(SwFieldType& rType)
  {
      EndListeningAll();
      m_pFieldType = &rType;
      StartListening(m_pFieldType->GetNotifier());
  }
  void ClearFieldType()
  {
      SvtListener::EndListeningAll();
      m_pFieldType = nullptr;
  }
  virtual void Notify(const SfxHint&) override;
1176};

1178namespace
1179{
  class theSwXTextFieldUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theSwXTextFieldUnoTunnelId > {};
1181}

1183const uno::Sequence< sal_Int8 > & SwXTextField::getUnoTunnelId()
1184{
  return theSwXTextFieldUnoTunnelId::get().getSeq();
1186}

1188sal_Int64 SAL_CALL
1189SwXTextField::getSomething(const uno::Sequence< sal_Int8 >& rId)
1190{
  return ::sw::UnoTunnelImpl<SwXTextField>(rId, this);
1192}

1194SwXTextField::SwXTextField(
  SwServiceType nServiceId,
  SwDoc* pDoc)
  : m_pImpl(new Impl(pDoc, nullptr, nServiceId))
1198{
  //Set visible as default!
  if ( SwServiceType::FieldTypeSetExp == nServiceId
       || SwServiceType::FieldTypeDatabaseSetNum == nServiceId
       || SwServiceType::FieldTypeDatabase == nServiceId
       || SwServiceType::FieldTypeDatabaseName == nServiceId )
  {
      m_pImpl->m_pProps->bBool2 = true;
  }
  else if(SwServiceType::FieldTypeTableFormula == nServiceId)
  {
      m_pImpl->m_pProps->bBool1 = true;
  }
  if(SwServiceType::FieldTypeSetExp == nServiceId)
  {
      m_pImpl->m_pProps->nUSHORT2 = USHRT_MAX(32767 *2 +1);
  }
1215}

1217SwXTextField::SwXTextField(SwFormatField& rFormat, SwDoc & rDoc)
  : m_pImpl(new Impl(&rDoc, &rFormat, SwServiceType::Invalid))
1219{
1220}

1222SwXTextField::~SwXTextField()
1223{
1224}

1226uno::Reference<text::XTextField>
1227SwXTextField::CreateXTextField(SwDoc *const pDoc, SwFormatField const* pFormat,
      SwServiceType nServiceId)
1229{
  assert(!pFormat || pDoc)(static_cast <bool> (!pFormat || pDoc) ? void (0) : __assert_fail
 ("!pFormat || pDoc", "/home/maarten/src/libreoffice/core/sw/source/core/unocore/unofield.cxx"
, 1230, __extension__ __PRETTY_FUNCTION__));
  assert(pFormat || nServiceId != SwServiceType::Invalid)(static_cast <bool> (pFormat || nServiceId != SwServiceType
::Invalid) ? void (0) : __assert_fail ("pFormat || nServiceId != SwServiceType::Invalid"
, "/home/maarten/src/libreoffice/core/sw/source/core/unocore/unofield.cxx"
, 1231, __extension__ __PRETTY_FUNCTION__));
  // re-use existing SwXTextField
  uno::Reference<text::XTextField> xField;
  if (pFormat)
  {
      xField = pFormat->GetXTextField();
  }
  if (!xField.is())
  {
      SwXTextField *const pField( pFormat
              ? new SwXTextField(const_cast<SwFormatField&>(*pFormat), *pDoc)
              : new SwXTextField(nServiceId, pDoc));
      xField.set(pField);
      if (pFormat)
      {
          const_cast<SwFormatField *>(pFormat)->SetXTextField(xField);
      }
      // need a permanent Reference to initialize m_wThis
      pField->m_pImpl->m_wThis = xField;
  }
  return xField;
1252}

1254SwServiceType SwXTextField::GetServiceId() const
1255{
  return m_pImpl->m_nServiceId;
1257}

1259/** Convert between SwSetExpField with InputFlag false and InputFlag true.
  Unfortunately the InputFlag is exposed in the API as "Input" property
  and is mutable; in the UI and in ODF these are 2 different types of
  fields, so the API design is very questionable.
  In order to keep the mutable property, the whole thing has to be
  reconstructed from scratch, to replace the SwTextField hint with
  SwTextInputField or vice versa.
  The SwFormatField will be replaced - it must be, because the Which
  changes - but the SwXTextField *must not* be disposed in the operation,
  it has to be disconnected first and at the end connected to the
  new instance!
*/
1271void SwXTextField::TransmuteLeadToInputField(SwSetExpField & rField)
1272{
  assert(rField.GetFormatField()->Which() == (rField.GetInputFlag() ? RES_TXTATR_INPUTFIELD : RES_TXTATR_FIELD))(static_cast <bool> (rField.GetFormatField()->Which(
) == (rField.GetInputFlag() ? RES_TXTATR_INPUTFIELD : RES_TXTATR_FIELD
)) ? void (0) : __assert_fail ("rField.GetFormatField()->Which() == (rField.GetInputFlag() ? RES_TXTATR_INPUTFIELD : RES_TXTATR_FIELD)"
, "/home/maarten/src/libreoffice/core/sw/source/core/unocore/unofield.cxx"
, 1273, __extension__ __PRETTY_FUNCTION__));
1
Assuming the condition is false→
2
←
'?' condition is false→
3
←
'?' condition is true→
  uno::Reference<text::XTextField> const xField(
      rField.GetFormatField()->GetXTextField());
  SwXTextField *const pXField = xField.is()
4
←
Calling 'BaseReference::is'→
7
←
Returning from 'BaseReference::is'→
8
←
'?' condition is true→
10
←
'pXField' initialized here→
      ? reinterpret_cast<SwXTextField*>(
          sal::static_int_cast<sal_IntPtr>(
              uno::Reference<lang::XUnoTunnel>(xField, uno::UNO_QUERY_THROW)
9
←
Passing value via 1st parameter 'n'→
                  ->getSomething(getUnoTunnelId())))
      : nullptr;
  if (pXField)
11
←
Assuming 'pXField' is null→
12
←
Taking false branch→
      pXField->m_pImpl->SetFormatField(nullptr, nullptr);
  SwTextField *const pOldAttr(rField.GetFormatField()->GetTextField());
  SwSetExpField tempField(rField);
  tempField.SetInputFlag(!rField.GetInputFlag());
  SwFormatField tempFormat(tempField);
  assert(tempFormat.GetField() != &rField)(static_cast <bool> (tempFormat.GetField() != &rField
) ? void (0) : __assert_fail ("tempFormat.GetField() != &rField"
, "/home/maarten/src/libreoffice/core/sw/source/core/unocore/unofield.cxx"
, 1288, __extension__ __PRETTY_FUNCTION__));
13
←
Assuming the condition is true→
14
←
'?' condition is true→
  assert(tempFormat.GetField() != &tempField)(static_cast <bool> (tempFormat.GetField() != &tempField
) ? void (0) : __assert_fail ("tempFormat.GetField() != &tempField"
, "/home/maarten/src/libreoffice/core/sw/source/core/unocore/unofield.cxx"
, 1289, __extension__ __PRETTY_FUNCTION__)); // this copies it again?
15
←
'?' condition is true→
  assert(tempFormat.Which() == (static_cast<SwSetExpField const*>(tempFormat.GetField())->GetInputFlag() ? RES_TXTATR_INPUTFIELD : RES_TXTATR_FIELD))(static_cast <bool> (tempFormat.Which() == (static_cast
<SwSetExpField const*>(tempFormat.GetField())->GetInputFlag
() ? RES_TXTATR_INPUTFIELD : RES_TXTATR_FIELD)) ? void (0) : __assert_fail
 ("tempFormat.Which() == (static_cast<SwSetExpField const*>(tempFormat.GetField())->GetInputFlag() ? RES_TXTATR_INPUTFIELD : RES_TXTATR_FIELD)"
, "/home/maarten/src/libreoffice/core/sw/source/core/unocore/unofield.cxx"
, 1290, __extension__ __PRETTY_FUNCTION__));
16
←
Assuming the condition is true→
17
←
'?' condition is true→
18
←
'?' condition is true→
  SwTextNode & rNode(pOldAttr->GetTextNode());
  std::shared_ptr<SwPaM> pPamForTextField;
  IDocumentContentOperations & rIDCO(rNode.GetDoc().getIDocumentContentOperations());
  SwTextField::GetPamForTextField(*pOldAttr, pPamForTextField);
  assert(pPamForTextField)(static_cast <bool> (pPamForTextField) ? void (0) : __assert_fail
 ("pPamForTextField", "/home/maarten/src/libreoffice/core/sw/source/core/unocore/unofield.cxx"
, 1295, __extension__ __PRETTY_FUNCTION__));
19
←
'?' condition is true→
  sal_Int32 const nStart(pPamForTextField->Start()->nContent.GetIndex());
  rIDCO.DeleteAndJoin(*pPamForTextField);
  // ATTENTION: rField is dead now! hope nobody accesses it...
  bool bSuccess = rIDCO.InsertPoolItem(*pPamForTextField, tempFormat);
  assert(bSuccess)(static_cast <bool> (bSuccess) ? void (0) : __assert_fail
 ("bSuccess", "/home/maarten/src/libreoffice/core/sw/source/core/unocore/unofield.cxx"
, 1300, __extension__ __PRETTY_FUNCTION__));
20
←
Assuming 'bSuccess' is true→
21
←
'?' condition is true→
  (void) bSuccess;
  SwTextField const* pNewAttr(rNode.GetFieldTextAttrAt(nStart, true));
  assert(pNewAttr)(static_cast <bool> (pNewAttr) ? void (0) : __assert_fail
 ("pNewAttr", "/home/maarten/src/libreoffice/core/sw/source/core/unocore/unofield.cxx"
, 1303, __extension__ __PRETTY_FUNCTION__));
22
←
Assuming 'pNewAttr' is non-null→
23
←
'?' condition is true→
  SwFormatField const& rNewFormat(pNewAttr->GetFormatField());
  assert(rNewFormat.Which() == (static_cast<SwSetExpField const*>(rNewFormat.GetField())->GetInputFlag() ? RES_TXTATR_INPUTFIELD : RES_TXTATR_FIELD))(static_cast <bool> (rNewFormat.Which() == (static_cast
<SwSetExpField const*>(rNewFormat.GetField())->GetInputFlag
() ? RES_TXTATR_INPUTFIELD : RES_TXTATR_FIELD)) ? void (0) : __assert_fail
 ("rNewFormat.Which() == (static_cast<SwSetExpField const*>(rNewFormat.GetField())->GetInputFlag() ? RES_TXTATR_INPUTFIELD : RES_TXTATR_FIELD)"
, "/home/maarten/src/libreoffice/core/sw/source/core/unocore/unofield.cxx"
, 1305, __extension__ __PRETTY_FUNCTION__));
24
←
Assuming the condition is true→
25
←
'?' condition is true→
26
←
'?' condition is true→
  assert(static_cast<SwSetExpField const*>(rNewFormat.GetField())->GetInputFlag() == (dynamic_cast<SwTextInputField const*>(pNewAttr) != nullptr))(static_cast <bool> (static_cast<SwSetExpField const
*>(rNewFormat.GetField())->GetInputFlag() == (dynamic_cast
<SwTextInputField const*>(pNewAttr) != nullptr)) ? void
 (0) : __assert_fail ("static_cast<SwSetExpField const*>(rNewFormat.GetField())->GetInputFlag() == (dynamic_cast<SwTextInputField const*>(pNewAttr) != nullptr)"
, "/home/maarten/src/libreoffice/core/sw/source/core/unocore/unofield.cxx"
, 1306, __extension__ __PRETTY_FUNCTION__));
27
←
'?' condition is true→
  if (xField.is())
28
←
Calling 'BaseReference::is'→
30
←
Returning from 'BaseReference::is'→
31
←
Taking true branch→
  {
      pXField->m_pImpl->SetFormatField(const_cast<SwFormatField*>(&rNewFormat), &rNode.GetDoc());
32
←
Called C++ object pointer is null
      const_cast<SwFormatField&>(rNewFormat).SetXTextField(xField);
  }
1312}

1314void SAL_CALL SwXTextField::attachTextFieldMaster(
      const uno::Reference< beans::XPropertySet > & xFieldMaster)
1316{
  SolarMutexGuard aGuard;

  if (!m_pImpl->IsDescriptor())
      throw uno::RuntimeException();
  uno::Reference< lang::XUnoTunnel > xMasterTunnel(xFieldMaster, uno::UNO_QUERY);
  if (!xMasterTunnel.is())
      throw lang::IllegalArgumentException();
  SwXFieldMaster* pMaster = reinterpret_cast< SwXFieldMaster * >(
          sal::static_int_cast< sal_IntPtr >( xMasterTunnel->getSomething( SwXFieldMaster::getUnoTunnelId()) ));

  SwFieldType* pFieldType = pMaster ? pMaster->GetFieldType() : nullptr;
  if (!pFieldType ||
      pFieldType->Which() != lcl_ServiceIdToResId(m_pImpl->m_nServiceId))
  {
      throw lang::IllegalArgumentException();
  }
  m_pImpl->m_sTypeName = pFieldType->GetName();
  m_pImpl->SetFieldType(*pFieldType);
1335}

1337uno::Reference< beans::XPropertySet > SAL_CALL
1338SwXTextField::getTextFieldMaster()
1339{
  SolarMutexGuard aGuard;

  SwFieldType* pType = m_pImpl->GetFieldType();
  uno::Reference<beans::XPropertySet> const xRet(
          SwXFieldMaster::CreateXFieldMaster(m_pImpl->m_pDoc, pType));
  return xRet;
1346}

1348OUString SAL_CALL SwXTextField::getPresentation(sal_Bool bShowCommand)
1349{
  SolarMutexGuard aGuard;

  SwField const*const pField = m_pImpl->GetField();
  if (!pField)
  {
      throw uno::RuntimeException();
  }
  return bShowCommand ? pField->GetFieldName() : pField->ExpandField(true, nullptr);
1358}

1360void SAL_CALL SwXTextField::attach(
      const uno::Reference< text::XTextRange > & xTextRange)
1362{
  SolarMutexGuard aGuard;
  if (m_pImpl->IsDescriptor())
  {
      uno::Reference<lang::XUnoTunnel> xRangeTunnel( xTextRange, uno::UNO_QUERY);
      SwXTextRange* pRange = nullptr;
      OTextCursorHelper* pCursor = nullptr;
      if(xRangeTunnel.is())
      {
          pRange  = reinterpret_cast< SwXTextRange * >(
                  sal::static_int_cast< sal_IntPtr >( xRangeTunnel->getSomething( SwXTextRange::getUnoTunnelId()) ));
          pCursor = reinterpret_cast< OTextCursorHelper * >(
                  sal::static_int_cast< sal_IntPtr >( xRangeTunnel->getSomething( OTextCursorHelper::getUnoTunnelId()) ));
      }

      SwDoc* pDoc = pRange ? &pRange->GetDoc() : pCursor ? pCursor->GetDoc() : nullptr;
      // if a FieldMaster was attached, then the document is already fixed!
      // NOTE: sw.SwXAutoTextEntry unoapi test depends on m_pDoc = 0 being valid
      if (!pDoc || (m_pImpl->m_pDoc && m_pImpl->m_pDoc != pDoc))
          throw lang::IllegalArgumentException();

      SwUnoInternalPaM aPam(*pDoc);
      // this now needs to return TRUE
      ::sw::XTextRangeToSwPaM(aPam, xTextRange);
      std::unique_ptr<SwField> xField;
      switch (m_pImpl->m_nServiceId)
      {
          case SwServiceType::FieldTypeAnnotation:
              {
                  SwFieldType* pFieldType = pDoc->getIDocumentFieldsAccess().GetSysFieldType(SwFieldIds::Postit);

                  DateTime aDateTime( DateTime::EMPTY );
                  if (m_pImpl->m_pProps->pDateTime)
                  {
                      aDateTime = *(m_pImpl->m_pProps->pDateTime);
                  }
                  SwPostItField* pPostItField = new SwPostItField(
                      static_cast<SwPostItFieldType*>(pFieldType),
                      m_pImpl->m_pProps->sPar1, // author
                      m_pImpl->m_pProps->sPar2, // content
                      m_pImpl->m_pProps->sPar3, // author's initials
                      m_pImpl->m_pProps->sPar4, // name
                      aDateTime,
                      m_pImpl->m_pProps->bBool1 // resolvedflag
                  );
                  if ( m_pImpl->m_xTextObject.is() )
                  {
                      pPostItField->SetTextObject( m_pImpl->m_xTextObject->CreateText() );
                      pPostItField->SetPar2(m_pImpl->m_xTextObject->GetText());
                  }
                  xField.reset(pPostItField);
              }
              break;
          case SwServiceType::FieldTypeScript:
          {
              SwFieldType* pFieldType = pDoc->getIDocumentFieldsAccess().GetSysFieldType(SwFieldIds::Script);
              xField.reset(new SwScriptField(static_cast<SwScriptFieldType*>(pFieldType),
                      m_pImpl->m_pProps->sPar1, m_pImpl->m_pProps->sPar2,
                      m_pImpl->m_pProps->bBool1));
          }
          break;
          case SwServiceType::FieldTypeDateTime:
          {
              sal_uInt16 nSub = 0;
              if (m_pImpl->m_pProps->bBool1)
                  nSub |= FIXEDFLD;
              if (m_pImpl->m_pProps->bBool2)
                  nSub |= DATEFLD;
              else
                  nSub |= TIMEFLD;
              SwFieldType* pFieldType = pDoc->getIDocumentFieldsAccess().GetSysFieldType(SwFieldIds::DateTime);
              SwDateTimeField *const pDTField = new SwDateTimeField(
                      static_cast<SwDateTimeFieldType*>(pFieldType),
                          nSub, m_pImpl->m_pProps->nFormat);
              xField.reset(pDTField);
              if (m_pImpl->m_pProps->fDouble > 0.)
              {
                  pDTField->SetValue(m_pImpl->m_pProps->fDouble);
              }
              if (m_pImpl->m_pProps->pDateTime)
              {
                  uno::Any aVal; aVal <<= *m_pImpl->m_pProps->pDateTime;
                  xField->PutValue( aVal, FIELD_PROP_DATE_TIME25 );
              }
              pDTField->SetOffset(m_pImpl->m_pProps->nSubType);
          }
          break;
          case SwServiceType::FieldTypeFileName:
          {
              SwFieldType* pFieldType = pDoc->getIDocumentFieldsAccess().GetSysFieldType(SwFieldIds::Filename);
              sal_Int32 nFormat = m_pImpl->m_pProps->nFormat;
              if (m_pImpl->m_pProps->bBool2)
                  nFormat |= FF_FIXED;
              SwFileNameField *const pFNField = new SwFileNameField(
                      static_cast<SwFileNameFieldType*>(pFieldType), nFormat);
              xField.reset(pFNField);
              if (!m_pImpl->m_pProps->sPar3.isEmpty())
                  pFNField->SetExpansion(m_pImpl->m_pProps->sPar3);
              uno::Any aFormat;
              aFormat <<= m_pImpl->m_pProps->nFormat;
              xField->PutValue( aFormat, FIELD_PROP_FORMAT13 );
          }
          break;
          case SwServiceType::FieldTypeTemplateName:
          {
              SwFieldType* pFieldType = pDoc->getIDocumentFieldsAccess().GetSysFieldType(SwFieldIds::TemplateName);
              xField.reset(new SwTemplNameField(static_cast<SwTemplNameFieldType*>(pFieldType),
                                          m_pImpl->m_pProps->nFormat));
              uno::Any aFormat;
              aFormat <<= m_pImpl->m_pProps->nFormat;
              xField->PutValue(aFormat, FIELD_PROP_FORMAT13);
          }
          break;
          case SwServiceType::FieldTypeChapter:
          {
              SwFieldType* pFieldType = pDoc->getIDocumentFieldsAccess().GetSysFieldType(SwFieldIds::Chapter);
              SwChapterField *const pChapterField = new SwChapterField(
                      static_cast<SwChapterFieldType*>(pFieldType),
                      m_pImpl->m_pProps->nUSHORT1);
              xField.reset(pChapterField);
              pChapterField->SetLevel(m_pImpl->m_pProps->nByte1);
              uno::Any aVal;
              aVal <<= static_cast<sal_Int16>(m_pImpl->m_pProps->nUSHORT1);
              xField->PutValue(aVal, FIELD_PROP_USHORT118 );
          }
          break;
          case SwServiceType::FieldTypeAuthor:
          {
              long nFormat = m_pImpl->m_pProps->bBool1 ? AF_NAME : AF_SHORTCUT;
              if (m_pImpl->m_pProps->bBool2)
                  nFormat |= AF_FIXED;

              SwFieldType* pFieldType = pDoc->getIDocumentFieldsAccess().GetSysFieldType(SwFieldIds::Author);
              SwAuthorField *const pAuthorField = new SwAuthorField(
                      static_cast<SwAuthorFieldType*>(pFieldType), nFormat);
              xField.reset(pAuthorField);
              pAuthorField->SetExpansion(m_pImpl->m_pProps->sPar1);
          }
          break;
          case SwServiceType::FieldTypeConditionedText:
          case SwServiceType::FieldTypeHiddenText:
          {
              SwFieldType* pFieldType = pDoc->getIDocumentFieldsAccess().GetSysFieldType(SwFieldIds::HiddenText);
              SwHiddenTextField *const pHTField = new SwHiddenTextField(
                      static_cast<SwHiddenTextFieldType*>(pFieldType),
                      m_pImpl->m_pProps->sPar1,
                      m_pImpl->m_pProps->sPar2, m_pImpl->m_pProps->sPar3,
                      SwServiceType::FieldTypeHiddenText == m_pImpl->m_nServiceId ?
                           SwFieldTypesEnum::HiddenText : SwFieldTypesEnum::ConditionalText);
              xField.reset(pHTField);
              pHTField->SetValue(m_pImpl->m_pProps->bBool1);
              uno::Any aVal;
              aVal <<= m_pImpl->m_pProps->sPar4;
              xField->PutValue(aVal, FIELD_PROP_PAR423 );
          }
          break;
          case SwServiceType::FieldTypeHiddenPara:
          {
              SwFieldType* pFieldType = pDoc->getIDocumentFieldsAccess().GetSysFieldType(SwFieldIds::HiddenPara);
              SwHiddenParaField *const pHPField = new SwHiddenParaField(
                      static_cast<SwHiddenParaFieldType*>(pFieldType),
                      m_pImpl->m_pProps->sPar1);
              xField.reset(pHPField);
              pHPField->SetHidden(m_pImpl->m_pProps->bBool1);
          }
          break;
          case SwServiceType::FieldTypeGetReference:
          {
              SwFieldType* pFieldType = pDoc->getIDocumentFieldsAccess().GetSysFieldType(SwFieldIds::GetRef);
              xField.reset(new SwGetRefField(static_cast<SwGetRefFieldType*>(pFieldType),
                          m_pImpl->m_pProps->sPar1,
                          m_pImpl->m_pProps->sPar4,
                          0,
                          0,
                          0));
              if (!m_pImpl->m_pProps->sPar3.isEmpty())
                  static_cast<SwGetRefField*>(xField.get())->SetExpand(m_pImpl->m_pProps->sPar3);
              uno::Any aVal;
              aVal <<= static_cast<sal_Int16>(m_pImpl->m_pProps->nUSHORT1);
              xField->PutValue(aVal, FIELD_PROP_USHORT118 );
              aVal <<= static_cast<sal_Int16>(m_pImpl->m_pProps->nUSHORT2);
              xField->PutValue(aVal, FIELD_PROP_USHORT219 );
              aVal <<= m_pImpl->m_pProps->nSHORT1;
              xField->PutValue(aVal, FIELD_PROP_SHORT124 );
          }
          break;
          case SwServiceType::FieldTypeJumpEdit:
          {
              SwFieldType* pFieldType = pDoc->getIDocumentFieldsAccess().GetSysFieldType(SwFieldIds::JumpEdit);
              xField.reset(new SwJumpEditField(static_cast<SwJumpEditFieldType*>(pFieldType),
                      m_pImpl->m_pProps->nUSHORT1, m_pImpl->m_pProps->sPar2,
                      m_pImpl->m_pProps->sPar1));
          }
          break;
          case SwServiceType::FieldTypeDocInfoChangeAuthor:
          case SwServiceType::FieldTypeDocInfoChangeDateTime:
          case SwServiceType::FieldTypeDocInfoEditTime:
          case SwServiceType::FieldTypeDocInfoDescription:
          case SwServiceType::FieldTypeDocInfoCreateAuthor:
          case SwServiceType::FieldTypeDocInfoCreateDateTime:
          case SwServiceType::FieldTypeDocInfoCustom:
          case SwServiceType::FieldTypeDocInfoPrintAuthor:
          case SwServiceType::FieldTypeDocInfoPrintDateTime:
          case SwServiceType::FieldTypeDocInfoKeywords:
          case SwServiceType::FieldTypeDocInfoSubject:
          case SwServiceType::FieldTypeDocInfoTitle:
          case SwServiceType::FieldTypeDocInfoRevision:
          case SwServiceType::FieldTypeDocInfo:
          {
              SwFieldType* pFieldType = pDoc->getIDocumentFieldsAccess().GetSysFieldType(SwFieldIds::DocInfo);
              sal_uInt16 nSubType = aDocInfoSubTypeFromService[
                      static_cast<sal_uInt16>(m_pImpl->m_nServiceId) - sal_uInt16(SwServiceType::FieldTypeDocInfoChangeAuthor)];
              if (SwServiceType::FieldTypeDocInfoChangeDateTime == m_pImpl->m_nServiceId ||
                  SwServiceType::FieldTypeDocInfoCreateDateTime == m_pImpl->m_nServiceId ||
                  SwServiceType::FieldTypeDocInfoPrintDateTime == m_pImpl->m_nServiceId ||
                  SwServiceType::FieldTypeDocInfoEditTime == m_pImpl->m_nServiceId)
              {
                  if (m_pImpl->m_pProps->bBool2) //IsDate
                  {
                      nSubType &= 0xf0ff;
                      nSubType |= DI_SUB_DATE;
                  }
                  else
                  {
                      nSubType &= 0xf0ff;
                      nSubType |= DI_SUB_TIME;
                  }
              }
              if (m_pImpl->m_pProps->bBool1)
                  nSubType |= DI_SUB_FIXED;
              xField.reset(new SwDocInfoField(
                      static_cast<SwDocInfoFieldType*>(pFieldType), nSubType,
                      m_pImpl->m_pProps->sPar4, m_pImpl->m_pProps->nFormat));
              if (!m_pImpl->m_pProps->sPar3.isEmpty())
                  static_cast<SwDocInfoField*>(xField.get())->SetExpansion(m_pImpl->m_pProps->sPar3);
          }
          break;
          case SwServiceType::FieldTypeUserExt:
          {
              sal_Int32 nFormat = 0;
              if (m_pImpl->m_pProps->bBool1)
                  nFormat = AF_FIXED;

              SwFieldType* pFieldType = pDoc->getIDocumentFieldsAccess().GetSysFieldType(SwFieldIds::ExtUser);
              SwExtUserField *const pEUField = new SwExtUserField(
                  static_cast<SwExtUserFieldType*>(pFieldType),
                  m_pImpl->m_pProps->nUSHORT1, nFormat);
              xField.reset(pEUField);
              pEUField->SetExpansion(m_pImpl->m_pProps->sPar1);
          }
          break;
          case SwServiceType::FieldTypeUser:
          {
              SwFieldType* pFieldType =
                  pDoc->getIDocumentFieldsAccess().GetFieldType(SwFieldIds::User, m_pImpl->m_sTypeName, true);
              if (!pFieldType)
                  throw uno::RuntimeException();
              sal_uInt16 nUserSubType = (m_pImpl->m_pProps->bBool1)
                  ? nsSwExtendedSubType::SUB_INVISIBLE : 0;
              if (m_pImpl->m_pProps->bBool2)
                  nUserSubType |= nsSwExtendedSubType::SUB_CMD;
              if (m_pImpl->m_pProps->bFormatIsDefault &&
                  nsSwGetSetExpType::GSE_STRING == static_cast<SwUserFieldType*>(pFieldType)->GetType())
              {
                  m_pImpl->m_pProps->nFormat = -1;
              }
              xField.reset(new SwUserField(static_cast<SwUserFieldType*>(pFieldType),
                                  nUserSubType,
                                  m_pImpl->m_pProps->nFormat));
          }
          break;
          case SwServiceType::FieldTypeRefPageSet:
          {
              SwFieldType* pFieldType = pDoc->getIDocumentFieldsAccess().GetSysFieldType(SwFieldIds::RefPageSet);
              xField.reset(new SwRefPageSetField( static_cast<SwRefPageSetFieldType*>(pFieldType),
                                  m_pImpl->m_pProps->nUSHORT1,
                                  m_pImpl->m_pProps->bBool1 ));
          }
          break;
          case SwServiceType::FieldTypeRefPageGet:
          {
              SwFieldType* pFieldType = pDoc->getIDocumentFieldsAccess().GetSysFieldType(SwFieldIds::RefPageGet);
              SwRefPageGetField *const pRGField = new SwRefPageGetField(
                      static_cast<SwRefPageGetFieldType*>(pFieldType),
                      m_pImpl->m_pProps->nUSHORT1 );
              xField.reset(pRGField);
              pRGField->SetText(m_pImpl->m_pProps->sPar1, nullptr);
          }
          break;
          case SwServiceType::FieldTypePageNum:
          {
              SwFieldType* pFieldType = pDoc->getIDocumentFieldsAccess().GetSysFieldType(SwFieldIds::PageNumber);
              SwPageNumberField *const pPNField = new SwPageNumberField(
                  static_cast<SwPageNumberFieldType*>(pFieldType), PG_RANDOM,
                  m_pImpl->m_pProps->nFormat,
                  m_pImpl->m_pProps->nUSHORT1);
              xField.reset(pPNField);
              pPNField->SetUserString(m_pImpl->m_pProps->sPar1);
              uno::Any aVal;
              aVal <<= m_pImpl->m_pProps->nSubType;
              xField->PutValue( aVal, FIELD_PROP_SUBTYPE14 );
          }
          break;
          case SwServiceType::FieldTypeDDE:
          {
              SwFieldType* pFieldType =
                  pDoc->getIDocumentFieldsAccess().GetFieldType(SwFieldIds::Dde, m_pImpl->m_sTypeName, true);
              if (!pFieldType)
                  throw uno::RuntimeException();
              xField.reset(new SwDDEField( static_cast<SwDDEFieldType*>(pFieldType) ));
          }
          break;
          case SwServiceType::FieldTypeDatabaseName:
          {
              SwFieldType* pFieldType = pDoc->getIDocumentFieldsAccess().GetSysFieldType(SwFieldIds::DatabaseName);
              SwDBData aData;
              aData.sDataSource = m_pImpl->m_pProps->sPar1;
              aData.sCommand = m_pImpl->m_pProps->sPar2;
              aData.nCommandType = m_pImpl->m_pProps->nSHORT1;
              xField.reset(new SwDBNameField(static_cast<SwDBNameFieldType*>(pFieldType), aData));
              sal_uInt16  nSubType = xField->GetSubType();
              if (m_pImpl->m_pProps->bBool2)
                  nSubType &= ~nsSwExtendedSubType::SUB_INVISIBLE;
              else
                  nSubType |= nsSwExtendedSubType::SUB_INVISIBLE;
              xField->SetSubType(nSubType);
          }
          break;
          case SwServiceType::FieldTypeDatabaseNextSet:
          {
              SwDBData aData;
              aData.sDataSource = m_pImpl->m_pProps->sPar1;
              aData.sCommand = m_pImpl->m_pProps->sPar2;
              aData.nCommandType = m_pImpl->m_pProps->nSHORT1;
              SwFieldType* pFieldType = pDoc->getIDocumentFieldsAccess().GetSysFieldType(SwFieldIds::DbNextSet);
              xField.reset(new SwDBNextSetField(static_cast<SwDBNextSetFieldType*>(pFieldType),
                      m_pImpl->m_pProps->sPar3, aData));
          }
          break;
          case SwServiceType::FieldTypeDatabaseNumSet:
          {
              SwDBData aData;
              aData.sDataSource = m_pImpl->m_pProps->sPar1;
              aData.sCommand = m_pImpl->m_pProps->sPar2;
              aData.nCommandType = m_pImpl->m_pProps->nSHORT1;
              xField.reset(new SwDBNumSetField( static_cast<SwDBNumSetFieldType*>(
                  pDoc->getIDocumentFieldsAccess().GetSysFieldType(SwFieldIds::DbNumSet)),
                  m_pImpl->m_pProps->sPar3,
                  OUString::number(m_pImpl->m_pProps->nFormat),
                  aData ));
          }
          break;
          case SwServiceType::FieldTypeDatabaseSetNum:
          {
              SwDBData aData;
              aData.sDataSource = m_pImpl->m_pProps->sPar1;
              aData.sCommand = m_pImpl->m_pProps->sPar2;
              aData.nCommandType = m_pImpl->m_pProps->nSHORT1;
              SwDBSetNumberField *const pDBSNField =
                  new SwDBSetNumberField(static_cast<SwDBSetNumberFieldType*>(
                          pDoc->getIDocumentFieldsAccess().GetSysFieldType(SwFieldIds::DbSetNumber)), aData,
                      m_pImpl->m_pProps->nUSHORT1);
              xField.reset(pDBSNField);
              pDBSNField->SetSetNumber(m_pImpl->m_pProps->nFormat);
              sal_uInt16 nSubType = xField->GetSubType();
              if (m_pImpl->m_pProps->bBool2)
                  nSubType &= ~nsSwExtendedSubType::SUB_INVISIBLE;
              else
                  nSubType |= nsSwExtendedSubType::SUB_INVISIBLE;
              xField->SetSubType(nSubType);
          }
          break;
          case SwServiceType::FieldTypeDatabase:
          {
              SwFieldType* pFieldType =
                  pDoc->getIDocumentFieldsAccess().GetFieldType(SwFieldIds::Database, m_pImpl->m_sTypeName, false);
              if (!pFieldType)
                  throw uno::RuntimeException();
              xField.reset(new SwDBField(static_cast<SwDBFieldType*>(pFieldType),
                      m_pImpl->m_pProps->nFormat));
              static_cast<SwDBField*>(xField.get())->InitContent(m_pImpl->m_pProps->sPar1);
              sal_uInt16  nSubType = xField->GetSubType();
              if (m_pImpl->m_pProps->bBool2)
                  nSubType &= ~nsSwExtendedSubType::SUB_INVISIBLE;
              else
                  nSubType |= nsSwExtendedSubType::SUB_INVISIBLE;
              xField->SetSubType(nSubType);
          }
          break;
          case SwServiceType::FieldTypeSetExp:
          {
              SwFieldType* pFieldType =
                  pDoc->getIDocumentFieldsAccess().GetFieldType(SwFieldIds::SetExp, m_pImpl->m_sTypeName, true);
              if (!pFieldType)
                  throw uno::RuntimeException();
              // detect the field type's sub type and set an appropriate number format
              if (m_pImpl->m_pProps->bFormatIsDefault &&
                  nsSwGetSetExpType::GSE_STRING == static_cast<SwSetExpFieldType*>(pFieldType)->GetType())
              {
                  m_pImpl->m_pProps->nFormat = -1;
              }
              SwSetExpField *const pSEField = new SwSetExpField(
                  static_cast<SwSetExpFieldType*>(pFieldType),
                  m_pImpl->m_pProps->sPar2,
                  m_pImpl->m_pProps->nUSHORT2 != USHRT_MAX(32767 *2 +1) ?  //#i79471# the field can have a number format or a number_ing_ format
                  m_pImpl->m_pProps->nUSHORT2 : m_pImpl->m_pProps->nFormat);
              xField.reset(pSEField);

              sal_uInt16  nSubType = xField->GetSubType();
              if (m_pImpl->m_pProps->bBool2)
                  nSubType &= ~nsSwExtendedSubType::SUB_INVISIBLE;
              else
                  nSubType |= nsSwExtendedSubType::SUB_INVISIBLE;
              if (m_pImpl->m_pProps->bBool3)
                  nSubType |= nsSwExtendedSubType::SUB_CMD;
              else
                  nSubType &= ~nsSwExtendedSubType::SUB_CMD;
              xField->SetSubType(nSubType);
              pSEField->SetSeqNumber(m_pImpl->m_pProps->nUSHORT1);
              pSEField->SetInputFlag(m_pImpl->m_pProps->bBool1);
              pSEField->SetPromptText(m_pImpl->m_pProps->sPar3);
              if (!m_pImpl->m_pProps->sPar4.isEmpty())
                  pSEField->ChgExpStr(m_pImpl->m_pProps->sPar4, nullptr);

          }
          break;
          case SwServiceType::FieldTypeGetExp:
          {
              sal_uInt16 nSubType;
              switch (m_pImpl->m_pProps->nSubType)
              {
                  case text::SetVariableType::STRING: nSubType = nsSwGetSetExpType::GSE_STRING;   break;
                  case text::SetVariableType::VAR:        nSubType = nsSwGetSetExpType::GSE_EXPR;  break;
                  //case text::SetVariableType::SEQUENCE:   nSubType = nsSwGetSetExpType::GSE_SEQ;  break;
                  case text::SetVariableType::FORMULA:    nSubType = nsSwGetSetExpType::GSE_FORMULA; break;
                  default:
                      OSL_FAIL("wrong value")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unofield.cxx"
 ":" "1798" ": "), "%s", "wrong value"); } } while (false);
                      nSubType = nsSwGetSetExpType::GSE_EXPR;
              }
              //make sure the SubType matches the field type
              SwFieldType* pSetExpField = pDoc->getIDocumentFieldsAccess().GetFieldType(
                      SwFieldIds::SetExp, m_pImpl->m_pProps->sPar1, false);
              bool bSetGetExpFieldUninitialized = false;
              if (pSetExpField)
              {
                  if (nSubType != nsSwGetSetExpType::GSE_STRING &&
                      static_cast< SwSetExpFieldType* >(pSetExpField)->GetType() == nsSwGetSetExpType::GSE_STRING)
                      nSubType = nsSwGetSetExpType::GSE_STRING;
              }
              else
                  bSetGetExpFieldUninitialized = true; // #i82544#

              if (m_pImpl->m_pProps->bBool2)
                  nSubType |= nsSwExtendedSubType::SUB_CMD;
              else
                  nSubType &= ~nsSwExtendedSubType::SUB_CMD;
              SwGetExpField *const pGEField = new SwGetExpField(
                      static_cast<SwGetExpFieldType*>(
                          pDoc->getIDocumentFieldsAccess().GetSysFieldType(SwFieldIds::GetExp)),
                      m_pImpl->m_pProps->sPar1, nSubType,
                      m_pImpl->m_pProps->nFormat);
              xField.reset(pGEField);
              //TODO: evaluate SubType!
              if (!m_pImpl->m_pProps->sPar4.isEmpty())
                  pGEField->ChgExpStr(m_pImpl->m_pProps->sPar4, nullptr);
              // #i82544#
              if (bSetGetExpFieldUninitialized)
                  pGEField->SetLateInitialization();
          }
          break;
          case SwServiceType::FieldTypeInputUser:
          case SwServiceType::FieldTypeInput:
          {
              SwFieldType* pFieldType =
                  pDoc->getIDocumentFieldsAccess().GetFieldType(SwFieldIds::Input, m_pImpl->m_sTypeName, true);
              if (!pFieldType)
                  throw uno::RuntimeException();
              sal_uInt16 nInpSubType =
                  sal::static_int_cast<sal_uInt16>(
                      SwServiceType::FieldTypeInputUser == m_pImpl->m_nServiceId
                          ? INP_USR : INP_TXT);
              SwInputField * pTextField =
                  new SwInputField(static_cast<SwInputFieldType*>(pFieldType),
                                   m_pImpl->m_pProps->sPar1,
                                   m_pImpl->m_pProps->sPar2,
                                   nInpSubType);
              pTextField->SetHelp(m_pImpl->m_pProps->sPar3);
              pTextField->SetToolTip(m_pImpl->m_pProps->sPar4);

              xField.reset(pTextField);
          }
          break;
          case SwServiceType::FieldTypeMacro:
          {
              SwFieldType* pFieldType = pDoc->getIDocumentFieldsAccess().GetSysFieldType(SwFieldIds::Macro);
              OUString aName;

              // support for Scripting Framework macros
              if (!m_pImpl->m_pProps->sPar4.isEmpty())
              {
                  aName = m_pImpl->m_pProps->sPar4;
              }
              else
              {
                  SwMacroField::CreateMacroString(aName,
                      m_pImpl->m_pProps->sPar1, m_pImpl->m_pProps->sPar3);
              }
              xField.reset(new SwMacroField(static_cast<SwMacroFieldType*>(pFieldType), aName,
                                      m_pImpl->m_pProps->sPar2));
          }
          break;
          case SwServiceType::FieldTypePageCount:
          case SwServiceType::FieldTypeParagraphCount:
          case SwServiceType::FieldTypeWordCount:
          case SwServiceType::FieldTypeCharacterCount:
          case SwServiceType::FieldTypeTableCount:
          case SwServiceType::FieldTypeGraphicObjectCount:
          case SwServiceType::FieldTypeEmbeddedObjectCount:
          {
              sal_uInt16 nSubType = DS_PAGE;
              switch (m_pImpl->m_nServiceId)
              {
                  case SwServiceType::FieldTypeParagraphCount       : nSubType = DS_PARA; break;
                  case SwServiceType::FieldTypeWordCount            : nSubType = DS_WORD; break;
                  case SwServiceType::FieldTypeCharacterCount       : nSubType = DS_CHAR; break;
                  case SwServiceType::FieldTypeTableCount           : nSubType = DS_TBL;  break;
                  case SwServiceType::FieldTypeGraphicObjectCount  : nSubType = DS_GRF;  break;
                  case SwServiceType::FieldTypeEmbeddedObjectCount : nSubType = DS_OLE;  break;
                  default: break;
              }
              SwFieldType* pFieldType = pDoc->getIDocumentFieldsAccess().GetSysFieldType(SwFieldIds::DocStat);
              xField.reset(new SwDocStatField(
                      static_cast<SwDocStatFieldType*>(pFieldType),
                      nSubType, m_pImpl->m_pProps->nUSHORT2));
          }
          break;
          case SwServiceType::FieldTypeBibliography:
          {
              SwAuthorityFieldType const type(pDoc);
              xField.reset(new SwAuthorityField(static_cast<SwAuthorityFieldType*>(
                          pDoc->getIDocumentFieldsAccess().InsertFieldType(type)),
                      OUString()));
              if (m_pImpl->m_pProps->aPropSeq.hasElements())
              {
                  uno::Any aVal;
                  aVal <<= m_pImpl->m_pProps->aPropSeq;
                  xField->PutValue( aVal, FIELD_PROP_PROP_SEQ26 );
              }
          }
          break;
          case SwServiceType::FieldTypeCombinedCharacters:
              // create field
              xField.reset(new SwCombinedCharField( static_cast<SwCombinedCharFieldType*>(
                          pDoc->getIDocumentFieldsAccess().GetSysFieldType(SwFieldIds::CombinedChars)),
                          m_pImpl->m_pProps->sPar1));
              break;
          case SwServiceType::FieldTypeDropdown:
          {
              SwDropDownField *const pDDField = new SwDropDownField(
                  static_cast<SwDropDownFieldType *>(
                      pDoc->getIDocumentFieldsAccess().GetSysFieldType(SwFieldIds::Dropdown)));
              xField.reset(pDDField);

              pDDField->SetItems(m_pImpl->m_pProps->aStrings);
              pDDField->SetSelectedItem(m_pImpl->m_pProps->sPar1);
              pDDField->SetName(m_pImpl->m_pProps->sPar2);
              pDDField->SetHelp(m_pImpl->m_pProps->sPar3);
              pDDField->SetToolTip(m_pImpl->m_pProps->sPar4);
          }
          break;

          case SwServiceType::FieldTypeTableFormula:
          {
              // create field
              sal_uInt16 nType = nsSwGetSetExpType::GSE_FORMULA;
              if (m_pImpl->m_pProps->bBool1)
              {
                  nType |= nsSwExtendedSubType::SUB_CMD;
                  if (m_pImpl->m_pProps->bFormatIsDefault)
                      m_pImpl->m_pProps->nFormat = -1;
              }
              xField.reset(new SwTableField( static_cast<SwTableFieldType*>(
                  pDoc->getIDocumentFieldsAccess().GetSysFieldType(SwFieldIds::Table)),
                  m_pImpl->m_pProps->sPar2,
                  nType,
                  m_pImpl->m_pProps->nFormat));
              static_cast<SwTableField*>(xField.get())->ChgExpStr(m_pImpl->m_pProps->sPar1);
          }
          break;
          default: OSL_FAIL("What kind of type is that?")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unofield.cxx"
 ":" "1951" ": "), "%s", "What kind of type is that?"); } } while
 (false);
      }

      if (!xField)
          throw uno::RuntimeException("no SwField created?");

      xField->SetAutomaticLanguage(!m_pImpl->m_pProps->bBool4);
      SwFormatField aFormat(*xField);

      UnoActionContext aCont(pDoc);
      if (aPam.HasMark() &&
          m_pImpl->m_nServiceId != SwServiceType::FieldTypeAnnotation)
      {
          pDoc->getIDocumentContentOperations().DeleteAndJoin(aPam);
      }

      SwXTextCursor const*const pTextCursor(dynamic_cast<SwXTextCursor*>(pCursor));
      const bool bForceExpandHints(
          pTextCursor
          && pTextCursor->IsAtEndOfMeta() );
      const SetAttrMode nInsertFlags =
          bForceExpandHints
          ? SetAttrMode::FORCEHINTEXPAND
          : SetAttrMode::DEFAULT;

      if (*aPam.GetPoint() != *aPam.GetMark() &&
          m_pImpl->m_nServiceId == SwServiceType::FieldTypeAnnotation)
      {
          // Make sure we always insert the field at the end
          SwPaM aEnd(*aPam.End(), *aPam.End());
          pDoc->getIDocumentContentOperations().InsertPoolItem(aEnd, aFormat, nInsertFlags);
      }
      else
          pDoc->getIDocumentContentOperations().InsertPoolItem(aPam, aFormat, nInsertFlags);

      SwTextAttr* pTextAttr = aPam.GetNode().GetTextNode()->GetFieldTextAttrAt( aPam.GetPoint()->nContent.GetIndex()-1, true );

      // What about updating the fields? (see fldmgr.cxx)
      if (!pTextAttr)
          throw uno::RuntimeException("no SwTextAttr inserted?");  // could theoretically happen, if paragraph is full

      const SwFormatField& rField = pTextAttr->GetFormatField();
      m_pImpl->SetFormatField(const_cast<SwFormatField*>(&rField), pDoc);

      if ( pTextAttr->Which() == RES_TXTATR_ANNOTATION
           && *aPam.GetPoint() != *aPam.GetMark() )
      {
          // create annotation mark
          const SwPostItField* pPostItField = dynamic_cast< const SwPostItField* >(pTextAttr->GetFormatField().GetField());
          OSL_ENSURE( pPostItField != nullptr, "<SwXTextField::attachToRange(..)> - annotation field missing!" )do { if (true && (!(pPostItField != nullptr))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unofield.cxx"
 ":" "2000" ": "), "%s", "<SwXTextField::attachToRange(..)> - annotation field missing!"
); } } while (false);
          if ( pPostItField != nullptr )
          {
              IDocumentMarkAccess* pMarksAccess = pDoc->getIDocumentMarkAccess();
              pMarksAccess->makeAnnotationMark( aPam, pPostItField->GetName() );
          }
      }

      xField.reset();

      assert(m_pImpl->GetFormatField())(static_cast <bool> (m_pImpl->GetFormatField()) ? void
 (0) : __assert_fail ("m_pImpl->GetFormatField()", "/home/maarten/src/libreoffice/core/sw/source/core/unocore/unofield.cxx"
, 2010, __extension__ __PRETTY_FUNCTION__));
      m_pImpl->m_pDoc = pDoc;
      m_pImpl->GetFormatField()->SetXTextField(this);
      m_pImpl->m_wThis = *this;
      m_pImpl->m_bIsDescriptor = false;
      m_pImpl->ClearFieldType();
      m_pImpl->m_pProps.reset();
      if (m_pImpl->m_bCallUpdate)
          update();
  }
  else if ( !m_pImpl->IsDescriptor()
            && m_pImpl->m_pDoc != nullptr
            && m_pImpl->m_nServiceId == SwServiceType::FieldTypeAnnotation )
  {
      SwUnoInternalPaM aIntPam( *m_pImpl->m_pDoc );
      if ( !::sw::XTextRangeToSwPaM( aIntPam, xTextRange ) )
          throw lang::IllegalArgumentException();

      // Nothing to do, if the text range has a separate start and end, but they have the same
      // value.
      if (!aIntPam.HasMark() || *aIntPam.Start() != *aIntPam.End())
      {
          UnoActionContext aCont( m_pImpl->m_pDoc );
          // insert copy of annotation at new text range
          std::unique_ptr<SwPostItField> pPostItField(static_cast< SwPostItField* >(m_pImpl->GetFormatField()->GetField()->CopyField().release()));
          SwFormatField aFormatField( *pPostItField );
          pPostItField.reset();
          SwPaM aEnd( *aIntPam.End(), *aIntPam.End() );
          m_pImpl->m_pDoc->getIDocumentContentOperations().InsertPoolItem( aEnd, aFormatField );
          // delete former annotation
          {
              const SwTextField* pTextField = m_pImpl->GetFormatField()->GetTextField();
              SwTextNode& rTextNode = *pTextField->GetpTextNode();
              SwPaM aPam( rTextNode, pTextField->GetStart() );
              aPam.SetMark();
              aPam.Move();
              m_pImpl->m_pDoc->getIDocumentContentOperations().DeleteAndJoin(aPam);
          }
          // keep inserted annotation
          {
              SwTextField* pTextAttr = aEnd.GetNode().GetTextNode()->GetFieldTextAttrAt( aEnd.End()->nContent.GetIndex()-1, true );
              if ( pTextAttr != nullptr )
              {
                  m_pImpl->SetFormatField(const_cast<SwFormatField*>(&pTextAttr->GetFormatField()), m_pImpl->m_pDoc);

                  if ( *aIntPam.GetPoint() != *aIntPam.GetMark() )
                  {
                      // create annotation mark
                      const SwPostItField* pField = dynamic_cast< const SwPostItField* >(pTextAttr->GetFormatField().GetField());
                      OSL_ENSURE( pField != nullptr, "<SwXTextField::attach(..)> - annotation field missing!" )do { if (true && (!(pField != nullptr))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unofield.cxx"
 ":" "2059" ": "), "%s", "<SwXTextField::attach(..)> - annotation field missing!"
); } } while (false);
                      if ( pField != nullptr )
                      {
                          IDocumentMarkAccess* pMarksAccess = aIntPam.GetDoc().getIDocumentMarkAccess();
                          pMarksAccess->makeAnnotationMark( aIntPam, pField->GetName() );
                      }
                  }
              }
          }
      }

  }
  else
      throw lang::IllegalArgumentException();
2073}

2075uno::Reference< text::XTextRange > SAL_CALL
2076SwXTextField::getAnchor()
2077{
  SolarMutexGuard aGuard;

  SwField const*const pField = m_pImpl->GetField();
  if (!pField)
      return nullptr;

  const SwTextField* pTextField = m_pImpl->GetFormatField()->GetTextField();
  if (!pTextField)
      throw uno::RuntimeException();

  std::shared_ptr< SwPaM > pPamForTextField;
  SwTextField::GetPamForTextField(*pTextField, pPamForTextField);
  if (pPamForTextField == nullptr)
      return nullptr;

  // If this is a postit field, then return the range of its annotation mark if it has one.
  if (pField->Which() == SwFieldIds::Postit)
  {
      const SwPostItField* pPostItField = static_cast<const SwPostItField*>(pField);
      IDocumentMarkAccess* pMarkAccess = m_pImpl->m_pDoc->getIDocumentMarkAccess();
      for (IDocumentMarkAccess::const_iterator_t ppMark = pMarkAccess->getAnnotationMarksBegin(); ppMark != pMarkAccess->getAnnotationMarksEnd(); ++ppMark)
      {
          if ((*ppMark)->GetName() == pPostItField->GetName())
          {
              pPamForTextField = std::make_shared<SwPaM>((*ppMark)->GetMarkStart(), (*ppMark)->GetMarkEnd());
              break;
          }
      }
  }

  uno::Reference<text::XTextRange> xRange = SwXTextRange::CreateXTextRange(
          *m_pImpl->m_pDoc, *(pPamForTextField->GetPoint()), pPamForTextField->GetMark());
  return xRange;
2111}

2113void SAL_CALL SwXTextField::dispose()
2114{
  SolarMutexGuard aGuard;
  SwField const*const pField = m_pImpl->GetField();
  if(pField && m_pImpl->m_pDoc)
  {
      UnoActionContext aContext(m_pImpl->m_pDoc);
      assert(m_pImpl->GetFormatField()->GetTextField() && "<SwXTextField::dispose()> - missing <SwTextField> --> crash")(static_cast <bool> (m_pImpl->GetFormatField()->GetTextField
() && "<SwXTextField::dispose()> - missing <SwTextField> --> crash"
) ? void (0) : __assert_fail ("m_pImpl->GetFormatField()->GetTextField() && \"<SwXTextField::dispose()> - missing <SwTextField> --> crash\""
, "/home/maarten/src/libreoffice/core/sw/source/core/unocore/unofield.cxx"
, 2120, __extension__ __PRETTY_FUNCTION__));
      SwTextField::DeleteTextField(*(m_pImpl->GetFormatField()->GetTextField()));
  }

  if (m_pImpl->m_xTextObject.is())
  {
      m_pImpl->m_xTextObject->DisposeEditSource();
      m_pImpl->m_xTextObject.clear();
  }
  m_pImpl->Invalidate();
2130}

2132void SAL_CALL SwXTextField::addEventListener(
      const uno::Reference<lang::XEventListener> & xListener)
2134{
  // no need to lock here as m_pImpl is const and container threadsafe
  m_pImpl->m_EventListeners.addInterface(xListener);
2137}

2139void SAL_CALL SwXTextField::removeEventListener(
      const uno::Reference<lang::XEventListener> & xListener)
2141{
  // no need to lock here as m_pImpl is const and container threadsafe
  m_pImpl->m_EventListeners.removeInterface(xListener);
2144}

2146uno::Reference< beans::XPropertySetInfo > SAL_CALL
2147SwXTextField::getPropertySetInfo()
2148{
  SolarMutexGuard aGuard;
  // no static
  uno::Reference< beans::XPropertySetInfo >  aRef;
  if (m_pImpl->m_nServiceId == SwServiceType::Invalid)
  {
      throw uno::RuntimeException();
  }
  const SfxItemPropertySet* pPropSet = aSwMapProvider.GetPropertySet(
                  lcl_GetPropertyMapOfService(m_pImpl->m_nServiceId));
  const uno::Reference<beans::XPropertySetInfo>& xInfo = pPropSet->getPropertySetInfo();
  // extend PropertySetInfo!
  const uno::Sequence<beans::Property> aPropSeq = xInfo->getProperties();
  aRef = new SfxExtItemPropertySetInfo(
      aSwMapProvider.GetPropertyMapEntries(PROPERTY_MAP_PARAGRAPH_EXTENSIONS24),
      aPropSeq );
  return aRef;
2165}

2167void SAL_CALL
2168SwXTextField::setPropertyValue(
      const OUString& rPropertyName, const uno::Any& rValue)
2170{
  SolarMutexGuard aGuard;
  SwField const*const pField = m_pImpl->GetField();
  const SfxItemPropertySet* _pPropSet = aSwMapProvider.GetPropertySet(
              lcl_GetPropertyMapOfService(m_pImpl->m_nServiceId));
  const SfxItemPropertySimpleEntry*   pEntry = _pPropSet->getPropertyMap().getByName(rPropertyName);

  if (!pEntry)
      throw beans::UnknownPropertyException( "Unknown property: " + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) );
  if ( pEntry->nFlags & beans::PropertyAttribute::READONLY)
      throw beans::PropertyVetoException( "Property is read-only: " + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) );

  if(pField)
  {
      // special treatment for mail merge fields
      const SwFieldIds nWhich = pField->Which();
      if( SwFieldIds::Database == nWhich &&
          (rPropertyName == UNO_NAME_DATA_BASE_NAME"DataBaseName" ||
          rPropertyName == UNO_NAME_DATA_BASE_URL"DataBaseURL"||
          rPropertyName == UNO_NAME_DATA_TABLE_NAME"DataTableName"||
          rPropertyName == UNO_NAME_DATA_COLUMN_NAME"DataColumnName"))
      {
          // here a new field type must be created and the field must
          // be registered at the new type
          OSL_FAIL("not implemented")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unofield.cxx"
 ":" "2194" ": "), "%s", "not implemented"); } } while (false
);
      }
      else
      {
          SwDoc * pDoc = m_pImpl->m_pDoc;
          assert(pDoc)(static_cast <bool> (pDoc) ? void (0) : __assert_fail (
"pDoc", "/home/maarten/src/libreoffice/core/sw/source/core/unocore/unofield.cxx"
, 2199, __extension__ __PRETTY_FUNCTION__));
          const SwTextField* pTextField = m_pImpl->GetFormatField()->GetTextField();
          if(!pTextField)
              throw uno::RuntimeException();
          SwPosition aPosition( pTextField->GetTextNode() );
          aPosition.nContent = pTextField->GetStart();
          pDoc->getIDocumentFieldsAccess().PutValueToField( aPosition, rValue, pEntry->nWID);
      }

      //#i100374# notify SwPostIt about new field content
      assert(m_pImpl->GetFormatField())(static_cast <bool> (m_pImpl->GetFormatField()) ? void
 (0) : __assert_fail ("m_pImpl->GetFormatField()", "/home/maarten/src/libreoffice/core/sw/source/core/unocore/unofield.cxx"
, 2209, __extension__ __PRETTY_FUNCTION__));
      if (SwFieldIds::Postit == nWhich)
      {
          m_pImpl->GetFormatField()->Broadcast(
                  SwFormatFieldHint( nullptr, SwFormatFieldHintWhich::CHANGED ));
      }

      // fdo#42073 notify SwTextField about changes of the expanded string
      if (m_pImpl->GetFormatField()->GetTextField())
      {
          m_pImpl->GetFormatField()->GetTextField()->ExpandTextField();
      }

      //#i100374# changing a document field should set the modify flag
      SwDoc* pDoc = m_pImpl->m_pDoc;
      if (pDoc)
          pDoc->getIDocumentState().SetModified();

  }
  else if (m_pImpl->m_pProps)
  {
      bool* pBool = nullptr;
      switch(pEntry->nWID)
      {
      case FIELD_PROP_PAR110:
          rValue >>= m_pImpl->m_pProps->sPar1;
          break;
      case FIELD_PROP_PAR211:
          rValue >>= m_pImpl->m_pProps->sPar2;
          break;
      case FIELD_PROP_PAR312:
          rValue >>= m_pImpl->m_pProps->sPar3;
          break;
      case FIELD_PROP_PAR423:
          rValue >>= m_pImpl->m_pProps->sPar4;
          break;
      case FIELD_PROP_FORMAT13:
          rValue >>= m_pImpl->m_pProps->nFormat;
          m_pImpl->m_pProps->bFormatIsDefault = false;
          break;
      case FIELD_PROP_SUBTYPE14:
          m_pImpl->m_pProps->nSubType = SWUnoHelper::GetEnumAsInt32(rValue);
          break;
      case FIELD_PROP_BYTE120 :
          rValue >>= m_pImpl->m_pProps->nByte1;
          break;
      case FIELD_PROP_BOOL115 :
          pBool = &m_pImpl->m_pProps->bBool1;
          break;
      case FIELD_PROP_BOOL216 :
          pBool = &m_pImpl->m_pProps->bBool2;
          break;
      case FIELD_PROP_BOOL322 :
          pBool = &m_pImpl->m_pProps->bBool3;
          break;
      case FIELD_PROP_BOOL428:
          pBool = &m_pImpl->m_pProps->bBool4;
      break;
      case FIELD_PROP_DATE17 :
      {
          auto aTemp = o3tl::tryAccess<util::Date>(rValue);
          if(!aTemp)
              throw lang::IllegalArgumentException();

          m_pImpl->m_pProps->aDate = Date(aTemp->Day, aTemp->Month, aTemp->Year);
      }
      break;
      case FIELD_PROP_USHORT118:
      case FIELD_PROP_USHORT219:
          {
              sal_Int16 nVal = 0;
              rValue >>= nVal;
              if( FIELD_PROP_USHORT118 == pEntry->nWID)
                  m_pImpl->m_pProps->nUSHORT1 = nVal;
              else
                  m_pImpl->m_pProps->nUSHORT2 = nVal;
          }
          break;
      case FIELD_PROP_SHORT124:
          rValue >>= m_pImpl->m_pProps->nSHORT1;
          break;
      case FIELD_PROP_DOUBLE21:
          if(rValue.getValueType() != ::cppu::UnoType<double>::get())
              throw lang::IllegalArgumentException();
          rValue >>= m_pImpl->m_pProps->fDouble;
          break;

      case FIELD_PROP_DATE_TIME25 :
          if (!m_pImpl->m_pProps->pDateTime)
              m_pImpl->m_pProps->pDateTime.reset( new util::DateTime );
          rValue >>= *m_pImpl->m_pProps->pDateTime;
          break;
      case FIELD_PROP_PROP_SEQ26:
          rValue >>= m_pImpl->m_pProps->aPropSeq;
          break;
      case FIELD_PROP_STRINGS29:
          rValue >>= m_pImpl->m_pProps->aStrings;
          break;
      }
      if (pBool)
      {
          auto b = o3tl::tryAccess<bool>(rValue);
          if( !b )
              throw lang::IllegalArgumentException();
          *pBool = *b;

      }
  }
  else
      throw uno::RuntimeException();
2319}

2321uno::Any SAL_CALL SwXTextField::getPropertyValue(const OUString& rPropertyName)
2322{
  SolarMutexGuard aGuard;
  uno::Any aRet;
  SwField const*const pField = m_pImpl->GetField();
  const SfxItemPropertySet* _pPropSet = aSwMapProvider.GetPropertySet(
              lcl_GetPropertyMapOfService(m_pImpl->m_nServiceId));
  const SfxItemPropertySimpleEntry*   pEntry = _pPropSet->getPropertyMap().getByName(rPropertyName);
  if(!pEntry )
  {
      const SfxItemPropertySet* _pParaPropSet = aSwMapProvider.GetPropertySet(PROPERTY_MAP_PARAGRAPH_EXTENSIONS24);
      pEntry = _pParaPropSet->getPropertyMap().getByName(rPropertyName);
  }
  if (!pEntry)
      throw beans::UnknownPropertyException( "Unknown property: " + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) );

  switch( pEntry->nWID )
  {
  case FN_UNO_TEXT_WRAP((20000 + 2200) + 70):
      aRet <<= text::WrapTextMode_NONE;
      break;
  case FN_UNO_ANCHOR_TYPE((20000 + 2200) + 71):
      aRet <<= text::TextContentAnchorType_AS_CHARACTER;
      break;
  case FN_UNO_ANCHOR_TYPES((20000 + 2200) + 65):
      {
          uno::Sequence<text::TextContentAnchorType> aTypes(1);
          text::TextContentAnchorType* pArray = aTypes.getArray();
          pArray[0] = text::TextContentAnchorType_AS_CHARACTER;
          aRet <<= aTypes;
      }
      break;

  default:
      if( pField )
      {
          if (FIELD_PROP_IS_FIELD_USED32      == pEntry->nWID ||
              FIELD_PROP_IS_FIELD_DISPLAYED33 == pEntry->nWID)
          {
              bool bIsFieldUsed       = false;
              bool bIsFieldDisplayed  = false;

              // in order to have the information about fields
              // correctly evaluated the document needs a layout
              // (has to be already formatted)
              SwDoc *pDoc = m_pImpl->m_pDoc;
              SwViewShell *pViewShell = nullptr;
              SwEditShell *pEditShell = nullptr;
              if( pDoc )
              {
                  pViewShell = pDoc->getIDocumentLayoutAccess().GetCurrentViewShell();
                  pEditShell = pDoc->GetEditShell();
              }

              if (pEditShell)
                  pEditShell->CalcLayout();
              else if (pViewShell) // a page preview has no SwEditShell it should only have a view shell
                  pViewShell->CalcLayout();
              else
                  throw uno::RuntimeException();

              // get text node for the text field
              const SwFormatField *pFieldFormat =
                  (m_pImpl->GetField()) ? m_pImpl->GetFormatField() : nullptr;
              const SwTextField* pTextField = pFieldFormat
                  ? m_pImpl->GetFormatField()->GetTextField() : nullptr;
              if(!pTextField)
                  throw uno::RuntimeException();
              const SwTextNode& rTextNode = pTextField->GetTextNode();

              // skip fields that are currently not in the document
              // e.g. fields in undo or redo array
              if (rTextNode.GetNodes().IsDocNodes())
              {
                  bool bFrame = 0 != rTextNode.FindLayoutRect().Width(); // or so
                  bool bHidden = rTextNode.IsHidden();
                  if ( !bHidden )
                  {
                      sal_Int32 nHiddenStart;
                      sal_Int32 nHiddenEnd;
                      bHidden = SwScriptInfo::GetBoundsOfHiddenRange( pTextField->GetTextNode(),
                                      pTextField->GetStart(),
                                      nHiddenStart, nHiddenEnd );
                  }

                  // !bFrame && !bHidden: most probably a field in an unused page style

                  // FME: Problem: hidden field in unused page template =>
                  // bIsFieldUsed = true
                  // bIsFieldDisplayed = false
                  bIsFieldUsed       = bFrame || bHidden;
                  bIsFieldDisplayed  = bIsFieldUsed && !bHidden;
              }
              aRet <<= (FIELD_PROP_IS_FIELD_USED32 == pEntry->nWID) ? bIsFieldUsed : bIsFieldDisplayed;
          }
          else
              pField->QueryValue( aRet, pEntry->nWID );
      }
      else if (m_pImpl->m_pProps)     // currently just a descriptor...
      {
          switch(pEntry->nWID)
          {
          case FIELD_PROP_TEXT34:
              {
                  if (!m_pImpl->m_xTextObject.is())
                  {
                      m_pImpl->m_xTextObject
                          = new SwTextAPIObject( std::make_unique<SwTextAPIEditSource>(m_pImpl->m_pDoc) );
                  }

                  uno::Reference<text::XText> xText(m_pImpl->m_xTextObject.get());
                  aRet <<= xText;
                  break;
              }
          case FIELD_PROP_PAR110:
              aRet <<= m_pImpl->m_pProps->sPar1;
              break;
          case FIELD_PROP_PAR211:
              aRet <<= m_pImpl->m_pProps->sPar2;
              break;
          case FIELD_PROP_PAR312:
              aRet <<= m_pImpl->m_pProps->sPar3;
              break;
          case FIELD_PROP_PAR423:
              aRet <<= m_pImpl->m_pProps->sPar4;
              break;
          case FIELD_PROP_FORMAT13:
              aRet <<= m_pImpl->m_pProps->nFormat;
              break;
          case FIELD_PROP_SUBTYPE14:
              aRet <<= m_pImpl->m_pProps->nSubType;
              break;
          case FIELD_PROP_BYTE120 :
              aRet <<= m_pImpl->m_pProps->nByte1;
              break;
          case FIELD_PROP_BOOL115 :
              aRet <<= m_pImpl->m_pProps->bBool1;
              break;
          case FIELD_PROP_BOOL216 :
              aRet <<= m_pImpl->m_pProps->bBool2;
              break;
          case FIELD_PROP_BOOL322 :
              aRet <<= m_pImpl->m_pProps->bBool3;
              break;
          case FIELD_PROP_BOOL428 :
              aRet <<= m_pImpl->m_pProps->bBool4;
              break;
          case FIELD_PROP_DATE17 :
              aRet <<= m_pImpl->m_pProps->aDate.GetUNODate();
              break;
          case FIELD_PROP_USHORT118:
              aRet <<= static_cast<sal_Int16>(m_pImpl->m_pProps->nUSHORT1);
              break;
          case FIELD_PROP_USHORT219:
              aRet <<= static_cast<sal_Int16>(m_pImpl->m_pProps->nUSHORT2);
              break;
          case FIELD_PROP_SHORT124:
              aRet <<= m_pImpl->m_pProps->nSHORT1;
              break;
          case FIELD_PROP_DOUBLE21:
              aRet <<= m_pImpl->m_pProps->fDouble;
              break;
          case FIELD_PROP_DATE_TIME25 :
              if (m_pImpl->m_pProps->pDateTime)
                  aRet <<= *m_pImpl->m_pProps->pDateTime;
              break;
          case FIELD_PROP_PROP_SEQ26:
              aRet <<= m_pImpl->m_pProps->aPropSeq;
              break;
          case FIELD_PROP_STRINGS29:
              aRet <<= m_pImpl->m_pProps->aStrings;
              break;
          case FIELD_PROP_IS_FIELD_USED32:
          case FIELD_PROP_IS_FIELD_DISPLAYED33:
              aRet <<= false;
              break;
          }
      }
      else
          throw uno::RuntimeException();
  }
  return aRet;
2503}

2505void SwXTextField::addPropertyChangeListener(const OUString& /*PropertyName*/, const uno::Reference< beans::XPropertyChangeListener > & /*aListener*/)
2506{
  OSL_FAIL("not implemented")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unofield.cxx"
 ":" "2507" ": "), "%s", "not implemented"); } } while (false
);
2508}

2510void SwXTextField::removePropertyChangeListener(const OUString& /*PropertyName*/, const uno::Reference< beans::XPropertyChangeListener > & /*aListener*/)
2511{
  OSL_FAIL("not implemented")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unofield.cxx"
 ":" "2512" ": "), "%s", "not implemented"); } } while (false
);
2513}

2515void SwXTextField::addVetoableChangeListener(const OUString& /*PropertyName*/, const uno::Reference< beans::XVetoableChangeListener > & /*aListener*/)
2516{
  OSL_FAIL("not implemented")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unofield.cxx"
 ":" "2517" ": "), "%s", "not implemented"); } } while (false
);
2518}

2520void SwXTextField::removeVetoableChangeListener(const OUString& /*PropertyName*/, const uno::Reference< beans::XVetoableChangeListener > & /*aListener*/)
2521{
  OSL_FAIL("not implemented")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/unocore/unofield.cxx"
 ":" "2522" ": "), "%s", "not implemented"); } } while (false
);
2523}

2525void SAL_CALL SwXTextField::update()
2526{
  SolarMutexGuard aGuard;
  SwField * pField = const_cast<SwField*>(m_pImpl->GetField());
  if (pField)
  {
      switch(pField->Which())
      {
          case SwFieldIds::DateTime:
          static_cast<SwDateTimeField*>(pField)->SetDateTime( ::DateTime( ::DateTime::SYSTEM ) );
          break;

          case SwFieldIds::ExtUser:
          {
              SwExtUserField* pExtUserField = static_cast<SwExtUserField*>(pField);
              pExtUserField->SetExpansion( SwExtUserFieldType::Expand(
                                          pExtUserField->GetSubType() ) );
          }
          break;

          case SwFieldIds::Author:
          {
              SwAuthorField* pAuthorField = static_cast<SwAuthorField*>(pField);
              pAuthorField->SetExpansion( SwAuthorFieldType::Expand(
                                          pAuthorField->GetFormat() ) );
          }
          break;

          case SwFieldIds::Filename:
          {
              SwFileNameField* pFileNameField = static_cast<SwFileNameField*>(pField);
              pFileNameField->SetExpansion( static_cast<SwFileNameFieldType*>(pField->GetTyp())->Expand(
                                          pFileNameField->GetFormat() ) );
          }
          break;

          case SwFieldIds::DocInfo:
          {
                  SwDocInfoField* pDocInfField = static_cast<SwDocInfoField*>(pField);
                  pDocInfField->SetExpansion( static_cast<SwDocInfoFieldType*>(pField->GetTyp())->Expand(
                                              pDocInfField->GetSubType(),
                                              pDocInfField->GetFormat(),
                                              pDocInfField->GetLanguage(),
                                              pDocInfField->GetName() ) );
          }
          break;
          default: break;
      }
      // Text formatting has to be triggered.
      m_pImpl->GetFormatField()->ModifyNotification(nullptr, nullptr);
  }
  else
      m_pImpl->m_bCallUpdate = true;
2578}

2580OUString SAL_CALL SwXTextField::getImplementationName()
2581{
  return "SwXTextField";
2583}

2585static OUString OldNameToNewName_Impl( const OUString &rOld )
2586{
  static const char aOldNamePart1[] = ".TextField.DocInfo.";
  static const char aOldNamePart2[] = ".TextField.";
  OUString sServiceNameCC( rOld );
  sal_Int32 nIdx = sServiceNameCC.indexOf( aOldNamePart1 );
  if (nIdx >= 0)
      sServiceNameCC = sServiceNameCC.replaceAt( nIdx, strlen(aOldNamePart1), ".textfield.docinfo." );
  nIdx = sServiceNameCC.indexOf( aOldNamePart2 );
  if (nIdx >= 0)
      sServiceNameCC = sServiceNameCC.replaceAt( nIdx, strlen(aOldNamePart2), ".textfield." );
  return sServiceNameCC;
2597}

2599sal_Bool SAL_CALL SwXTextField::supportsService(const OUString& rServiceName)
2600{
  return cppu::supportsService(this, rServiceName);
2602}

2604uno::Sequence< OUString > SAL_CALL SwXTextField::getSupportedServiceNames()
2605{
  const OUString sServiceName =
      SwXServiceProvider::GetProviderName(m_pImpl->m_nServiceId);

  // case-corrected version of service-name (see #i67811)
  // (need to supply both because of compatibility to older versions)
  const OUString sServiceNameCC(  OldNameToNewName_Impl( sServiceName ) );
  sal_Int32 nLen = sServiceName == sServiceNameCC ? 2 : 3;

  uno::Sequence< OUString > aRet( nLen );
  OUString* pArray = aRet.getArray();
  *pArray++ = sServiceName;
  if (nLen == 3)
      *pArray++ = sServiceNameCC;
  *pArray++ = "com.sun.star.text.TextContent";
  return aRet;
2621}

2623void SwXTextField::Impl::Invalidate()
2624{
  EndListeningAll();
  m_pFormatField = nullptr;
  m_pDoc = nullptr;
  uno::Reference<uno::XInterface> const xThis(m_wThis);
  if (!xThis.is())
  {   // fdo#72695: if UNO object is already dead, don't revive it with event
      return;
  }
  lang::EventObject const ev(xThis);
  m_EventListeners.disposeAndClear(ev);
2635}

2637void SwXTextField::Impl::Notify(const SfxHint& rHint)
2638{

  if(rHint.GetId() == SfxHintId::Dying)
      Invalidate();
  else if (auto pLegacyHint = dynamic_cast<const sw::LegacyModifyHint*>(&rHint))
  {
      switch(pLegacyHint->m_pOld ? pLegacyHint->m_pOld->Which() : 0)
      {
          case RES_REMOVE_UNO_OBJECT:
          case RES_OBJECTDYING:
              Invalidate();
              break;
      }
  }
2652}

2654const SwField* SwXTextField::Impl::GetField() const
2655{
  return m_pFormatField ? m_pFormatField->GetField() : nullptr;
2657}

2659OUString SwXTextFieldMasters::getImplementationName()
2660{
  return "SwXTextFieldMasters";
2662}

2664sal_Bool SwXTextFieldMasters::supportsService(const OUString& rServiceName)
2665{
  return cppu::supportsService(this, rServiceName);
2667}

2669uno::Sequence< OUString > SwXTextFieldMasters::getSupportedServiceNames()
2670{
  uno::Sequence<OUString> aRet { "com.sun.star.text.TextFieldMasters" };
  return aRet;
2673}

2675SwXTextFieldMasters::SwXTextFieldMasters(SwDoc* _pDoc) :
  SwUnoCollection(_pDoc)
2677{
2678}

2680SwXTextFieldMasters::~SwXTextFieldMasters()
2681{

2683}

2685/*
  Iteration over non-standard field types
  USER/SETEXP/DDE/DATABASE
  Thus the names are:
  "com.sun.star.text.fieldmaster.User" + <field type name>
  "com.sun.star.text.fieldmaster.DDE" + <field type name>
  "com.sun.star.text.fieldmaster.SetExpression" + <field type name>
  "com.sun.star.text.fieldmaster.DataBase" + <field type name>

  If too much, maybe one could leave out the "com.sun.star.text".
*/
2696static SwFieldIds lcl_GetIdByName( OUString& rName, OUString& rTypeName )
2697{
  if (rName.startsWithIgnoreAsciiCase(COM_TEXT_FLDMASTER_CC"com.sun.star.text.fieldmaster."))
      rName = rName.copy(RTL_CONSTASCII_LENGTH(COM_TEXT_FLDMASTER_CC)((sal_Int32)((sizeof(sal_n_array_size("com.sun.star.text.fieldmaster."
)))-1)));

  SwFieldIds nResId = SwFieldIds::Unknown;
  sal_Int32 nIdx = 0;
  rTypeName = rName.getToken( 0, '.', nIdx );
  if (rTypeName == "User")
      nResId = SwFieldIds::User;
  else if (rTypeName == "DDE")
      nResId = SwFieldIds::Dde;
  else if (rTypeName == "SetExpression")
  {
      nResId = SwFieldIds::SetExp;

      const OUString sFieldTypName( rName.getToken( 0, '.', nIdx ));
      const OUString sUIName( SwStyleNameMapper::GetSpecialExtraUIName( sFieldTypName ) );

      if( sUIName != sFieldTypName )
          rName = comphelper::string::setToken(rName, 1, '.', sUIName);
  }
  else if (rTypeName.equalsIgnoreAsciiCase("DataBase"))
  {
      rName = rName.copy(RTL_CONSTASCII_LENGTH("DataBase.")((sal_Int32)((sizeof(sal_n_array_size("DataBase.")))-1)));
      if (!rName.isEmpty())
      {
          // #i51815#
          rName = "DataBase." + rName;
          nResId = SwFieldIds::Database;
      }
  }
  else if (rTypeName == "Bibliography")
      nResId = SwFieldIds::TableOfAuthorities;
  return nResId;
2731}

2733uno::Any SwXTextFieldMasters::getByName(const OUString& rName)
2734{
  SolarMutexGuard aGuard;
  if(!GetDoc())
      throw uno::RuntimeException();

  OUString sName(rName), sTypeName;
  const SwFieldIds nResId = lcl_GetIdByName( sName, sTypeName );
  if( SwFieldIds::Unknown == nResId )
      throw container::NoSuchElementException(
          "SwXTextFieldMasters::getByName(" + rName + ")",
          css::uno::Reference<css::uno::XInterface>());

  sName = sName.copy(std::min(sTypeName.getLength()+1, sName.getLength()));
  SwFieldType* pType = GetDoc()->getIDocumentFieldsAccess().GetFieldType(nResId, sName, true);
  if(!pType)
      throw container::NoSuchElementException(
          "SwXTextFieldMasters::getByName(" + rName + ")",
          css::uno::Reference<css::uno::XInterface>());

  uno::Reference<beans::XPropertySet> const xRet(
          SwXFieldMaster::CreateXFieldMaster(GetDoc(), pType));
  return uno::makeAny(xRet);
2756}

2758bool SwXTextFieldMasters::getInstanceName(
  const SwFieldType& rFieldType, OUString& rName)
2760{
  OUString sField;

  switch( rFieldType.Which() )
  {
  case SwFieldIds::User:
      sField = "User." + rFieldType.GetName();
      break;
  case SwFieldIds::Dde:
      sField = "DDE." + rFieldType.GetName();
      break;

  case SwFieldIds::SetExp:
      sField = "SetExpression." + SwStyleNameMapper::GetSpecialExtraProgName( rFieldType.GetName() );
      break;

  case SwFieldIds::Database:
      sField = "DataBase." + rFieldType.GetName().replaceAll(OUStringChar(DB_DELIMu'\x00ff'), ".");
      break;

  case SwFieldIds::TableOfAuthorities:
      sField = "Bibliography";
      break;

  default:
      return false;
  }

  rName += COM_TEXT_FLDMASTER_CC"com.sun.star.text.fieldmaster." + sField;
  return true;
2790}

2792uno::Sequence< OUString > SwXTextFieldMasters::getElementNames()
2793{
  SolarMutexGuard aGuard;
  if(!GetDoc())
      throw uno::RuntimeException();

  const SwFieldTypes* pFieldTypes = GetDoc()->getIDocumentFieldsAccess().GetFieldTypes();
  const size_t nCount = pFieldTypes->size();

  std::vector<OUString> aFieldNames;
  for( size_t i = 0; i < nCount; ++i )
  {
      SwFieldType& rFieldType = *((*pFieldTypes)[i]);

      OUString sFieldName;
      if (SwXTextFieldMasters::getInstanceName(rFieldType, sFieldName))
      {
          aFieldNames.push_back(sFieldName);
      }
  }

  return comphelper::containerToSequence(aFieldNames);
2814}

2816sal_Bool SwXTextFieldMasters::hasByName(const OUString& rName)
2817{
  SolarMutexGuard aGuard;
  if(!GetDoc())
      throw uno::RuntimeException();

  OUString sName(rName), sTypeName;
  const SwFieldIds nResId = lcl_GetIdByName( sName, sTypeName );
  bool bRet = false;
  if( SwFieldIds::Unknown != nResId )
  {
      sName = sName.copy(std::min(sTypeName.getLength()+1, sName.getLength()));
      bRet = nullptr != GetDoc()->getIDocumentFieldsAccess().GetFieldType(nResId, sName, true);
  }
  return bRet;
2831}

2833uno::Type  SwXTextFieldMasters::getElementType()
2834{
  return cppu::UnoType<beans::XPropertySet>::get();

2837}

2839sal_Bool SwXTextFieldMasters::hasElements()
2840{
  SolarMutexGuard aGuard;
  if(!IsValid())
      throw uno::RuntimeException();
  return true;
2845}

2847class SwXTextFieldTypes::Impl
2848{
2849private:
  ::osl::Mutex m_Mutex; // just for OInterfaceContainerHelper2

2852public:
  ::comphelper::OInterfaceContainerHelper2 m_RefreshListeners;

  Impl() : m_RefreshListeners(m_Mutex) { }
2856};

2858OUString SwXTextFieldTypes::getImplementationName()
2859{
  return "SwXTextFieldTypes";
2861}

2863sal_Bool SwXTextFieldTypes::supportsService(const OUString& rServiceName)
2864{
  return cppu::supportsService(this, rServiceName);
2866}

2868uno::Sequence< OUString > SwXTextFieldTypes::getSupportedServiceNames()
2869{
  uno::Sequence<OUString> aRet { "com.sun.star.text.TextFields" };
  return aRet;
2872}

2874SwXTextFieldTypes::SwXTextFieldTypes(SwDoc* _pDoc)
  : SwUnoCollection (_pDoc)
  , m_pImpl(new Impl)
2877{
2878}

2880SwXTextFieldTypes::~SwXTextFieldTypes()
2881{
2882}

2884void SwXTextFieldTypes::Invalidate()
2885{
  SwUnoCollection::Invalidate();
  lang::EventObject const ev(static_cast< ::cppu::OWeakObject&>(*this));
  m_pImpl->m_RefreshListeners.disposeAndClear(ev);
2889}

2891uno::Reference< container::XEnumeration >  SwXTextFieldTypes::createEnumeration()
2892{
  SolarMutexGuard aGuard;
  if(!IsValid())
      throw uno::RuntimeException();
  return new SwXFieldEnumeration(*GetDoc());
2897}

2899uno::Type  SwXTextFieldTypes::getElementType()
2900{
  return cppu::UnoType<text::XDependentTextField>::get();
2902}

2904sal_Bool SwXTextFieldTypes::hasElements()
2905{
  SolarMutexGuard aGuard;
  if(!IsValid())
      throw uno::RuntimeException();
  return true; // they always exist
2910}

2912void SAL_CALL SwXTextFieldTypes::refresh()
2913{
  {
      SolarMutexGuard aGuard;
      if (!IsValid())
          throw uno::RuntimeException();
      UnoActionContext aContext(GetDoc());
      GetDoc()->getIDocumentStatistics().UpdateDocStat( false, true );
      GetDoc()->getIDocumentFieldsAccess().UpdateFields(false);
  }
  // call refresh listeners (without SolarMutex locked)
  lang::EventObject const event(static_cast< ::cppu::OWeakObject*>(this));
  m_pImpl->m_RefreshListeners.notifyEach(
          & util::XRefreshListener::refreshed, event);
2926}

2928void SAL_CALL SwXTextFieldTypes::addRefreshListener(
      const uno::Reference<util::XRefreshListener> & xListener)
2930{
  // no need to lock here as m_pImpl is const and container threadsafe
  m_pImpl->m_RefreshListeners.addInterface(xListener);
2933}

2935void SAL_CALL SwXTextFieldTypes::removeRefreshListener(
      const uno::Reference<util::XRefreshListener> & xListener)
2937{
  // no need to lock here as m_pImpl is const and container threadsafe
  m_pImpl->m_RefreshListeners.removeInterface(xListener);
2940}

2942class SwXFieldEnumeration::Impl
  : public SvtListener
2944{
2945public:
  SwDoc* m_pDoc;
  std::vector<uno::Reference<text::XTextField>> m_Items;
  sal_Int32 m_nNextIndex;  ///< index of next element to be returned

  explicit Impl(SwDoc& rDoc)
      : m_pDoc(&rDoc)
      , m_nNextIndex(0)
  {
      StartListening(rDoc.getIDocumentStylePoolAccess().GetPageDescFromPool(RES_POOLPAGE_STANDARD)->GetNotifier());
  }

  virtual void Notify(const SfxHint& rHint) override
  {
      if(rHint.GetId() == SfxHintId::Dying)
          m_pDoc = nullptr;
  }
2962};

2964OUString SAL_CALL
2965SwXFieldEnumeration::getImplementationName()
2966{
  return "SwXFieldEnumeration";
2968}

2970sal_Bool SAL_CALL SwXFieldEnumeration::supportsService(const OUString& rServiceName)
2971{
  return cppu::supportsService(this, rServiceName);
2973}

2975uno::Sequence<OUString> SAL_CALL
2976SwXFieldEnumeration::getSupportedServiceNames()
2977{
  return { "com.sun.star.text.FieldEnumeration" };
2979}

2981SwXFieldEnumeration::SwXFieldEnumeration(SwDoc & rDoc)
  : m_pImpl(new Impl(rDoc))
2983{
  // build sequence
  m_pImpl->m_Items.clear();

  const SwFieldTypes* pFieldTypes = m_pImpl->m_pDoc->getIDocumentFieldsAccess().GetFieldTypes();
  const size_t nCount = pFieldTypes->size();
  for(size_t nType = 0;  nType < nCount;  ++nType)
  {
      const SwFieldType* pCurType = (*pFieldTypes)[nType].get();
      std::vector<SwFormatField*> vFormatFields;
      pCurType->GatherFields(vFormatFields);
      std::for_each(vFormatFields.begin(), vFormatFields.end(),
              [this](SwFormatField* pF) { m_pImpl->m_Items.push_back(SwXTextField::CreateXTextField(m_pImpl->m_pDoc, pF)); });
  }
  // now handle meta-fields, which are not SwFields
  const std::vector< uno::Reference<text::XTextField> > MetaFields(
         m_pImpl->m_pDoc->GetMetaFieldManager().getMetaFields() );
  for (const auto & rMetaField : MetaFields)
  {
      m_pImpl->m_Items.push_back( rMetaField );
  }
3004}

3006SwXFieldEnumeration::~SwXFieldEnumeration()
3007{
3008}

3010sal_Bool SAL_CALL SwXFieldEnumeration::hasMoreElements()
3011{
  SolarMutexGuard aGuard;

  return m_pImpl->m_nNextIndex < static_cast<sal_Int32>(m_pImpl->m_Items.size());
3015}

3017uno::Any SAL_CALL SwXFieldEnumeration::nextElement()
3018{
  SolarMutexGuard aGuard;

  if (m_pImpl->m_nNextIndex >= static_cast<sal_Int32>(m_pImpl->m_Items.size()))
      throw container::NoSuchElementException(
          "SwXFieldEnumeration::nextElement",
          css::uno::Reference<css::uno::XInterface>());

  uno::Reference< text::XTextField >  &rxField =
      m_pImpl->m_Items[ m_pImpl->m_nNextIndex++ ];
  uno::Any aRet;
  aRet <<= rxField;
  rxField = nullptr;  // free memory for item that is no longer used
  return aRet;
3032}

3034/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

←

/home/maarten/src/libreoffice/core/include/com/sun/star/uno/Reference.h

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
*   Licensed to the Apache Software Foundation (ASF) under one or more
*   contributor license agreements. See the NOTICE file distributed
*   with this work for additional information regarding copyright
*   ownership. The ASF licenses this file to you under the Apache
*   License, Version 2.0 (the "License"); you may not use this file
*   except in compliance with the License. You may obtain a copy of
*   the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
19#ifndef INCLUDED_COM_SUN_STAR_UNO_REFERENCE_H
20#define INCLUDED_COM_SUN_STAR_UNO_REFERENCE_H

22#include "sal/config.h"

24#include <cassert>
25#include <cstddef>

27#if defined LIBO_INTERNAL_ONLY1
28#include <type_traits>
29#endif

31#include "rtl/alloc.h"

33namespace com
34{
35namespace sun
36{
37namespace star
38{
39namespace uno
40{

42class RuntimeException;
43class XInterface;
44class Type;
45class Any;

47/** Enum defining UNO_REF_NO_ACQUIRE for setting reference without acquiring a given interface.
  Deprecated, please use SAL_NO_ACQUIRE.
  @deprecated
50*/
51enum UnoReference_NoAcquire
52{
  /** This enum value can be used for creating a reference granting a given interface,
      i.e. transferring ownership to it.
  */
  UNO_REF_NO_ACQUIRE
57};

59/** This base class serves as a base class for all template reference classes and
  has been introduced due to compiler problems with templated operators ==, =!.
61*/
62class BaseReference
63{
64protected:
  /** the interface pointer
  */
  XInterface * _pInterface;

  /** Queries given interface for type rType.

      @param pInterface interface pointer
      @param rType interface type
      @return interface of demanded type (may be null)
  */
  inline static XInterface * SAL_CALL iquery( XInterface * pInterface, const Type & rType );
  /** Queries given interface for type rType.
      Throws a RuntimeException if the demanded interface cannot be queried.

      @param pInterface interface pointer
      @param rType interface type
      @return interface of demanded type
  */
  inline static XInterface * SAL_CALL iquery_throw( XInterface * pInterface, const Type & rType );

85public:
  /** Gets interface pointer. This call does not acquire the interface.

      @return UNacquired interface pointer
  */
  XInterface * SAL_CALL get() const
      { return _pInterface; }

  /** Checks if reference is null.

      @return true if reference acquires an interface, i.e. true if it is not null
  */
  bool SAL_CALL is() const
      { return (NULL__null != _pInterface); }
5
←
Assuming NULL is not equal to field '_pInterface'→
6
←
Returning the value 1, which participates in a condition later→
29
←
Returning the value 1, which participates in a condition later→

100#if defined LIBO_INTERNAL_ONLY1
  /** Checks if reference is null.

      @return true if reference acquires an interface, i.e. true if it is not null
  */
  explicit operator bool() const
      { return is(); }
107#endif

  /** Equality operator: compares two interfaces
      Checks if both references are null or refer to the same object.

      @param pInterface another interface
      @return true if both references are null or refer to the same object, false otherwise
  */
  inline bool SAL_CALL operator == ( XInterface * pInterface ) const;
  /** Inequality operator: compares two interfaces
      Checks if both references are null or refer to the same object.

      @param pInterface another interface
      @return false if both references are null or refer to the same object, true otherwise
  */
  inline bool SAL_CALL operator != ( XInterface * pInterface ) const;

  /** Equality operator: compares two interfaces
      Checks if both references are null or refer to the same object.

      @param rRef another reference
      @return true if both references are null or refer to the same object, false otherwise
  */
  inline bool SAL_CALL operator == ( const BaseReference & rRef ) const;
  /** Inequality operator: compares two interfaces
      Checks if both references are null or refer to the same object.

      @param rRef another reference
      @return false if both references are null or refer to the same object, true otherwise
  */
  inline bool SAL_CALL operator != ( const BaseReference & rRef ) const;

  /** Needed by some STL containers.

      @param rRef another reference
      @return true, if this reference is less than rRef
  */
  inline bool SAL_CALL operator < ( const BaseReference & rRef ) const;
145};

147/** Enum defining UNO_QUERY for implicit interface query.
148*/
149enum UnoReference_Query
150{
  /** This enum value can be used for implicit interface query.
  */
  UNO_QUERY
154};
155/** Enum defining UNO_QUERY_THROW for implicit interface query.
  If the demanded interface is unavailable, then a RuntimeException is thrown.
157*/
158enum UnoReference_QueryThrow
159{
  /** This enum value can be used for implicit interface query.
  */
  UNO_QUERY_THROW
163};
164/** Enum defining UNO_SET_THROW for throwing if attempts are made to assign a null
  interface

  @since UDK 3.2.8
168*/
169enum UnoReference_SetThrow
170{
  UNO_SET_THROW
172};

174/** Template reference class for interface type derived from BaseReference.
  A special constructor given the UNO_QUERY identifier queries interfaces
  for reference type.
177*/
178template< class interface_type >
179class SAL_DLLPUBLIC_RTTI__attribute__ ((type_visibility("default"))) Reference : public BaseReference
180{
  /** Queries given interface for type interface_type.

      @param pInterface interface pointer
      @return interface of demanded type (may be null)
  */
  inline static XInterface * SAL_CALL iquery( XInterface * pInterface );
  /** Queries given interface for type interface_type.
      Throws a RuntimeException if the demanded interface cannot be queried.

      @param pInterface interface pointer
      @return interface of demanded type
  */
  inline static XInterface * SAL_CALL iquery_throw( XInterface * pInterface );
  /** Returns the given interface if it is not <NULL/>, throws a RuntimeException otherwise.

      @param pInterface interface pointer
      @return pInterface
  */
  inline static interface_type * SAL_CALL iset_throw( interface_type * pInterface );

  /** Cast from an "interface pointer" (e.g., BaseReference::_pInterface) to a
      pointer to this interface_type.

      To work around ambiguities in the case of multiple-inheritance interface
      types (which inherit XInterface more than once), use reinterpret_cast
      (resp. a sequence of two static_casts, to avoid warnings about
      reinterpret_cast used between related classes) to switch from a pointer
      to XInterface to a pointer to this derived interface_type.  In
      principle, this is not guaranteed to work.  In practice, it seems to
      work on all supported platforms.
  */
  static interface_type * castFromXInterface(XInterface * p) {
      return static_cast< interface_type * >(static_cast< void * >(p));
  }

  /** Cast from a pointer to this interface_type to an "interface pointer"
      (e.g., BaseReference::_pInterface).

      To work around ambiguities in the case of multiple-inheritance interface
      types (which inherit XInterface more than once), use reinterpret_cast
      (resp. a sequence of two static_casts, to avoid warnings about
      reinterpret_cast used between related classes) to switch from a pointer
      to this derived interface_type to a pointer to XInterface.  In
      principle, this is not guaranteed to work.  In practice, it seems to
      work on all supported platforms.
  */
  static XInterface * castToXInterface(interface_type * p) {
      return static_cast< XInterface * >(static_cast< void * >(p));
  }

231public:
  /// @cond INTERNAL
  // these are here to force memory de/allocation to sal lib.
  static void * SAL_CALL operator new ( ::size_t nSize )
      { return ::rtl_allocateMemory( nSize ); }
  static void SAL_CALL operator delete ( void * pMem )
      { ::rtl_freeMemory( pMem ); }
  static void * SAL_CALL operator new ( ::size_t, void * pMem )
      { return pMem; }
  static void SAL_CALL operator delete ( void *, void * )
      {}
  /// @endcond

  /** Destructor: Releases interface if set.
  */
  inline ~Reference() COVERITY_NOEXCEPT_FALSE;

  /** Default Constructor: Sets null reference.
  */
  inline Reference();

  /** Copy constructor: Copies interface reference.

      @param rRef another reference
  */
  inline Reference( const Reference< interface_type > & rRef );

258#if defined LIBO_INTERNAL_ONLY1
  /** Move constructor

      @param rRef another reference
  */
  inline Reference( Reference< interface_type > && rRef ) noexcept;

  /** Up-casting conversion constructor: Copies interface reference.

      Does not work for up-casts to ambiguous bases.  For the special case of
      up-casting to Reference< XInterface >, see the corresponding conversion
      operator.

      @param rRef another reference
  */
  template< class derived_type >
  inline Reference(
      const Reference< derived_type > & rRef,
      std::enable_if_t<
          std::is_base_of_v<interface_type, derived_type>
          && !std::is_same_v<interface_type, XInterface>, void *> = nullptr);
279#endif

  /** Constructor: Sets given interface pointer.

      @param pInterface an interface pointer
  */
  inline Reference( interface_type * pInterface );

  /** Constructor: Sets given interface pointer without acquiring it.

      @param pInterface another reference
      @param dummy SAL_NO_ACQUIRE to force obvious distinction to other constructors
  */
  inline Reference( interface_type * pInterface, __sal_NoAcquire dummy);
  /** Constructor: Sets given interface pointer without acquiring it.
      Deprecated, please use SAL_NO_ACQUIRE version.

      @deprecated
      @param pInterface another reference
      @param dummy UNO_REF_NO_ACQUIRE to force obvious distinction to other constructors
  */
  inline SAL_DEPRECATED("use SAL_NO_ACQUIRE version")__attribute__((deprecated("use SAL_NO_ACQUIRE version"))) Reference( interface_type * pInterface, UnoReference_NoAcquire dummy );

  /** Constructor: Queries given interface for reference interface type (interface_type).

      @param rRef another reference
      @param dummy UNO_QUERY to force obvious distinction to other constructors
  */
  inline Reference( const BaseReference & rRef, UnoReference_Query dummy );
  /** Constructor: Queries given interface for reference interface type (interface_type).

      @param pInterface an interface pointer
      @param dummy UNO_QUERY to force obvious distinction to other constructors
  */
  inline Reference( XInterface * pInterface, UnoReference_Query dummy);
  /** Constructor: Queries given any for reference interface type (interface_type).

      @param rAny an any
      @param dummy UNO_QUERY to force obvious distinction to other constructors
  */
  inline Reference( const Any & rAny, UnoReference_Query dummy);
  /** Constructor: Queries given interface for reference interface type (interface_type).
      Throws a RuntimeException if the demanded interface cannot be queried.

      @param rRef another reference
      @param dummy UNO_QUERY_THROW to force obvious distinction
                   to other constructors
  */
  inline Reference( const BaseReference & rRef, UnoReference_QueryThrow dummy );
328#ifdef LIBO_INTERNAL_ONLY1
  /**
      Prevent code from calling the QUERY_THROW constructor, when they meant to use the SET_THROW constructor.
  */
  Reference( const Reference< interface_type > & rRef, UnoReference_QueryThrow dummy ) = delete;
333#endif
  /** Constructor: Queries given interface for reference interface type (interface_type).
      Throws a RuntimeException if the demanded interface cannot be queried.

      @param pInterface an interface pointer
      @param dummy UNO_QUERY_THROW to force obvious distinction
                   to other constructors
  */
  inline Reference( XInterface * pInterface, UnoReference_QueryThrow dummy );
  /** Constructor: Queries given any for reference interface type (interface_type).
      Throws a RuntimeException if the demanded interface cannot be queried.

      @param rAny an any
      @param dummy UNO_QUERY_THROW to force obvious distinction
                   to other constructors
  */
  inline Reference( const Any & rAny, UnoReference_QueryThrow dummy );
  /** Constructor: assigns from the given interface of the same type. Throws a RuntimeException
      if the source interface is NULL.

      @param rRef another interface reference of the same type
      @param dummy UNO_SET_THROW to distinguish from default copy constructor

      @since UDK 3.2.8
  */
  inline Reference( const Reference< interface_type > & rRef, UnoReference_SetThrow dummy );
  /** Constructor: assigns from the given interface of the same type. Throws a RuntimeException
      if the source interface is NULL.

      @param pInterface an interface pointer
      @param dummy UNO_SET_THROW to distinguish from default assignment constructor

      @since UDK 3.2.8
  */
  inline Reference( interface_type * pInterface, UnoReference_SetThrow dummy );

  /** Cast operator to Reference< XInterface >: Reference objects are binary compatible and
      any interface must be derived from com.sun.star.uno.XInterface.
      This a useful direct cast possibility.
  */
  SAL_CALL operator const Reference< XInterface > & () const
      { return * reinterpret_cast< const Reference< XInterface > * >( this ); }

  /** Dereference operator: Used to call interface methods.

      @return UNacquired interface pointer
  */
  interface_type * SAL_CALL operator -> () const {
      assert(_pInterface != NULL)(static_cast <bool> (_pInterface != __null) ? void (0) :
 __assert_fail ("_pInterface != NULL", "/home/maarten/src/libreoffice/core/include/com/sun/star/uno/Reference.h"
, 381, __extension__ __PRETTY_FUNCTION__));
      return castFromXInterface(_pInterface);
  }

  /** Indirection operator.

      @since LibreOffice 6.3
      @return UNacquired interface reference
  */
  interface_type & SAL_CALL operator * () const {
      assert(_pInterface != NULL)(static_cast <bool> (_pInterface != __null) ? void (0) :
 __assert_fail ("_pInterface != NULL", "/home/maarten/src/libreoffice/core/include/com/sun/star/uno/Reference.h"
, 391, __extension__ __PRETTY_FUNCTION__));
      return *castFromXInterface(_pInterface);
  }

  /** Gets interface pointer. This call does not acquire the interface.

      @return UNacquired interface pointer
  */
  interface_type * SAL_CALL get() const
      { return castFromXInterface(_pInterface); }

  /** Clears reference, i.e. releases interface. Reference is null after clear() call.
  */
  inline void SAL_CALL clear();

  /** Sets the given interface. An interface already set will be released.

      @param rRef another reference
      @return true, if non-null interface was set
  */
  inline bool SAL_CALL set( const Reference< interface_type > & rRef );
  /** Sets the given interface. An interface already set will be released.

      @param pInterface another interface
      @return true, if non-null interface was set
  */
  inline bool SAL_CALL set( interface_type * pInterface );

  /** Sets interface pointer without acquiring it. An interface already set will be released.

      @param pInterface an interface pointer
      @param dummy SAL_NO_ACQUIRE to force obvious distinction to set methods
      @return true, if non-null interface was set
  */
  inline bool SAL_CALL set( interface_type * pInterface, __sal_NoAcquire dummy);
  /** Sets interface pointer without acquiring it. An interface already set will be released.
      Deprecated, please use SAL_NO_ACQUIRE version.

      @deprecated
      @param pInterface an interface pointer
      @param dummy UNO_REF_NO_ACQUIRE to force obvious distinction to set methods
      @return true, if non-null interface was set
  */
  inline SAL_DEPRECATED("use SAL_NO_ACQUIRE version")__attribute__((deprecated("use SAL_NO_ACQUIRE version"))) bool SAL_CALL set( interface_type * pInterface, UnoReference_NoAcquire dummy);

  /** Queries given interface for reference interface type (interface_type) and sets it.
      An interface already set will be released.

      @param pInterface an interface pointer
      @param dummy UNO_QUERY to force obvious distinction to set methods
      @return true, if non-null interface was set
  */
  inline bool SAL_CALL set( XInterface * pInterface, UnoReference_Query dummy );
  /** Queries given interface for reference interface type (interface_type) and sets it.
      An interface already set will be released.

      @param rRef another reference
      @param dummy UNO_QUERY to force obvious distinction to set methods
      @return true, if non-null interface was set
  */
  inline bool SAL_CALL set( const BaseReference & rRef, UnoReference_Query dummy);

  /** Queries given any for reference interface type (interface_type)
      and sets it.  An interface already set will be released.

      @param rAny
             an Any containing an interface
      @param dummy
             UNO_QUERY to force obvious distinction
             to set methods
      @return
              true, if non-null interface was set
  */
  inline bool set( Any const & rAny, UnoReference_Query dummy );

  /** Queries given interface for reference interface type (interface_type) and sets it.
      An interface already set will be released.
      Throws a RuntimeException if the demanded interface cannot be set.

      @param pInterface an interface pointer
      @param dummy UNO_QUERY_THROW to force obvious distinction
                   to set methods
  */
  inline void SAL_CALL set( XInterface * pInterface, UnoReference_QueryThrow dummy );
  /** Queries given interface for reference interface type (interface_type) and sets it.
      An interface already set will be released.
      Throws a RuntimeException if the demanded interface cannot be set.

      @param rRef another reference
      @param dummy UNO_QUERY_THROW to force obvious distinction
             to set methods
  */
  inline void SAL_CALL set( const BaseReference & rRef, UnoReference_QueryThrow dummy );
484#ifdef LIBO_INTERNAL_ONLY1
  /**
      Prevent code from calling the QUERY_THROW version, when they meant to use the SET_THROW version.
  */
  void set( const Reference< interface_type > & rRef, UnoReference_QueryThrow dummy ) = delete;
489#endif

  /** Queries given any for reference interface type (interface_type) and
      sets it.  An interface already set will be released.
      Throws a RuntimeException if the demanded interface cannot be set.

      @param rAny
             an Any containing an interface
      @param dummy
             UNO_QUERY_THROW to force obvious distinction to set methods
  */
  inline void set( Any const & rAny, UnoReference_QueryThrow dummy);
  /** sets the given interface
      An interface already set will be released.
      Throws a RuntimeException if the source interface is @b NULL.

      @param pInterface an interface pointer
      @param dummy UNO_SET_THROW to force obvious distinction to other set methods

      @since UDK 3.2.8
  */
  inline void SAL_CALL set( interface_type * pInterface, UnoReference_SetThrow dummy);
  /** sets the given interface
      An interface already set will be released.
      Throws a RuntimeException if the source interface is @b NULL.

      @param rRef an interface reference
      @param dummy UNO_SET_THROW to force obvious distinction to other set methods

      @since UDK 3.2.8
  */
  inline void SAL_CALL set( const Reference< interface_type > & rRef, UnoReference_SetThrow dummy);


  /** Assignment operator: Acquires given interface pointer and sets reference.
      An interface already set will be released.

      @param pInterface an interface pointer
      @return this reference
  */
  inline Reference< interface_type > & SAL_CALL operator = ( interface_type * pInterface );
  /** Assignment operator: Acquires given interface reference and sets reference.
      An interface already set will be released.

      @param rRef an interface reference
      @return this reference
  */
  inline Reference< interface_type > & SAL_CALL operator = ( const Reference< interface_type > & rRef );
537#if defined LIBO_INTERNAL_ONLY1
  /** Assignment move operator: Acquires given interface reference and sets reference.
      An interface already set will be released.

      @param rRef an interface reference
      @return this reference
  */
  inline Reference< interface_type > & SAL_CALL operator = ( Reference< interface_type > && rRef ) noexcept;
545#endif
  /** Queries given interface reference for type interface_type.

      @param rRef interface reference
      @return interface reference of demanded type (may be null)
  */
  SAL_WARN_UNUSED_RESULT[[nodiscard]] inline static Reference< interface_type > SAL_CALL query( const BaseReference & rRef );
  /** Queries given interface for type interface_type.

      @param pInterface interface pointer
      @return interface reference of demanded type (may be null)
  */
  SAL_WARN_UNUSED_RESULT[[nodiscard]] inline static Reference< interface_type > SAL_CALL query( XInterface * pInterface );
558};

560}
561}
562}
563}

565#endif

567/* vim:set shiftwidth=4 softtabstop=4 expandtab: */