?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
docthemes: Save themes def. to a file when added to ColorSets
[LibreOffice.git] / sw / source / uibase / fldui / fldmgr.cxx
blob7d4d4e251b671edd6dc2285a01509661e562770c
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20 #include <config_features.h>
21 #include <config_fuzzers.h>
22
23 #include <cmdid.h>
24 #include <hintids.hxx>
25 #include <svl/numformat.hxx>
26 #include <svl/stritem.hxx>
27 #include <com/sun/star/text/DefaultNumberingProvider.hpp>
28 #include <com/sun/star/text/XDefaultNumberingProvider.hpp>
29 #include <com/sun/star/text/XNumberingTypeInfo.hpp>
30 #include <com/sun/star/style/NumberingType.hpp>
31 #include <com/sun/star/beans/XPropertySet.hpp>
32 #include <com/sun/star/sdbc/XConnection.hpp>
33 #include <com/sun/star/sdbc/XDataSource.hpp>
34 #include <com/sun/star/uri/UriReferenceFactory.hpp>
35 #include <com/sun/star/uri/XVndSunStarScriptUrl.hpp>
36 #include <comphelper/processfactory.hxx>
37 #include <comphelper/string.hxx>
38 #include <o3tl/string_view.hxx>
39 #include <tools/resary.hxx>
40 #include <osl/diagnose.h>
41 #include <sfx2/dispatch.hxx>
42 #include <sfx2/linkmgr.hxx>
43 #include <sfx2/app.hxx>
44 #include <sfx2/viewfrm.hxx>
45 #include <svx/strarray.hxx>
46 #include <fmtrfmrk.hxx>
47 #include <svl/zforlist.hxx>
48 #include <svl/zformat.hxx>
49 #include <vcl/mnemonic.hxx>
50 #include <view.hxx>
51 #include <wrtsh.hxx>
52 #include <doc.hxx>
53 #include <swmodule.hxx>
54 #include <fmtinfmt.hxx>
55 #include <cellatr.hxx>
56 #include <dbmgr.hxx>
57 #include <shellres.hxx>
58 #include <fldbas.hxx>
59 #include <docufld.hxx>
60 #include <chpfld.hxx>
61 #include <ddefld.hxx>
62 #include <expfld.hxx>
63 #include <reffld.hxx>
64 #include <usrfld.hxx>
65 #include <dbfld.hxx>
66 #include <authfld.hxx>
67 #include <flddat.hxx>
68 #include <fldmgr.hxx>
69 #include <ndtxt.hxx>
70 #include <cntfrm.hxx>
71 #include <flddropdown.hxx>
72 #include <strings.hrc>
73 #include <tox.hxx>
74 #include <viewopt.hxx>
75 #include <txmsrt.hxx>
76 #include <unotools/useroptions.hxx>
77 #include <IDocumentContentOperations.hxx>
78 #include <translatehelper.hxx>
79
80 using namespace com::sun::star::uno;
81 using namespace com::sun::star::container;
82 using namespace com::sun::star::beans;
83 using namespace com::sun::star::text;
84 using namespace com::sun::star::style;
85 using namespace com::sun::star::sdbc;
86 using namespace ::com::sun::star;
87 using namespace nsSwDocInfoSubType;
88
89 // groups of fields
90 enum
91 {
92 GRP_DOC_BEGIN = 0,
93 GRP_DOC_END = GRP_DOC_BEGIN + 12,
94
95 GRP_FKT_BEGIN = GRP_DOC_END,
96 GRP_FKT_END = GRP_FKT_BEGIN + 8,
97
98 GRP_REF_BEGIN = GRP_FKT_END,
99 GRP_REF_END = GRP_REF_BEGIN + 2,
100
101 GRP_REG_BEGIN = GRP_REF_END,
102 GRP_REG_END = GRP_REG_BEGIN + 1,
103
104 GRP_DB_BEGIN = GRP_REG_END,
105 GRP_DB_END = GRP_DB_BEGIN + 5,
106
107 GRP_VAR_BEGIN = GRP_DB_END,
108 GRP_VAR_END = GRP_VAR_BEGIN + 9
109 };
110
111 enum
112 {
113 GRP_WEB_DOC_BEGIN = 0,
114 GRP_WEB_DOC_END = GRP_WEB_DOC_BEGIN + 9,
115
116 GRP_WEB_FKT_BEGIN = GRP_WEB_DOC_END + 2,
117 GRP_WEB_FKT_END = GRP_WEB_FKT_BEGIN + 0, // the group is empty!
118
119 GRP_WEB_REF_BEGIN = GRP_WEB_FKT_END + 6, // the group is empty!
120 GRP_WEB_REF_END = GRP_WEB_REF_BEGIN + 0,
121
122 GRP_WEB_REG_BEGIN = GRP_WEB_REF_END + 2,
123 GRP_WEB_REG_END = GRP_WEB_REG_BEGIN + 1,
124
125 GRP_WEB_DB_BEGIN = GRP_WEB_REG_END, // the group is empty!
126 GRP_WEB_DB_END = GRP_WEB_DB_BEGIN + 0,
127
128 GRP_WEB_VAR_BEGIN = GRP_WEB_DB_END + 5,
129 GRP_WEB_VAR_END = GRP_WEB_VAR_BEGIN + 1
130 };
131
132 const sal_uInt16 VF_COUNT = 1; // { 0 }
133 const sal_uInt16 VF_USR_COUNT = 2; // { 0, nsSwExtendedSubType::SUB_CMD }
134 const sal_uInt16 VF_DB_COUNT = 1; // { nsSwExtendedSubType::SUB_OWN_FMT }
135
136 const TranslateId FLD_EU_ARY[] =
137 {
138 FLD_EU_COMPANY,
139 FLD_EU_GIVENNAME,
140 FLD_EU_SURNAME,
141 FLD_EU_INITIALS,
142 FLD_EU_STREET,
143 FLD_EU_COUNTRY,
144 FLD_EU_POSTCODE,
145 FLD_EU_TOWN,
146 FLD_EU_TITLE,
147 FLD_EU_POS,
148 FLD_EU_TELPERSONAL,
149 FLD_EU_TELWORK,
150 FLD_EU_FAX,
151 FLD_EU_EMAIL,
152 FLD_EU_REGION
153 };
154
155 const TranslateId FMT_AUTHOR_ARY[] =
156 {
157 FMT_AUTHOR_NAME,
158 FMT_AUTHOR_SCUT
159 };
160
161 const TranslateId FLD_DATE_ARY[] =
162 {
163 FLD_DATE_FIX,
164 FLD_DATE_STD,
165 };
166
167 const TranslateId FLD_TIME_ARY[] =
168 {
169 FLD_TIME_FIX,
170 FLD_TIME_STD
171 };
172
173 const TranslateId FMT_NUM_ARY[] =
174 {
175 FMT_NUM_ABC,
176 FMT_NUM_SABC,
177 FMT_NUM_ABC_N,
178 FMT_NUM_SABC_N,
179 FMT_NUM_ROMAN,
180 FMT_NUM_SROMAN,
181 FMT_NUM_ARABIC,
182 FMT_NUM_PAGEDESC,
183 FMT_NUM_PAGESPECIAL
184 };
185
186 const TranslateId FMT_FF_ARY[] =
187 {
188 FMT_FF_NAME,
189 FMT_FF_PATHNAME,
190 FMT_FF_PATH,
191 FMT_FF_NAME_NOEXT,
192 FMT_FF_UI_NAME,
193 FMT_FF_UI_RANGE
194 };
195
196 const TranslateId FLD_STAT_ARY[] =
197 {
198 FLD_STAT_PAGE,
199 FLD_STAT_PARA,
200 FLD_STAT_WORD,
201 FLD_STAT_CHAR,
202 FLD_STAT_TABLE,
203 FLD_STAT_GRF,
204 FLD_STAT_OBJ
205 };
206
207 const TranslateId FMT_CHAPTER_ARY[] =
208 {
209 FMT_CHAPTER_NO,
210 FMT_CHAPTER_NAME,
211 FMT_CHAPTER_NAMENO,
212 FMT_CHAPTER_NO_NOSEPARATOR
213 };
214
215 const TranslateId FLD_INPUT_ARY[] =
216 {
217 FLD_INPUT_TEXT
218 };
219
220 const TranslateId FMT_MARK_ARY[] =
221 {
222 FMT_MARK_TEXT,
223 FMT_MARK_TABLE,
224 FMT_MARK_FRAME,
225 FMT_MARK_GRAFIC,
226 FMT_MARK_OLE
227 };
228
229 const TranslateId FMT_REF_ARY[] =
230 {
231 FMT_REF_PAGE,
232 FMT_REF_CHAPTER,
233 FMT_REF_TEXT,
234 FMT_REF_UPDOWN,
235 FMT_REF_PAGE_PGDSC,
236 FMT_REF_ONLYNUMBER,
237 FMT_REF_ONLYCAPTION,
238 FMT_REF_ONLYSEQNO,
239 FMT_REF_NUMBER,
240 FMT_REF_NUMBER_NO_CONTEXT,
241 FMT_REF_NUMBER_FULL_CONTEXT
242 };
243
244 const TranslateId FMT_REG_ARY[] =
245 {
246 FMT_REG_AUTHOR,
247 FMT_REG_TIME,
248 FMT_REG_DATE
249 };
250
251 const TranslateId FMT_DBFLD_ARY[] =
252 {
253 FMT_DBFLD_DB,
254 FMT_DBFLD_SYS
255 };
256
257 const TranslateId FMT_SETVAR_ARY[] =
258 {
259 FMT_SETVAR_SYS,
260 FMT_SETVAR_TEXT
261 };
262
263 const TranslateId FMT_GETVAR_ARY[] =
264 {
265 FMT_GETVAR_TEXT,
266 FMT_GETVAR_NAME
267 };
268
269 const TranslateId FMT_DDE_ARY[] =
270 {
271 FMT_DDE_NORMAL,
272 FMT_DDE_HOT
273 };
274
275 const TranslateId FLD_PAGEREF_ARY[] =
276 {
277 FLD_PAGEREF_OFF,
278 FLD_PAGEREF_ON
279 };
280
281 const TranslateId FMT_USERVAR_ARY[] =
282 {
283 FMT_USERVAR_TEXT,
284 FMT_USERVAR_CMD
285 };
286
287 namespace {
288
289 // field types and subtypes
290 struct SwFieldPack
291 {
292 SwFieldTypesEnum nTypeId;
293
294 const TranslateId* pSubTypeResIds;
295 size_t nSubTypeLength;
296
297 const TranslateId* pFormatResIds;
298 size_t nFormatLength;
299 };
300
301 }
302
303 // strings and formats
304 const SwFieldPack aSwFields[] =
305 {
306 // Document
307 { SwFieldTypesEnum::ExtendedUser, FLD_EU_ARY, std::size(FLD_EU_ARY), nullptr, 0 },
308 { SwFieldTypesEnum::Author, nullptr, 0, FMT_AUTHOR_ARY, std::size(FMT_AUTHOR_ARY) },
309 { SwFieldTypesEnum::Date, FLD_DATE_ARY, std::size(FLD_DATE_ARY), nullptr, 0 },
310 { SwFieldTypesEnum::Time, FLD_TIME_ARY, std::size(FLD_TIME_ARY), nullptr, 0 },
311 { SwFieldTypesEnum::PageNumber, nullptr, 0, FMT_NUM_ARY, std::size(FMT_NUM_ARY) -1 },
312 { SwFieldTypesEnum::NextPage, nullptr, 0, FMT_NUM_ARY, std::size(FMT_NUM_ARY) },
313 { SwFieldTypesEnum::PreviousPage, nullptr, 0, FMT_NUM_ARY, std::size(FMT_NUM_ARY) },
314 { SwFieldTypesEnum::Filename, nullptr, 0, FMT_FF_ARY, std::size(FMT_FF_ARY) },
315 { SwFieldTypesEnum::DocumentStatistics, FLD_STAT_ARY, std::size(FLD_STAT_ARY), FMT_NUM_ARY, std::size(FMT_NUM_ARY) -1 },
316
317 { SwFieldTypesEnum::Chapter, nullptr, 0, FMT_CHAPTER_ARY, std::size(FMT_CHAPTER_ARY) },
318 { SwFieldTypesEnum::TemplateName, nullptr, 0, FMT_FF_ARY, std::size(FMT_FF_ARY) },
319 { SwFieldTypesEnum::ParagraphSignature, nullptr, 0, nullptr, 0 },
320
321 // Functions
322 { SwFieldTypesEnum::ConditionalText, nullptr, 0, nullptr, 0 },
323 { SwFieldTypesEnum::Dropdown, nullptr, 0, nullptr, 0 },
324 { SwFieldTypesEnum::Input, FLD_INPUT_ARY, std::size(FLD_INPUT_ARY), nullptr, 0 },
325 { SwFieldTypesEnum::Macro, nullptr, 0, nullptr, 0 },
326 { SwFieldTypesEnum::JumpEdit, nullptr, 0, FMT_MARK_ARY, std::size(FMT_MARK_ARY) },
327 { SwFieldTypesEnum::CombinedChars, nullptr, 0, nullptr, 0 },
328 { SwFieldTypesEnum::HiddenText, nullptr, 0, nullptr, 0 },
329 { SwFieldTypesEnum::HiddenParagraph, nullptr, 0, nullptr, 0 },
330
331 // Cross-References
332 { SwFieldTypesEnum::SetRef, nullptr, 0, nullptr, 0 },
333 { SwFieldTypesEnum::GetRef, nullptr, 0, FMT_REF_ARY, std::size(FMT_REF_ARY) },
334
335 // DocInformation
336 { SwFieldTypesEnum::DocumentInfo, nullptr, 0, FMT_REG_ARY, std::size(FMT_REG_ARY) },
337
338 // Database
339 { SwFieldTypesEnum::Database, nullptr, 0, FMT_DBFLD_ARY, std::size(FMT_DBFLD_ARY) },
340 { SwFieldTypesEnum::DatabaseNextSet, nullptr, 0, nullptr, 0 },
341 { SwFieldTypesEnum::DatabaseNumberSet, nullptr, 0, nullptr, 0 },
342 { SwFieldTypesEnum::DatabaseSetNumber, nullptr, 0, FMT_NUM_ARY, std::size(FMT_NUM_ARY) - 2 },
343 { SwFieldTypesEnum::DatabaseName, nullptr, 0, nullptr, 0 },
344
345 // Variables
346 { SwFieldTypesEnum::Set, nullptr, 0, FMT_SETVAR_ARY, std::size(FMT_SETVAR_ARY) },
347
348 { SwFieldTypesEnum::Get, nullptr, 0, FMT_GETVAR_ARY, std::size(FMT_GETVAR_ARY) },
349 { SwFieldTypesEnum::DDE, nullptr, 0, FMT_DDE_ARY, std::size(FMT_DDE_ARY) },
350 { SwFieldTypesEnum::Formel, nullptr, 0, FMT_GETVAR_ARY, std::size(FMT_GETVAR_ARY) },
351 { SwFieldTypesEnum::Input, FLD_INPUT_ARY, std::size(FLD_INPUT_ARY), nullptr, 0 },
352 { SwFieldTypesEnum::Sequence, nullptr, 0, FMT_NUM_ARY, std::size(FMT_NUM_ARY) - 2 },
353 { SwFieldTypesEnum::SetRefPage, FLD_PAGEREF_ARY, std::size(FLD_PAGEREF_ARY),nullptr, 0 },
354 { SwFieldTypesEnum::GetRefPage, nullptr, 0, FMT_NUM_ARY, std::size(FMT_NUM_ARY) - 1 },
355 { SwFieldTypesEnum::User, nullptr, 0, FMT_USERVAR_ARY, std::size(FMT_USERVAR_ARY) }
356 };
357
358 // access to the shell
359 static SwWrtShell* lcl_GetShell()
360 {
361 if (SwView* pView = GetActiveView())
362 return pView->GetWrtShellPtr();
363 return nullptr;
364 }
365
366 static sal_uInt16 GetPackCount() { return SAL_N_ELEMENTS(aSwFields); }
367
368 // FieldManager controls inserting and updating of fields
369 SwFieldMgr::SwFieldMgr(SwWrtShell* pSh ) :
370 m_pWrtShell(pSh),
371 m_bEvalExp(true)
372 {
373 // determine current field if existing
374 GetCurField();
375 }
376
377 SwFieldMgr::~SwFieldMgr()
378 {
379 }
380
381 // organise RefMark by names
382 bool SwFieldMgr::CanInsertRefMark( std::u16string_view rStr )
383 {
384 bool bRet = false;
385 SwWrtShell *pSh = m_pWrtShell ? m_pWrtShell : lcl_GetShell();
386 OSL_ENSURE(pSh, "no SwWrtShell found");
387 if(pSh)
388 {
389 sal_uInt16 nCnt = pSh->GetCursorCnt();
390
391 // the last Cursor doesn't have to be a spanned selection
392 if( 1 < nCnt && !pSh->SwCursorShell::HasSelection() )
393 --nCnt;
394
395 bRet = 2 > nCnt && nullptr == pSh->GetRefMark( rStr );
396 }
397 return bRet;
398 }
399
400 // access over ResIds
401 void SwFieldMgr::RemoveFieldType(SwFieldIds nResId, const OUString& rName )
402 {
403 SwWrtShell * pSh = m_pWrtShell ? m_pWrtShell : lcl_GetShell();
404 OSL_ENSURE(pSh, "no SwWrtShell found");
405 if( pSh )
406 pSh->RemoveFieldType(nResId, rName);
407 }
408
409 size_t SwFieldMgr::GetFieldTypeCount() const
410 {
411 SwWrtShell * pSh = m_pWrtShell ? m_pWrtShell : lcl_GetShell();
412 OSL_ENSURE(pSh, "no SwWrtShell found");
413 return pSh ? pSh->GetFieldTypeCount() : 0;
414 }
415
416 SwFieldType* SwFieldMgr::GetFieldType(SwFieldIds nResId, size_t nField) const
417 {
418 SwWrtShell * pSh = m_pWrtShell ? m_pWrtShell : lcl_GetShell();
419 OSL_ENSURE(pSh, "no SwWrtShell found");
420 return pSh ? pSh->GetFieldType(nField, nResId) : nullptr;
421 }
422
423 SwFieldType* SwFieldMgr::GetFieldType(SwFieldIds nResId, const OUString& rName) const
424 {
425 SwWrtShell * pSh = m_pWrtShell ? m_pWrtShell : lcl_GetShell();
426 OSL_ENSURE(pSh, "no SwWrtShell found");
427 return pSh ? pSh->GetFieldType(nResId, rName) : nullptr;
428 }
429
430 // determine current field
431 SwField* SwFieldMgr::GetCurField()
432 {
433 SwWrtShell *pSh = m_pWrtShell ? m_pWrtShell : ::lcl_GetShell();
434 if ( pSh )
435 m_pCurField = pSh->GetCurField( true );
436 else
437 m_pCurField = nullptr;
438
439 // initialise strings and format
440 m_aCurPar1.clear();
441 m_aCurPar2.clear();
442 m_sCurFrame.clear();
443
444 if(!m_pCurField)
445 return nullptr;
446
447 // preprocess current values; determine parameter 1 and parameter 2
448
449 m_aCurPar1 = m_pCurField->GetPar1();
450 m_aCurPar2 = m_pCurField->GetPar2();
451
452 return m_pCurField;
453 }
454
455 // provide group range
456 const SwFieldGroupRgn& SwFieldMgr::GetGroupRange(bool bHtmlMode, sal_uInt16 nGrpId)
457 {
458 static SwFieldGroupRgn const aRanges[] =
459 {
460 { /* Document */ GRP_DOC_BEGIN, GRP_DOC_END },
461 { /* Functions */ GRP_FKT_BEGIN, GRP_FKT_END },
462 { /* Cross-Refs */ GRP_REF_BEGIN, GRP_REF_END },
463 { /* DocInfos */ GRP_REG_BEGIN, GRP_REG_END },
464 { /* Database */ GRP_DB_BEGIN, GRP_DB_END },
465 { /* User */ GRP_VAR_BEGIN, GRP_VAR_END }
466 };
467 static SwFieldGroupRgn const aWebRanges[] =
468 {
469 { /* Document */ GRP_WEB_DOC_BEGIN, GRP_WEB_DOC_END },
470 { /* Functions */ GRP_WEB_FKT_BEGIN, GRP_WEB_FKT_END },
471 { /* Cross-Refs */ GRP_WEB_REF_BEGIN, GRP_WEB_REF_END },
472 { /* DocInfos */ GRP_WEB_REG_BEGIN, GRP_WEB_REG_END },
473 { /* Database */ GRP_WEB_DB_BEGIN, GRP_WEB_DB_END },
474 { /* User */ GRP_WEB_VAR_BEGIN, GRP_WEB_VAR_END }
475 };
476
477 if (bHtmlMode)
478 return aWebRanges[nGrpId];
479 else
480 return aRanges[nGrpId];
481 }
482
483 // determine GroupId
484 sal_uInt16 SwFieldMgr::GetGroup(SwFieldTypesEnum nTypeId, sal_uInt16 nSubType)
485 {
486 if (nTypeId == SwFieldTypesEnum::SetInput)
487 nTypeId = SwFieldTypesEnum::Set;
488
489 if (nTypeId == SwFieldTypesEnum::Input && (nSubType & INP_USR))
490 nTypeId = SwFieldTypesEnum::User;
491
492 if (nTypeId == SwFieldTypesEnum::FixedDate)
493 nTypeId = SwFieldTypesEnum::Date;
494
495 if (nTypeId == SwFieldTypesEnum::FixedTime)
496 nTypeId = SwFieldTypesEnum::Time;
497
498 for (sal_uInt16 i = GRP_DOC; i <= GRP_VAR; i++)
499 {
500 const SwFieldGroupRgn& rRange = GetGroupRange(false/*bHtmlMode*/, i);
501 for (sal_uInt16 nPos = rRange.nStart; nPos < rRange.nEnd; nPos++)
502 {
503 if (aSwFields[nPos].nTypeId == nTypeId)
504 return i;
505 }
506 }
507 return USHRT_MAX;
508 }
509
510 // determine names to TypeId
511 // ACCESS over TYP_...
512 SwFieldTypesEnum SwFieldMgr::GetTypeId(sal_uInt16 nPos)
513 {
514 OSL_ENSURE(nPos < ::GetPackCount(), "forbidden Pos");
515 return aSwFields[ nPos ].nTypeId;
516 }
517
518 const OUString & SwFieldMgr::GetTypeStr(sal_uInt16 nPos)
519 {
520 OSL_ENSURE(nPos < ::GetPackCount(), "forbidden TypeId");
521
522 SwFieldTypesEnum nFieldWh = aSwFields[ nPos ].nTypeId;
523
524 // special treatment for date/time fields (without var/fix)
525 if( SwFieldTypesEnum::Date == nFieldWh )
526 {
527 static OUString g_aDate( SwResId( STR_DATEFLD ) );
528 return g_aDate;
529 }
530 if( SwFieldTypesEnum::Time == nFieldWh )
531 {
532 static OUString g_aTime( SwResId( STR_TIMEFLD ) );
533 return g_aTime;
534 }
535
536 return SwFieldType::GetTypeStr( nFieldWh );
537 }
538
539 // determine Pos in the list
540 sal_uInt16 SwFieldMgr::GetPos(SwFieldTypesEnum nTypeId)
541 {
542 switch( nTypeId )
543 {
544 case SwFieldTypesEnum::FixedDate: nTypeId = SwFieldTypesEnum::Date; break;
545 case SwFieldTypesEnum::FixedTime: nTypeId = SwFieldTypesEnum::Time; break;
546 case SwFieldTypesEnum::SetInput: nTypeId = SwFieldTypesEnum::Set; break;
547 case SwFieldTypesEnum::UserInput: nTypeId = SwFieldTypesEnum::User; break;
548 default: break;
549 }
550
551 for(sal_uInt16 i = 0; i < GetPackCount(); i++)
552 if(aSwFields[i].nTypeId == nTypeId)
553 return i;
554
555 return USHRT_MAX;
556 }
557
558 // localise subtypes of a field
559 void SwFieldMgr::GetSubTypes(SwFieldTypesEnum nTypeId, std::vector<OUString>& rToFill)
560 {
561 SwWrtShell *pSh = m_pWrtShell ? m_pWrtShell : lcl_GetShell();
562 OSL_ENSURE(pSh, "no SwWrtShell found");
563 if(!pSh)
564 return;
565
566 const sal_uInt16 nPos = GetPos(nTypeId);
567
568 switch(nTypeId)
569 {
570 case SwFieldTypesEnum::SetRef:
571 case SwFieldTypesEnum::GetRef:
572 {
573 // references are no fields
574 pSh->GetRefMarks( &rToFill );
575 break;
576 }
577 case SwFieldTypesEnum::Macro:
578 {
579 break;
580 }
581 case SwFieldTypesEnum::Input:
582 {
583 rToFill.push_back(SwResId(aSwFields[nPos].pSubTypeResIds[0]));
584 [[fallthrough]]; // move on at generic types
585 }
586 case SwFieldTypesEnum::DDE:
587 case SwFieldTypesEnum::Sequence:
588 case SwFieldTypesEnum::Formel:
589 case SwFieldTypesEnum::Get:
590 case SwFieldTypesEnum::Set:
591 case SwFieldTypesEnum::User:
592 {
593
594 const size_t nCount = pSh->GetFieldTypeCount();
595 for(size_t i = 0; i < nCount; ++i)
596 {
597 SwFieldType* pFieldType = pSh->GetFieldType( i );
598 const SwFieldIds nWhich = pFieldType->Which();
599
600 if((nTypeId == SwFieldTypesEnum::DDE && pFieldType->Which() == SwFieldIds::Dde) ||
601
602 (nTypeId == SwFieldTypesEnum::User && nWhich == SwFieldIds::User) ||
603
604 (nTypeId == SwFieldTypesEnum::Get && nWhich == SwFieldIds::SetExp &&
605 !(static_cast<SwSetExpFieldType*>(pFieldType)->GetType() & nsSwGetSetExpType::GSE_SEQ)) ||
606
607 (nTypeId == SwFieldTypesEnum::Set && nWhich == SwFieldIds::SetExp &&
608 !(static_cast<SwSetExpFieldType*>(pFieldType)->GetType() & nsSwGetSetExpType::GSE_SEQ)) ||
609
610 (nTypeId == SwFieldTypesEnum::Sequence && nWhich == SwFieldIds::SetExp &&
611 (static_cast<SwSetExpFieldType*>(pFieldType)->GetType() & nsSwGetSetExpType::GSE_SEQ)) ||
612
613 ((nTypeId == SwFieldTypesEnum::Input || nTypeId == SwFieldTypesEnum::Formel) &&
614 (nWhich == SwFieldIds::User ||
615 (nWhich == SwFieldIds::SetExp &&
616 !(static_cast<SwSetExpFieldType*>(pFieldType)->GetType() & nsSwGetSetExpType::GSE_SEQ))) ) )
617 {
618 rToFill.push_back(pFieldType->GetName());
619 }
620 }
621 break;
622 }
623 case SwFieldTypesEnum::DatabaseNextSet:
624 case SwFieldTypesEnum::DatabaseNumberSet:
625 case SwFieldTypesEnum::DatabaseName:
626 case SwFieldTypesEnum::DatabaseSetNumber:
627 break;
628
629 default:
630 {
631 // static SubTypes
632 if(nPos != USHRT_MAX)
633 {
634 sal_uInt16 nCount;
635 if (nTypeId == SwFieldTypesEnum::DocumentInfo)
636 nCount = DI_SUBTYPE_END - DI_SUBTYPE_BEGIN;
637 else
638 nCount = aSwFields[nPos].nSubTypeLength;
639
640 for(sal_uInt16 i = 0; i < nCount; ++i)
641 {
642 OUString sNew;
643 if (nTypeId == SwFieldTypesEnum::DocumentInfo)
644 {
645 if ( i == DI_CUSTOM )
646 sNew = SwResId(STR_CUSTOM_FIELD);
647 else
648 sNew = SwViewShell::GetShellRes()->aDocInfoLst[i];
649 }
650 else
651 sNew = SwResId(aSwFields[nPos].pSubTypeResIds[i]);
652
653 rToFill.push_back(sNew);
654 }
655 }
656 }
657 }
658 }
659
660 // determine format
661 // ACCESS over TYP_...
662 sal_uInt16 SwFieldMgr::GetFormatCount(SwFieldTypesEnum nTypeId, bool bHtmlMode) const
663 {
664 assert(nTypeId < SwFieldTypesEnum::LAST && "forbidden TypeId");
665 {
666 const sal_uInt16 nPos = GetPos(nTypeId);
667
668 if (nPos == USHRT_MAX || (bHtmlMode && nTypeId == SwFieldTypesEnum::Set))
669 return 0;
670
671 sal_uInt16 nCount = aSwFields[nPos].nFormatLength;
672
673 if (nTypeId == SwFieldTypesEnum::Filename)
674 nCount -= 2; // no range or template
675
676 const TranslateId* pStart = aSwFields[nPos].pFormatResIds;
677 if (!pStart)
678 return nCount;
679
680 if (*pStart == FMT_GETVAR_ARY[0] || *pStart == FMT_SETVAR_ARY[0])
681 return VF_COUNT;
682 else if (*pStart == FMT_USERVAR_ARY[0])
683 return VF_USR_COUNT;
684 else if (*pStart == FMT_DBFLD_ARY[0])
685 return VF_DB_COUNT;
686 else if (*pStart == FMT_NUM_ARY[0])
687 {
688 GetNumberingInfo();
689 if(m_xNumberingInfo.is())
690 {
691 const Sequence<sal_Int16> aTypes = m_xNumberingInfo->getSupportedNumberingTypes();
692 // #i28073# it's not necessarily a sorted sequence
693 //skip all values below or equal to CHARS_LOWER_LETTER_N
694 nCount += std::count_if(aTypes.begin(), aTypes.end(),
695 [](sal_Int16 nCurrent) { return nCurrent > NumberingType::CHARS_LOWER_LETTER_N; });
696 }
697 return nCount;
698 }
699
700 return nCount;
701 }
702 }
703
704 // determine FormatString to a type
705 OUString SwFieldMgr::GetFormatStr(SwFieldTypesEnum nTypeId, sal_uInt32 nFormatId) const
706 {
707 assert(nTypeId < SwFieldTypesEnum::LAST && "forbidden TypeId");
708 const sal_uInt16 nPos = GetPos(nTypeId);
709
710 if (nPos == USHRT_MAX)
711 return OUString();
712
713 const TranslateId* pStart = aSwFields[nPos].pFormatResIds;
714 if (!pStart)
715 return OUString();
716
717 if (SwFieldTypesEnum::Author == nTypeId || SwFieldTypesEnum::Filename == nTypeId)
718 nFormatId &= ~static_cast<sal_uInt32>(FF_FIXED); // mask out Fixed-Flag
719
720 if (nFormatId < aSwFields[nPos].nFormatLength)
721 return SwResId(pStart[nFormatId]);
722
723 OUString aRet;
724 if (*pStart == FMT_NUM_ARY[0])
725 {
726 if (m_xNumberingInfo.is())
727 {
728 const Sequence<sal_Int16> aTypes = m_xNumberingInfo->getSupportedNumberingTypes();
729 sal_Int32 nOffset = aSwFields[nPos].nFormatLength;
730 sal_uInt32 nValidEntry = 0;
731 for (const sal_Int16 nCurrent : aTypes)
732 {
733 if(nCurrent > NumberingType::CHARS_LOWER_LETTER_N &&
734 (nCurrent != (NumberingType::BITMAP | LINK_TOKEN)))
735 {
736 if (nValidEntry == nFormatId - nOffset)
737 {
738 sal_uInt32 n = SvxNumberingTypeTable::FindIndex(nCurrent);
739 if (n != RESARRAY_INDEX_NOTFOUND)
740 {
741 aRet = SvxNumberingTypeTable::GetString(n);
742 }
743 else
744 {
745 aRet = m_xNumberingInfo->getNumberingIdentifier( nCurrent );
746 }
747 break;
748 }
749 ++nValidEntry;
750 }
751 }
752 }
753 }
754
755 return aRet;
756 }
757
758 // determine FormatId from Pseudo-ID
759 sal_uInt16 SwFieldMgr::GetFormatId(SwFieldTypesEnum nTypeId, sal_uInt32 nFormatId) const
760 {
761 sal_uInt16 nId = o3tl::narrowing<sal_uInt16>(nFormatId);
762 switch( nTypeId )
763 {
764 case SwFieldTypesEnum::DocumentInfo:
765 {
766 TranslateId sId = aSwFields[GetPos(nTypeId)].pFormatResIds[nFormatId];
767 if (sId == FMT_REG_AUTHOR)
768 nId = DI_SUB_AUTHOR;
769 else if (sId == FMT_REG_TIME)
770 nId = DI_SUB_TIME;
771 else if (sId == FMT_REG_DATE)
772 nId = DI_SUB_DATE;
773 break;
774 }
775 case SwFieldTypesEnum::PageNumber:
776 case SwFieldTypesEnum::NextPage:
777 case SwFieldTypesEnum::PreviousPage:
778 case SwFieldTypesEnum::DocumentStatistics:
779 case SwFieldTypesEnum::DatabaseSetNumber:
780 case SwFieldTypesEnum::Sequence:
781 case SwFieldTypesEnum::GetRefPage:
782 {
783 sal_uInt16 nPos = GetPos(nTypeId);
784 if (nFormatId < aSwFields[nPos].nFormatLength)
785 {
786 const TranslateId sId = aSwFields[nPos].pFormatResIds[nFormatId];
787 if (sId == FMT_NUM_ABC)
788 nId = SVX_NUM_CHARS_UPPER_LETTER;
789 else if (sId == FMT_NUM_SABC)
790 nId = SVX_NUM_CHARS_LOWER_LETTER;
791 else if (sId == FMT_NUM_ROMAN)
792 nId = SVX_NUM_ROMAN_UPPER;
793 else if (sId == FMT_NUM_SROMAN)
794 nId = SVX_NUM_ROMAN_LOWER;
795 else if (sId == FMT_NUM_ARABIC)
796 nId = SVX_NUM_ARABIC;
797 else if (sId == FMT_NUM_PAGEDESC)
798 nId = SVX_NUM_PAGEDESC;
799 else if (sId == FMT_NUM_PAGESPECIAL)
800 nId = SVX_NUM_CHAR_SPECIAL;
801 else if (sId == FMT_NUM_ABC_N)
802 nId = SVX_NUM_CHARS_UPPER_LETTER_N;
803 else if (sId == FMT_NUM_SABC_N)
804 nId = SVX_NUM_CHARS_LOWER_LETTER_N;
805 }
806 else if (m_xNumberingInfo.is())
807 {
808 const Sequence<sal_Int16> aTypes = m_xNumberingInfo->getSupportedNumberingTypes();
809 sal_Int32 nOffset = aSwFields[nPos].nFormatLength;
810 sal_Int32 nValidEntry = 0;
811 for (const sal_Int16 nCurrent : aTypes)
812 {
813 if (nCurrent > NumberingType::CHARS_LOWER_LETTER_N)
814 {
815 if (nValidEntry == static_cast<sal_Int32>(nFormatId) - nOffset)
816 {
817 nId = nCurrent;
818 break;
819 }
820 ++nValidEntry;
821 }
822 }
823 }
824 break;
825 }
826 case SwFieldTypesEnum::DDE:
827 {
828 const TranslateId sId = aSwFields[GetPos(nTypeId)].pFormatResIds[nFormatId];
829 if (sId == FMT_DDE_NORMAL)
830 nId = static_cast<sal_uInt16>(SfxLinkUpdateMode::ONCALL);
831 else if (sId == FMT_DDE_HOT)
832 nId = static_cast<sal_uInt16>(SfxLinkUpdateMode::ALWAYS);
833 break;
834 }
835 default: break;
836 }
837 return nId;
838 }
839
840 // Traveling
841 bool SwFieldMgr::GoNextPrev( bool bNext, SwFieldType* pTyp )
842 {
843 SwWrtShell* pSh = m_pWrtShell ? m_pWrtShell : ::lcl_GetShell();
844 if(!pSh)
845 return false;
846
847 if( !pTyp && m_pCurField )
848 {
849 const SwFieldTypesEnum nTypeId = m_pCurField->GetTypeId();
850 if( SwFieldTypesEnum::SetInput == nTypeId || SwFieldTypesEnum::UserInput == nTypeId )
851 pTyp = pSh->GetFieldType( 0, SwFieldIds::Input );
852 else
853 pTyp = m_pCurField->GetTyp();
854 }
855
856 if (pTyp && pTyp->Which() == SwFieldIds::Database)
857 {
858 // for fieldcommand-edit (hop to all DB fields)
859 return pSh->MoveFieldType( nullptr, bNext, SwFieldIds::Database );
860 }
861
862 return pTyp && pSh->MoveFieldType(pTyp, bNext);
863 }
864
865 // insert field types
866 void SwFieldMgr::InsertFieldType(SwFieldType const & rType)
867 {
868 SwWrtShell* pSh = m_pWrtShell ? m_pWrtShell : ::lcl_GetShell();
869 OSL_ENSURE(pSh, "no SwWrtShell found");
870 if(pSh)
871 pSh->InsertFieldType(rType);
872 }
873
874 // determine current TypeId
875 SwFieldTypesEnum SwFieldMgr::GetCurTypeId() const
876 {
877 return m_pCurField ? m_pCurField->GetTypeId() : SwFieldTypesEnum::Unknown;
878 }
879
880 // Over string insert field or update
881 bool SwFieldMgr::InsertField(
882 SwInsertField_Data& rData)
883 {
884 std::unique_ptr<SwField> pField;
885 bool bExp = false;
886 bool bTable = false;
887 bool bPageVar = false;
888 sal_uInt32 nFormatId = rData.m_nFormatId;
889 sal_uInt16 nSubType = rData.m_nSubType;
890 sal_Unicode cSeparator = rData.m_cSeparator;
891 SwWrtShell* pCurShell = rData.m_pSh;
892 if(!pCurShell)
893 pCurShell = m_pWrtShell ? m_pWrtShell : ::lcl_GetShell();
894 OSL_ENSURE(pCurShell, "no SwWrtShell found");
895 if(!pCurShell)
896 return false;
897
898 switch (rData.m_nTypeId)
899 { // ATTENTION this field is inserted by a separate dialog
900 case SwFieldTypesEnum::Postit:
901 {
902 SvtUserOptions aUserOpt;
903 SwPostItFieldType* pType = static_cast<SwPostItFieldType*>(pCurShell->GetFieldType(0, SwFieldIds::Postit));
904 pField.reset(
905 new SwPostItField(
906 pType,
907 rData.m_sPar1, // author
908 rData.m_sPar2, // content
909 aUserOpt.GetID(), // author's initials
910 OUString(), // name
911 DateTime(DateTime::SYSTEM) ));
912 }
913 break;
914 case SwFieldTypesEnum::Script:
915 {
916 SwScriptFieldType* pType =
917 static_cast<SwScriptFieldType*>(pCurShell->GetFieldType(0, SwFieldIds::Script));
918 pField.reset(new SwScriptField(pType, rData.m_sPar1, rData.m_sPar2, static_cast<bool>(nFormatId)));
919 break;
920 }
921
922 case SwFieldTypesEnum::CombinedChars:
923 {
924 SwCombinedCharFieldType* pType = static_cast<SwCombinedCharFieldType*>(
925 pCurShell->GetFieldType( 0, SwFieldIds::CombinedChars ));
926 pField.reset(new SwCombinedCharField( pType, rData.m_sPar1 ));
927 }
928 break;
929
930 case SwFieldTypesEnum::Authority:
931 {
932 SwAuthorityFieldType* pType =
933 static_cast<SwAuthorityFieldType*>(pCurShell->GetFieldType(0, SwFieldIds::TableOfAuthorities));
934 if (!pType)
935 {
936 SwAuthorityFieldType const type(pCurShell->GetDoc());
937 pType = static_cast<SwAuthorityFieldType*>(
938 pCurShell->InsertFieldType(type));
939 }
940 pField.reset(new SwAuthorityField(pType, rData.m_sPar1));
941 }
942 break;
943
944 case SwFieldTypesEnum::Date:
945 case SwFieldTypesEnum::Time:
946 {
947 sal_uInt16 nSub = static_cast< sal_uInt16 >(rData.m_nTypeId == SwFieldTypesEnum::Date ? DATEFLD : TIMEFLD);
948 nSub |= nSubType == DATE_VAR ? 0 : FIXEDFLD;
949
950 SwDateTimeFieldType* pTyp =
951 static_cast<SwDateTimeFieldType*>( pCurShell->GetFieldType(0, SwFieldIds::DateTime) );
952 pField.reset(new SwDateTimeField(pTyp, nSub, nFormatId));
953 pField->SetPar2(rData.m_sPar2);
954 break;
955 }
956
957 case SwFieldTypesEnum::Filename:
958 {
959 SwFileNameFieldType* pTyp =
960 static_cast<SwFileNameFieldType*>( pCurShell->GetFieldType(0, SwFieldIds::Filename) );
961 pField.reset(new SwFileNameField(pTyp, nFormatId));
962 break;
963 }
964
965 case SwFieldTypesEnum::TemplateName:
966 {
967 SwTemplNameFieldType* pTyp =
968 static_cast<SwTemplNameFieldType*>( pCurShell->GetFieldType(0, SwFieldIds::TemplateName) );
969 pField.reset(new SwTemplNameField(pTyp, nFormatId));
970 break;
971 }
972
973 case SwFieldTypesEnum::Chapter:
974 {
975 sal_uInt16 nByte = o3tl::narrowing<sal_uInt16>(rData.m_sPar2.toInt32());
976 SwChapterFieldType* pTyp =
977 static_cast<SwChapterFieldType*>( pCurShell->GetFieldType(0, SwFieldIds::Chapter) );
978 pField.reset(new SwChapterField(pTyp, nFormatId));
979 nByte = std::max(sal_uInt16(1), nByte);
980 nByte = std::min(nByte, sal_uInt16(MAXLEVEL));
981 nByte -= 1;
982 static_cast<SwChapterField*>(pField.get())->SetLevel(static_cast<sal_uInt8>(nByte));
983 break;
984 }
985
986 case SwFieldTypesEnum::NextPage:
987 case SwFieldTypesEnum::PreviousPage:
988 case SwFieldTypesEnum::PageNumber:
989 {
990 short nOff = static_cast<short>(rData.m_sPar2.toInt32());
991
992 if(rData.m_nTypeId == SwFieldTypesEnum::NextPage)
993 {
994 if( SVX_NUM_CHAR_SPECIAL == nFormatId )
995 nOff = 1;
996 else
997 nOff += 1;
998 nSubType = PG_NEXT;
999 }
1000 else if(rData.m_nTypeId == SwFieldTypesEnum::PreviousPage)
1001 {
1002 if( SVX_NUM_CHAR_SPECIAL == nFormatId )
1003 nOff = -1;
1004 else
1005 nOff -= 1;
1006 nSubType = PG_PREV;
1007 }
1008 else
1009 nSubType = PG_RANDOM;
1010
1011 SwPageNumberFieldType* pTyp =
1012 static_cast<SwPageNumberFieldType*>( pCurShell->GetFieldType(0, SwFieldIds::PageNumber) );
1013 pField.reset(new SwPageNumberField(pTyp, nSubType, nFormatId, nOff));
1014
1015 if( SVX_NUM_CHAR_SPECIAL == nFormatId &&
1016 ( PG_PREV == nSubType || PG_NEXT == nSubType ) )
1017 static_cast<SwPageNumberField*>(pField.get())->SetUserString( rData.m_sPar2 );
1018 break;
1019 }
1020
1021 case SwFieldTypesEnum::DocumentStatistics:
1022 {
1023 SwDocStatFieldType* pTyp =
1024 static_cast<SwDocStatFieldType*>( pCurShell->GetFieldType(0, SwFieldIds::DocStat) );
1025 pField.reset(new SwDocStatField(pTyp, nSubType, nFormatId));
1026 break;
1027 }
1028
1029 case SwFieldTypesEnum::Author:
1030 {
1031 SwAuthorFieldType* pTyp =
1032 static_cast<SwAuthorFieldType*>( pCurShell->GetFieldType(0, SwFieldIds::Author) );
1033 pField.reset(new SwAuthorField(pTyp, nFormatId));
1034 break;
1035 }
1036
1037 case SwFieldTypesEnum::ConditionalText:
1038 case SwFieldTypesEnum::HiddenText:
1039 {
1040 SwHiddenTextFieldType* pTyp =
1041 static_cast<SwHiddenTextFieldType*>( pCurShell->GetFieldType(0, SwFieldIds::HiddenText) );
1042 pField.reset(new SwHiddenTextField(pTyp, true, rData.m_sPar1, rData.m_sPar2, false, rData.m_nTypeId));
1043 bExp = true;
1044 break;
1045 }
1046
1047 case SwFieldTypesEnum::HiddenParagraph:
1048 {
1049 SwHiddenParaFieldType* pTyp =
1050 static_cast<SwHiddenParaFieldType*>( pCurShell->GetFieldType(0, SwFieldIds::HiddenPara) );
1051 pField.reset(new SwHiddenParaField(pTyp, rData.m_sPar1));
1052 bExp = true;
1053 break;
1054 }
1055
1056 case SwFieldTypesEnum::SetRef:
1057 {
1058 if( !rData.m_sPar1.isEmpty() && CanInsertRefMark( rData.m_sPar1 ) )
1059 {
1060 const OUString& rRefmarkText = rData.m_sPar2;
1061 SwPaM* pCursorPos = pCurShell->GetCursor();
1062 pCurShell->StartAction();
1063 bool bHadMark = pCursorPos->HasMark();
1064 // If we have no selection and the refmark text is provided, then the text is
1065 // expected to be HTML.
1066 if (!bHadMark && !rRefmarkText.isEmpty())
1067 {
1068 // Split node to remember where the start position is.
1069 bool bSuccess = pCurShell->GetDoc()->getIDocumentContentOperations().SplitNode(
1070 *pCursorPos->GetPoint(), /*bChkTableStart=*/false);
1071 if (bSuccess)
1072 {
1073 SwPaM aRefmarkPam(*pCursorPos->GetPoint());
1074 aRefmarkPam.Move(fnMoveBackward, GoInContent);
1075
1076 // Paste HTML content.
1077 SwTranslateHelper::PasteHTMLToPaM(
1078 *pCurShell, pCursorPos, rRefmarkText.toUtf8());
1079
1080 // Undo the above SplitNode().
1081 aRefmarkPam.SetMark();
1082 aRefmarkPam.Move(fnMoveForward, GoInContent);
1083 pCurShell->GetDoc()->getIDocumentContentOperations().DeleteAndJoin(
1084 aRefmarkPam);
1085 *aRefmarkPam.GetMark() = *pCursorPos->GetPoint();
1086 *pCursorPos = aRefmarkPam;
1087 }
1088 }
1089
1090 pCurShell->SetAttrItem( SwFormatRefMark( rData.m_sPar1 ) );
1091
1092 if (!bHadMark && !rRefmarkText.isEmpty())
1093 {
1094 pCursorPos->DeleteMark();
1095 }
1096 pCurShell->EndAction();
1097 return true;
1098 }
1099 return false;
1100 }
1101
1102 case SwFieldTypesEnum::GetRef:
1103 {
1104 SwGetRefFieldType* pTyp =
1105 static_cast<SwGetRefFieldType*>( pCurShell->GetFieldType(0, SwFieldIds::GetRef) );
1106
1107 sal_uInt16 nSeqNo = 0;
1108 sal_uInt16 nFlags = 0;
1109
1110 if (nSubType == REF_STYLE) nFlags = o3tl::narrowing<sal_uInt16>(rData.m_sPar2.toInt32());
1111 else nSeqNo = o3tl::narrowing<sal_uInt16>(rData.m_sPar2.toInt32());
1112
1113 OUString sReferenceLanguage;
1114 // handle language-variant formats
1115 if (nFormatId >= SAL_N_ELEMENTS(FMT_REF_ARY))
1116 {
1117 LanguageType nLang = GetCurrLanguage();
1118 if (nLang == LANGUAGE_HUNGARIAN)
1119 {
1120 if (nFormatId >= SAL_N_ELEMENTS(FMT_REF_ARY) * 2)
1121 sReferenceLanguage = "Hu";
1122 else
1123 sReferenceLanguage = "hu";
1124 }
1125 nFormatId %= SAL_N_ELEMENTS(FMT_REF_ARY);
1126 }
1127
1128 pField.reset(new SwGetRefField(pTyp, rData.m_sPar1, sReferenceLanguage, nSubType, nSeqNo, nFlags, nFormatId));
1129 bExp = true;
1130 break;
1131 }
1132
1133 case SwFieldTypesEnum::DDE:
1134 {
1135 //JP 28.08.95: DDE-Topics/-Items can have blanks in their names!
1136 // That's not yet considered here.
1137 sal_Int32 nIndex = 0;
1138 OUString sCmd = rData.m_sPar2.replaceFirst(" ", OUStringChar(sfx2::cTokenSeparator), &nIndex);
1139 if (nIndex>=0 && ++nIndex<sCmd.getLength())
1140 {
1141 sCmd = sCmd.replaceFirst(" ", OUStringChar(sfx2::cTokenSeparator), &nIndex);
1142 }
1143
1144 SwDDEFieldType aType( rData.m_sPar1, sCmd, static_cast<SfxLinkUpdateMode>(nFormatId) );
1145 SwDDEFieldType* pTyp = static_cast<SwDDEFieldType*>( pCurShell->InsertFieldType( aType ) );
1146 pField.reset(new SwDDEField( pTyp ));
1147 break;
1148 }
1149
1150 case SwFieldTypesEnum::Macro:
1151 {
1152 SwMacroFieldType* pTyp =
1153 static_cast<SwMacroFieldType*>(pCurShell->GetFieldType(0, SwFieldIds::Macro));
1154
1155 pField.reset(new SwMacroField(pTyp, rData.m_sPar1, rData.m_sPar2));
1156
1157 break;
1158 }
1159
1160 case SwFieldTypesEnum::Internet:
1161 {
1162 SwFormatINetFormat aFormat( rData.m_sPar1, m_sCurFrame );
1163 return pCurShell->InsertURL( aFormat, rData.m_sPar2 );
1164 }
1165
1166 case SwFieldTypesEnum::JumpEdit:
1167 {
1168 SwJumpEditFieldType* pTyp =
1169 static_cast<SwJumpEditFieldType*>(pCurShell->GetFieldType(0, SwFieldIds::JumpEdit));
1170
1171 pField.reset(new SwJumpEditField(pTyp, nFormatId, rData.m_sPar1, rData.m_sPar2));
1172 break;
1173 }
1174
1175 case SwFieldTypesEnum::DocumentInfo:
1176 {
1177 SwDocInfoFieldType* pTyp = static_cast<SwDocInfoFieldType*>( pCurShell->GetFieldType(
1178 0, SwFieldIds::DocInfo ) );
1179 pField.reset(new SwDocInfoField(pTyp, nSubType, rData.m_sPar1, nFormatId));
1180 break;
1181 }
1182
1183 case SwFieldTypesEnum::ExtendedUser:
1184 {
1185 SwExtUserFieldType* pTyp = static_cast<SwExtUserFieldType*>( pCurShell->GetFieldType(
1186 0, SwFieldIds::ExtUser) );
1187 pField.reset(new SwExtUserField(pTyp, nSubType, nFormatId));
1188 break;
1189 }
1190
1191 case SwFieldTypesEnum::Database:
1192 {
1193 #if HAVE_FEATURE_DBCONNECTIVITY && !ENABLE_FUZZERS
1194 SwDBData aDBData;
1195 OUString sPar1;
1196
1197 if (rData.m_sPar1.indexOf(DB_DELIM)<0)
1198 {
1199 aDBData = pCurShell->GetDBData();
1200 sPar1 = rData.m_sPar1;
1201 }
1202 else
1203 {
1204 sal_Int32 nIdx{ 0 };
1205 aDBData.sDataSource = rData.m_sPar1.getToken(0, DB_DELIM, nIdx);
1206 aDBData.sCommand = rData.m_sPar1.getToken(0, DB_DELIM, nIdx);
1207 aDBData.nCommandType = o3tl::toInt32(o3tl::getToken(rData.m_sPar1, 0, DB_DELIM, nIdx));
1208 sPar1 = rData.m_sPar1.getToken(0, DB_DELIM, nIdx);
1209 }
1210
1211 if(!aDBData.sDataSource.isEmpty() && pCurShell->GetDBData() != aDBData)
1212 pCurShell->ChgDBData(aDBData);
1213
1214 SwDBFieldType* pTyp = static_cast<SwDBFieldType*>(pCurShell->InsertFieldType(
1215 SwDBFieldType(pCurShell->GetDoc(), sPar1, aDBData) ) );
1216 pField.reset(new SwDBField(pTyp));
1217 pField->SetSubType(nSubType);
1218
1219 if( !(nSubType & nsSwExtendedSubType::SUB_OWN_FMT) ) // determine database format
1220 {
1221 Reference< XDataSource> xSource;
1222 rData.m_aDBDataSource >>= xSource;
1223 Reference<XConnection> xConnection;
1224 rData.m_aDBConnection >>= xConnection;
1225 Reference<XPropertySet> xColumn;
1226 rData.m_aDBColumn >>= xColumn;
1227 if(xColumn.is())
1228 {
1229 nFormatId = SwDBManager::GetColumnFormat(xSource, xConnection, xColumn,
1230 pCurShell->GetNumberFormatter(), GetCurrLanguage() );
1231 }
1232 else
1233 nFormatId = pCurShell->GetDBManager()->GetColumnFormat(
1234 aDBData.sDataSource, aDBData.sCommand, sPar1,
1235 pCurShell->GetNumberFormatter(), GetCurrLanguage() );
1236 }
1237 pField->ChangeFormat( nFormatId );
1238
1239 bExp = true;
1240 #endif
1241 break;
1242 }
1243
1244 case SwFieldTypesEnum::DatabaseSetNumber:
1245 case SwFieldTypesEnum::DatabaseNumberSet:
1246 case SwFieldTypesEnum::DatabaseNextSet:
1247 case SwFieldTypesEnum::DatabaseName:
1248 {
1249 #if HAVE_FEATURE_DBCONNECTIVITY && !ENABLE_FUZZERS
1250 SwDBData aDBData;
1251
1252 // extract DBName from rData.m_sPar1. Format: DBName.TableName.CommandType.ExpStrg
1253 sal_Int32 nTablePos = rData.m_sPar1.indexOf(DB_DELIM);
1254 sal_Int32 nExpPos = -1;
1255
1256 if (nTablePos>=0)
1257 {
1258 aDBData.sDataSource = rData.m_sPar1.copy(0, nTablePos++);
1259 sal_Int32 nCmdTypePos = rData.m_sPar1.indexOf(DB_DELIM, nTablePos);
1260 if (nCmdTypePos>=0)
1261 {
1262 aDBData.sCommand = rData.m_sPar1.copy(nTablePos, nCmdTypePos++ - nTablePos);
1263 nExpPos = rData.m_sPar1.indexOf(DB_DELIM, nCmdTypePos);
1264 if (nExpPos>=0)
1265 {
1266 aDBData.nCommandType = o3tl::toInt32(rData.m_sPar1.subView(nCmdTypePos, nExpPos++ - nCmdTypePos));
1267 }
1268 }
1269 }
1270
1271 sal_Int32 nPos = 0;
1272 if (nExpPos>=0)
1273 nPos = nExpPos;
1274 else if (nTablePos>=0)
1275 nPos = nTablePos;
1276
1277 OUString sPar1 = rData.m_sPar1.copy(nPos);
1278
1279 if (!aDBData.sDataSource.isEmpty() && pCurShell->GetDBData() != aDBData)
1280 pCurShell->ChgDBData(aDBData);
1281
1282 switch(rData.m_nTypeId)
1283 {
1284 case SwFieldTypesEnum::DatabaseName:
1285 {
1286 SwDBNameFieldType* pTyp =
1287 static_cast<SwDBNameFieldType*>(pCurShell->GetFieldType(0, SwFieldIds::DatabaseName));
1288 pField.reset(new SwDBNameField(pTyp, aDBData));
1289
1290 break;
1291 }
1292 case SwFieldTypesEnum::DatabaseNextSet:
1293 {
1294 SwDBNextSetFieldType* pTyp = static_cast<SwDBNextSetFieldType*>(pCurShell->GetFieldType(
1295 0, SwFieldIds::DbNextSet) );
1296 pField.reset(new SwDBNextSetField(pTyp, sPar1, aDBData));
1297 bExp = true;
1298 break;
1299 }
1300 case SwFieldTypesEnum::DatabaseNumberSet:
1301 {
1302 SwDBNumSetFieldType* pTyp = static_cast<SwDBNumSetFieldType*>( pCurShell->GetFieldType(
1303 0, SwFieldIds::DbNumSet) );
1304 pField.reset(new SwDBNumSetField( pTyp, sPar1, rData.m_sPar2, aDBData));
1305 bExp = true;
1306 break;
1307 }
1308 case SwFieldTypesEnum::DatabaseSetNumber:
1309 {
1310 SwDBSetNumberFieldType* pTyp = static_cast<SwDBSetNumberFieldType*>(
1311 pCurShell->GetFieldType(0, SwFieldIds::DbSetNumber) );
1312 pField.reset(new SwDBSetNumberField( pTyp, aDBData, nFormatId));
1313 bExp = true;
1314 break;
1315 }
1316 default: break;
1317 }
1318 #endif
1319 break;
1320 }
1321
1322 case SwFieldTypesEnum::User:
1323 {
1324 SwUserFieldType* pTyp =
1325 static_cast<SwUserFieldType*>( pCurShell->GetFieldType(SwFieldIds::User, rData.m_sPar1) );
1326
1327 // only if existing
1328 if(!pTyp)
1329 {
1330 pTyp = static_cast<SwUserFieldType*>( pCurShell->InsertFieldType(
1331 SwUserFieldType(pCurShell->GetDoc(), rData.m_sPar1)) );
1332 }
1333 if (pTyp->GetContent(nFormatId) != rData.m_sPar2)
1334 pTyp->SetContent(rData.m_sPar2, nFormatId);
1335 pField.reset(new SwUserField(pTyp, 0, nFormatId));
1336 if (pField->GetSubType() != nSubType)
1337 pField->SetSubType(nSubType);
1338 bTable = true;
1339 break;
1340 }
1341
1342 case SwFieldTypesEnum::Input:
1343 {
1344 if ((nSubType & 0x00ff) == INP_VAR)
1345 {
1346 SwSetExpFieldType* pTyp = static_cast<SwSetExpFieldType*>(
1347 pCurShell->GetFieldType(SwFieldIds::SetExp, rData.m_sPar1) );
1348
1349 // no Expression Type with this name existing -> create
1350 if(pTyp)
1351 {
1352 std::unique_ptr<SwSetExpField> pExpField(
1353 new SwSetExpField(pTyp, OUString(), nFormatId));
1354
1355 // Don't change type of SwSetExpFieldType:
1356 sal_uInt16 nOldSubType = pExpField->GetSubType();
1357 pExpField->SetSubType(nOldSubType | (nSubType & 0xff00));
1358
1359 pExpField->SetPromptText(rData.m_sPar2);
1360 pExpField->SetInputFlag(true) ;
1361 bExp = true;
1362 pField = std::move(pExpField);
1363 }
1364 else
1365 return false;
1366 }
1367 else
1368 {
1369 SwInputFieldType* pTyp =
1370 static_cast<SwInputFieldType*>( pCurShell->GetFieldType(0, SwFieldIds::Input) );
1371
1372 pField.reset(
1373 new SwInputField( pTyp, rData.m_sPar1, rData.m_sPar2, nSubType|nsSwExtendedSubType::SUB_INVISIBLE, nFormatId));
1374 }
1375 break;
1376 }
1377
1378 case SwFieldTypesEnum::Set:
1379 {
1380 if (rData.m_sPar2.isEmpty()) // empty variables are not allowed
1381 return false;
1382
1383 SwSetExpFieldType* pTyp = static_cast<SwSetExpFieldType*>( pCurShell->InsertFieldType(
1384 SwSetExpFieldType(pCurShell->GetDoc(), rData.m_sPar1) ) );
1385
1386 std::unique_ptr<SwSetExpField> pExpField(new SwSetExpField( pTyp, rData.m_sPar2, nFormatId));
1387 pExpField->SetSubType(nSubType);
1388 pExpField->SetPar2(rData.m_sPar2);
1389 bExp = true;
1390 pField = std::move(pExpField);
1391 break;
1392 }
1393
1394 case SwFieldTypesEnum::Sequence:
1395 {
1396 SwSetExpFieldType* pTyp = static_cast<SwSetExpFieldType*>( pCurShell->InsertFieldType(
1397 SwSetExpFieldType(pCurShell->GetDoc(), rData.m_sPar1, nsSwGetSetExpType::GSE_SEQ)));
1398
1399 sal_uInt8 nLevel = static_cast< sal_uInt8 >(nSubType & 0xff);
1400
1401 pTyp->SetOutlineLvl(nLevel);
1402 if (nLevel != 0x7f && cSeparator == 0)
1403 cSeparator = '.';
1404
1405 pTyp->SetDelimiter(OUString(cSeparator));
1406 pField.reset(new SwSetExpField(pTyp, rData.m_sPar2, nFormatId));
1407 bExp = true;
1408 break;
1409 }
1410
1411 case SwFieldTypesEnum::Get:
1412 {
1413 // is there a corresponding SetField
1414 SwSetExpFieldType* pSetTyp = static_cast<SwSetExpFieldType*>(
1415 pCurShell->GetFieldType(SwFieldIds::SetExp, rData.m_sPar1));
1416
1417 if(pSetTyp)
1418 {
1419 SwGetExpFieldType* pTyp = static_cast<SwGetExpFieldType*>( pCurShell->GetFieldType(
1420 0, SwFieldIds::GetExp) );
1421 pField.reset( new SwGetExpField(pTyp, rData.m_sPar1, pSetTyp->GetType(), nFormatId) );
1422 pField->SetSubType(nSubType | pSetTyp->GetType());
1423 bExp = true;
1424 }
1425 else
1426 return false;
1427 break;
1428 }
1429
1430 case SwFieldTypesEnum::Formel:
1431 {
1432 if(pCurShell->GetFrameType(nullptr,false) & FrameTypeFlags::TABLE)
1433 {
1434 pCurShell->StartAllAction();
1435
1436 SvNumberFormatter* pFormatter = pCurShell->GetDoc()->GetNumberFormatter();
1437 const SvNumberformat* pEntry = pFormatter->GetEntry(nFormatId);
1438
1439 if (pEntry)
1440 {
1441 SfxStringItem aFormat(FN_NUMBER_FORMAT, pEntry->GetFormatstring());
1442 pCurShell->GetView().GetViewFrame().GetDispatcher()->
1443 ExecuteList(FN_NUMBER_FORMAT, SfxCallMode::SYNCHRON,
1444 { &aFormat });
1445 }
1446
1447 SfxItemSet aBoxSet(SfxItemSet::makeFixedSfxItemSet<RES_BOXATR_FORMULA, RES_BOXATR_FORMULA>(pCurShell->GetAttrPool()));
1448
1449 OUString sFormula(comphelper::string::stripStart(rData.m_sPar2, ' '));
1450 if ( sFormula.startsWith("=") )
1451 {
1452 sFormula = sFormula.copy(1);
1453 }
1454
1455 aBoxSet.Put( SwTableBoxFormula( sFormula ));
1456 pCurShell->SetTableBoxFormulaAttrs( aBoxSet );
1457 pCurShell->UpdateTable();
1458
1459 pCurShell->EndAllAction();
1460 return true;
1461
1462 }
1463 else
1464 {
1465 SwGetExpFieldType* pTyp = static_cast<SwGetExpFieldType*>(
1466 pCurShell->GetFieldType(0, SwFieldIds::GetExp) );
1467 pField.reset( new SwGetExpField(pTyp, rData.m_sPar2, nsSwGetSetExpType::GSE_FORMULA, nFormatId) );
1468 pField->SetSubType(nSubType);
1469 bExp = true;
1470 }
1471 break;
1472 }
1473 case SwFieldTypesEnum::SetRefPage:
1474 pField.reset( new SwRefPageSetField( static_cast<SwRefPageSetFieldType*>(
1475 pCurShell->GetFieldType( 0, SwFieldIds::RefPageSet ) ),
1476 static_cast<short>(rData.m_sPar2.toInt32()), 0 != nSubType ) );
1477 bPageVar = true;
1478 break;
1479
1480 case SwFieldTypesEnum::GetRefPage:
1481 pField.reset( new SwRefPageGetField( static_cast<SwRefPageGetFieldType*>(
1482 pCurShell->GetFieldType( 0, SwFieldIds::RefPageGet ) ), nFormatId ) );
1483 bPageVar = true;
1484 break;
1485 case SwFieldTypesEnum::Dropdown :
1486 {
1487 pField.reset( new SwDropDownField(pCurShell->GetFieldType( 0, SwFieldIds::Dropdown )) );
1488 const sal_Int32 nTokenCount = comphelper::string::getTokenCount(rData.m_sPar2, DB_DELIM);
1489 Sequence<OUString> aEntries(nTokenCount);
1490 OUString* pArray = aEntries.getArray();
1491 for(sal_Int32 nToken = 0, nIdx = 0; nToken < nTokenCount; nToken++)
1492 pArray[nToken] = rData.m_sPar2.getToken(0, DB_DELIM, nIdx);
1493 static_cast<SwDropDownField*>(pField.get())->SetItems(aEntries);
1494 static_cast<SwDropDownField*>(pField.get())->SetName(rData.m_sPar1);
1495 }
1496 break;
1497
1498 // Insert Paragraph Signature field by signing the paragraph.
1499 // The resulting field is really a metadata field, created and added via signing.
1500 case SwFieldTypesEnum::ParagraphSignature:
1501 pCurShell->SignParagraph();
1502 return true;
1503
1504 default:
1505 { OSL_ENSURE(false, "wrong field type");
1506 return false;
1507 }
1508 }
1509 OSL_ENSURE(pField, "field not available");
1510
1511 //the auto language flag has to be set prior to the language!
1512 pField->SetAutomaticLanguage(rData.m_bIsAutomaticLanguage);
1513 LanguageType nLang = GetCurrLanguage();
1514 pField->SetLanguage(nLang);
1515
1516 // insert
1517 pCurShell->StartAllAction();
1518
1519 bool const isSuccess = pCurShell->InsertField2(*pField, rData.m_oAnnotationRange ? &*rData.m_oAnnotationRange : nullptr);
1520
1521 if (isSuccess)
1522 {
1523 if (SwFieldTypesEnum::Input == rData.m_nTypeId)
1524 {
1525 pCurShell->Push();
1526
1527 // start dialog, not before the field is inserted tdf#99529
1528 pCurShell->Left(SwCursorSkipMode::Chars, false,
1529 (INP_VAR == (nSubType & 0xff) || pCurShell->GetViewOptions()->IsFieldName()) ? 1 : 2,
1530 false);
1531 pCurShell->StartInputFieldDlg(pField.get(), false, true, rData.m_pParent);
1532
1533 pCurShell->Pop(SwCursorShell::PopMode::DeleteCurrent);
1534 }
1535
1536 if (bExp && m_bEvalExp)
1537 {
1538 pCurShell->UpdateExpFields(true);
1539 }
1540
1541 if (bTable)
1542 {
1543 pCurShell->Left(SwCursorSkipMode::Chars, false, 1, false );
1544 pCurShell->UpdateOneField(*pField);
1545 pCurShell->Right(SwCursorSkipMode::Chars, false, 1, false );
1546 }
1547 else if (bPageVar)
1548 {
1549 static_cast<SwRefPageGetFieldType*>(pCurShell->GetFieldType(0, SwFieldIds::RefPageGet))->UpdateFields();
1550 }
1551 else if (SwFieldTypesEnum::GetRef == rData.m_nTypeId)
1552 {
1553 pField->GetTyp()->UpdateFields();
1554 }
1555 }
1556
1557 // delete temporary field
1558 pField.reset();
1559
1560 pCurShell->EndAllAction();
1561 return isSuccess;
1562 }
1563
1564 // fields update
1565 void SwFieldMgr::UpdateCurField(sal_uInt32 nFormat,
1566 const OUString& rPar1,
1567 const OUString& rPar2,
1568 std::unique_ptr<SwField> pTmpField)
1569 {
1570 // change format
1571 OSL_ENSURE(m_pCurField, "no field at CursorPos");
1572
1573 if (!pTmpField)
1574 pTmpField = m_pCurField->CopyField();
1575
1576 SwFieldType* pType = pTmpField->GetTyp();
1577 const SwFieldTypesEnum nTypeId = pTmpField->GetTypeId();
1578
1579 SwWrtShell* pSh = m_pWrtShell ? m_pWrtShell : ::lcl_GetShell();
1580 OSL_ENSURE(pSh, "no SwWrtShell found");
1581 if(!pSh)
1582 return;
1583 pSh->StartAllAction();
1584
1585 bool bSetPar2 = true;
1586 bool bSetPar1 = true;
1587 OUString sPar2( rPar2 );
1588
1589 // Order to Format
1590 switch( nTypeId )
1591 {
1592 case SwFieldTypesEnum::DDE:
1593 {
1594 // DDE-Topics/-Items can have blanks in their names!
1595 // That's not yet considered here!
1596 sal_Int32 nIndex = 0;
1597 sPar2 = sPar2.replaceFirst(" ", OUStringChar(sfx2::cTokenSeparator), &nIndex );
1598 if (nIndex>=0 && ++nIndex<sPar2.getLength())
1599 {
1600 sPar2 = sPar2.replaceFirst(" ", OUStringChar(sfx2::cTokenSeparator), &nIndex);
1601 }
1602 break;
1603 }
1604
1605 case SwFieldTypesEnum::Chapter:
1606 {
1607 sal_uInt16 nByte = o3tl::narrowing<sal_uInt16>(rPar2.toInt32());
1608 nByte = std::max(sal_uInt16(1), nByte);
1609 nByte = std::min(nByte, sal_uInt16(MAXLEVEL));
1610 nByte -= 1;
1611 static_cast<SwChapterField*>(pTmpField.get())->SetLevel(static_cast<sal_uInt8>(nByte));
1612 bSetPar2 = false;
1613 break;
1614 }
1615
1616 case SwFieldTypesEnum::Script:
1617 static_cast<SwScriptField*>(pTmpField.get())->SetCodeURL(static_cast<bool>(nFormat));
1618 break;
1619
1620 case SwFieldTypesEnum::NextPage:
1621 if( SVX_NUM_CHAR_SPECIAL == nFormat )
1622 {
1623 static_cast<SwPageNumberField*>(m_pCurField)->SetUserString( sPar2 );
1624 sPar2 = "1";
1625 }
1626 else
1627 {
1628 if( nFormat + 2 == SVX_NUM_PAGEDESC )
1629 nFormat = SVX_NUM_PAGEDESC;
1630 short nOff = static_cast<short>(sPar2.toInt32());
1631 nOff += 1;
1632 sPar2 = OUString::number(nOff);
1633 }
1634 break;
1635
1636 case SwFieldTypesEnum::PreviousPage:
1637 if( SVX_NUM_CHAR_SPECIAL == nFormat )
1638 {
1639 static_cast<SwPageNumberField*>(m_pCurField)->SetUserString( sPar2 );
1640 sPar2 = "-1";
1641 }
1642 else
1643 {
1644 if( nFormat + 2 == SVX_NUM_PAGEDESC )
1645 nFormat = SVX_NUM_PAGEDESC;
1646 short nOff = static_cast<short>(sPar2.toInt32());
1647 nOff -= 1;
1648 sPar2 = OUString::number(nOff);
1649 }
1650 break;
1651
1652 case SwFieldTypesEnum::PageNumber:
1653 case SwFieldTypesEnum::GetRefPage:
1654 if( nFormat + 2 == SVX_NUM_PAGEDESC )
1655 nFormat = SVX_NUM_PAGEDESC;
1656 break;
1657
1658 case SwFieldTypesEnum::GetRef:
1659 {
1660 bSetPar2 = false;
1661 sal_Int16 nSubType = o3tl::narrowing<sal_uInt16>(rPar2.toInt32());
1662 static_cast<SwGetRefField*>(pTmpField.get())->SetSubType( nSubType );
1663 const sal_Int32 nPos = rPar2.indexOf( '|' );
1664 if( nPos>=0 )
1665 switch (nSubType) {
1666 case REF_STYLE:
1667 static_cast<SwGetRefField*>(pTmpField.get())->SetFlags( o3tl::narrowing<sal_uInt16>(o3tl::toInt32(rPar2.subView( nPos + 1 ))));
1668 break;
1669 default:
1670 static_cast<SwGetRefField*>(pTmpField.get())->SetSeqNo( o3tl::narrowing<sal_uInt16>(o3tl::toInt32(rPar2.subView( nPos + 1 ))));
1671 }
1672 }
1673 break;
1674 case SwFieldTypesEnum::Dropdown:
1675 {
1676 sal_Int32 nTokenCount = comphelper::string::getTokenCount(sPar2, DB_DELIM);
1677 Sequence<OUString> aEntries(nTokenCount);
1678 OUString* pArray = aEntries.getArray();
1679 for(sal_Int32 nToken = 0, nIdx = 0; nToken < nTokenCount; nToken++)
1680 pArray[nToken] = sPar2.getToken(0, DB_DELIM, nIdx);
1681 static_cast<SwDropDownField*>(pTmpField.get())->SetItems(aEntries);
1682 static_cast<SwDropDownField*>(pTmpField.get())->SetName(rPar1);
1683 bSetPar1 = bSetPar2 = false;
1684 }
1685 break;
1686 case SwFieldTypesEnum::Authority :
1687 {
1688 //#i99069# changes to a bibliography field should change the field type
1689 SwAuthorityField* pAuthorityField = static_cast<SwAuthorityField*>(pTmpField.get());
1690 SwAuthorityFieldType* pAuthorityType = static_cast<SwAuthorityFieldType*>(pType);
1691 rtl::Reference<SwAuthEntry> xTempEntry(new SwAuthEntry);
1692 for( sal_Int32 i = 0, nIdx = 0; i < AUTH_FIELD_END; ++i )
1693 xTempEntry->SetAuthorField( static_cast<ToxAuthorityField>(i),
1694 rPar1.getToken( 0, TOX_STYLE_DELIMITER, nIdx ));
1695
1696 // If just the page number of the URL changed, then update the current field and not
1697 // others.
1698 bool bEquivalent = true;
1699 for (int i = 0; i < AUTH_FIELD_END; ++i)
1700 {
1701 auto eField = static_cast<ToxAuthorityField>(i);
1702 if (eField == AUTH_FIELD_URL)
1703 {
1704 if (SwTOXAuthority::GetSourceURL(xTempEntry->GetAuthorField(AUTH_FIELD_URL))
1705 != SwTOXAuthority::GetSourceURL(
1706 pAuthorityField->GetFieldText(AUTH_FIELD_URL)))
1707 {
1708 bEquivalent = false;
1709 break;
1710 }
1711 }
1712 else
1713 {
1714 if (xTempEntry->GetAuthorField(eField) != pAuthorityField->GetFieldText(eField))
1715 {
1716 bEquivalent = false;
1717 break;
1718 }
1719 }
1720 }
1721
1722 if (bEquivalent)
1723 {
1724 break;
1725 }
1726
1727 if( pAuthorityType->ChangeEntryContent( xTempEntry.get() ) )
1728 {
1729 pType->UpdateFields();
1730 pSh->SetModified();
1731 }
1732
1733 if( xTempEntry->GetAuthorField( AUTH_FIELD_IDENTIFIER ) ==
1734 pAuthorityField->GetFieldText( AUTH_FIELD_IDENTIFIER ) )
1735 bSetPar1 = false; //otherwise it's a new or changed entry, the field needs to be updated
1736 bSetPar2 = false;
1737 }
1738 break;
1739 default: break;
1740 }
1741
1742 // set format
1743 // setup format before SetPar2 because of NumberFormatter!
1744 pTmpField->ChangeFormat(nFormat);
1745
1746 if( bSetPar1 )
1747 pTmpField->SetPar1( rPar1 );
1748 if( bSetPar2 )
1749 pTmpField->SetPar2( sPar2 );
1750
1751 // kick off update
1752 if(nTypeId == SwFieldTypesEnum::DDE ||
1753 nTypeId == SwFieldTypesEnum::User ||
1754 nTypeId == SwFieldTypesEnum::UserInput)
1755 {
1756 pType->UpdateFields();
1757 pSh->SetModified();
1758 }
1759 else {
1760 // mb: #32157
1761 pSh->SwEditShell::UpdateOneField(*pTmpField);
1762 GetCurField();
1763 }
1764
1765 pTmpField.reset();
1766
1767 pSh->EndAllAction();
1768 }
1769
1770 // explicitly evaluate ExpressionFields
1771 void SwFieldMgr::EvalExpFields(SwWrtShell* pSh)
1772 {
1773 if (pSh == nullptr)
1774 pSh = m_pWrtShell ? m_pWrtShell : ::lcl_GetShell();
1775
1776 if(pSh)
1777 {
1778 pSh->StartAllAction();
1779 pSh->UpdateExpFields(true);
1780 pSh->EndAllAction();
1781 }
1782 }
1783 LanguageType SwFieldMgr::GetCurrLanguage() const
1784 {
1785 SwWrtShell* pSh = m_pWrtShell ? m_pWrtShell : ::lcl_GetShell();
1786 if( pSh )
1787 return pSh->GetCurLang();
1788 return SvtSysLocale().GetLanguageTag().getLanguageType();
1789 }
1790
1791 void SwFieldType::GetFieldName_()
1792 {
1793 static const TranslateId coFieldNms[] =
1794 {
1795 FLD_DATE_STD,
1796 FLD_TIME_STD,
1797 STR_FILENAMEFLD,
1798 STR_DBNAMEFLD,
1799 STR_CHAPTERFLD,
1800 STR_PAGENUMBERFLD,
1801 STR_DOCSTATFLD,
1802 STR_AUTHORFLD,
1803 STR_SETFLD,
1804 STR_GETFLD,
1805 STR_FORMELFLD,
1806 STR_HIDDENTXTFLD,
1807 STR_SETREFFLD,
1808 STR_GETREFFLD,
1809 STR_DDEFLD,
1810 STR_MACROFLD,
1811 STR_INPUTFLD,
1812 STR_HIDDENPARAFLD,
1813 STR_DOCINFOFLD,
1814 STR_DBFLD,
1815 STR_USERFLD,
1816 STR_POSTITFLD,
1817 STR_TEMPLNAMEFLD,
1818 STR_SEQFLD,
1819 STR_DBNEXTSETFLD,
1820 STR_DBNUMSETFLD,
1821 STR_DBSETNUMBERFLD,
1822 STR_CONDTXTFLD,
1823 STR_NEXTPAGEFLD,
1824 STR_PREVPAGEFLD,
1825 STR_EXTUSERFLD,
1826 FLD_DATE_FIX,
1827 FLD_TIME_FIX,
1828 STR_SETINPUTFLD,
1829 STR_USRINPUTFLD,
1830 STR_SETREFPAGEFLD,
1831 STR_GETREFPAGEFLD,
1832 STR_INTERNETFLD,
1833 STR_JUMPEDITFLD,
1834 STR_SCRIPTFLD,
1835 STR_AUTHORITY,
1836 STR_COMBINED_CHARS,
1837 STR_DROPDOWN,
1838 STR_CUSTOM_FIELD,
1839 STR_PARAGRAPH_SIGNATURE
1840 };
1841
1842 // insert infos for fields
1843 SwFieldType::s_pFieldNames = new std::vector<OUString>;
1844 SwFieldType::s_pFieldNames->reserve(SAL_N_ELEMENTS(coFieldNms));
1845 for (const TranslateId & id : coFieldNms)
1846 {
1847 const OUString aTmp(SwResId(id));
1848 SwFieldType::s_pFieldNames->push_back(MnemonicGenerator::EraseAllMnemonicChars( aTmp ));
1849 }
1850 }
1851
1852 bool SwFieldMgr::ChooseMacro(weld::Window* pDialogParent)
1853 {
1854 bool bRet = false;
1855
1856 // choose script dialog
1857 OUString aScriptURL = SfxApplication::ChooseScript(pDialogParent);
1858
1859 // the script selector dialog returns a valid script URL
1860 if ( !aScriptURL.isEmpty() )
1861 {
1862 SetMacroPath( aScriptURL );
1863 bRet = true;
1864 }
1865
1866 return bRet;
1867 }
1868
1869 void SwFieldMgr::SetMacroPath(const OUString& rPath)
1870 {
1871 m_sMacroPath = rPath;
1872 m_sMacroName = rPath;
1873
1874 // try to set sMacroName member variable by parsing the macro path
1875 // using the new URI parsing services
1876
1877 const Reference< XComponentContext >& xContext =
1878 ::comphelper::getProcessComponentContext();
1879
1880 Reference< uri::XUriReferenceFactory >
1881 xFactory = uri::UriReferenceFactory::create( xContext );
1882
1883 Reference< uri::XVndSunStarScriptUrl >
1884 xUrl( xFactory->parse( m_sMacroPath ), UNO_QUERY );
1885
1886 if ( xUrl.is() )
1887 {
1888 m_sMacroName = xUrl->getName();
1889 }
1890 }
1891
1892 sal_uInt32 SwFieldMgr::GetDefaultFormat(SwFieldTypesEnum nTypeId, bool bIsText, SvNumberFormatter* pFormatter)
1893 {
1894 SvNumFormatType nDefFormat;
1895
1896 switch (nTypeId)
1897 {
1898 case SwFieldTypesEnum::Time:
1899 case SwFieldTypesEnum::Date:
1900 {
1901 nDefFormat = (nTypeId == SwFieldTypesEnum::Date) ? SvNumFormatType::DATE : SvNumFormatType::TIME;
1902 }
1903 break;
1904
1905 default:
1906 if (bIsText)
1907 {
1908 nDefFormat = SvNumFormatType::TEXT;
1909 }
1910 else
1911 {
1912 nDefFormat = SvNumFormatType::ALL;
1913 }
1914 break;
1915 }
1916
1917 return pFormatter->GetStandardFormat(nDefFormat, GetCurrLanguage());
1918 }
1919
1920 Reference<XNumberingTypeInfo> const & SwFieldMgr::GetNumberingInfo() const
1921 {
1922 if(!m_xNumberingInfo.is())
1923 {
1924 const Reference<XComponentContext>& xContext( ::comphelper::getProcessComponentContext() );
1925 Reference<XDefaultNumberingProvider> xDefNum = text::DefaultNumberingProvider::create(xContext);
1926 const_cast<SwFieldMgr*>(this)->m_xNumberingInfo.set(xDefNum, UNO_QUERY);
1927 }
1928 return m_xNumberingInfo;
1929 }
1930
1931 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE