Line data Source code
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 :
22 : #include <cmdid.h>
23 : #include <hintids.hxx>
24 : #include <svl/stritem.hxx>
25 : #include <com/sun/star/lang/XMultiServiceFactory.hpp>
26 : #include <com/sun/star/container/XNameAccess.hpp>
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 <editeng/unolingu.hxx>
39 : #include <unotools/localedatawrapper.hxx>
40 : #include <sfx2/dispatch.hxx>
41 : #include <sfx2/objsh.hxx>
42 : #include <sfx2/linkmgr.hxx>
43 : #include <sfx2/app.hxx>
44 : #include <basic/basmgr.hxx>
45 : #include <editeng/langitem.hxx>
46 : #include <svl/macitem.hxx>
47 : #include <basic/sbmod.hxx>
48 : #include <fmtrfmrk.hxx>
49 : #include <basic/sbmeth.hxx>
50 : #include <basic/sbx.hxx>
51 : #include <svl/zforlist.hxx>
52 : #include <svl/zformat.hxx>
53 : #include <vcl/mnemonic.hxx>
54 : #include <view.hxx>
55 : #include <wrtsh.hxx>
56 : #include <doc.hxx>
57 : #include <docsh.hxx>
58 : #include <swmodule.hxx>
59 : #include <charatr.hxx>
60 : #include <fmtinfmt.hxx>
61 : #include <cellatr.hxx>
62 : #include <dbmgr.hxx>
63 : #include <shellres.hxx>
64 : #include <fldbas.hxx>
65 : #include <docufld.hxx>
66 : #include <chpfld.hxx>
67 : #include <ddefld.hxx>
68 : #include <expfld.hxx>
69 : #include <reffld.hxx>
70 : #include <usrfld.hxx>
71 : #include <dbfld.hxx>
72 : #include <authfld.hxx>
73 : #include <flddat.hxx>
74 : #include <fldmgr.hxx>
75 : #include <crsskip.hxx>
76 : #include <flddropdown.hxx>
77 : #include <fldui.hrc>
78 : #include <tox.hxx>
79 : #include <misc.hrc>
80 : #include <cnttab.hxx>
81 : #include <unotools/useroptions.hxx>
82 :
83 : using namespace com::sun::star::uno;
84 : using namespace com::sun::star::container;
85 : using namespace com::sun::star::lang;
86 : using namespace com::sun::star::beans;
87 : using namespace com::sun::star::text;
88 : using namespace com::sun::star::style;
89 : using namespace com::sun::star::sdbc;
90 : using namespace ::com::sun::star;
91 : using namespace nsSwDocInfoSubType;
92 :
93 : // groups of fields
94 : enum
95 : {
96 : GRP_DOC_BEGIN = 0,
97 : GRP_DOC_END = GRP_DOC_BEGIN + 11,
98 :
99 : GRP_FKT_BEGIN = GRP_DOC_END,
100 : GRP_FKT_END = GRP_FKT_BEGIN + 8,
101 :
102 : GRP_REF_BEGIN = GRP_FKT_END,
103 : GRP_REF_END = GRP_REF_BEGIN + 2,
104 :
105 : GRP_REG_BEGIN = GRP_REF_END,
106 : GRP_REG_END = GRP_REG_BEGIN + 1,
107 :
108 : GRP_DB_BEGIN = GRP_REG_END,
109 : GRP_DB_END = GRP_DB_BEGIN + 5,
110 :
111 : GRP_VAR_BEGIN = GRP_DB_END,
112 : GRP_VAR_END = GRP_VAR_BEGIN + 9
113 : };
114 :
115 : enum
116 : {
117 : GRP_WEB_DOC_BEGIN = 0,
118 : GRP_WEB_DOC_END = GRP_WEB_DOC_BEGIN + 9,
119 :
120 : GRP_WEB_FKT_BEGIN = GRP_WEB_DOC_END + 2,
121 : GRP_WEB_FKT_END = GRP_WEB_FKT_BEGIN + 0, // the group is empty!
122 :
123 : GRP_WEB_REF_BEGIN = GRP_WEB_FKT_END + 6, // the group is empty!
124 : GRP_WEB_REF_END = GRP_WEB_REF_BEGIN + 0,
125 :
126 : GRP_WEB_REG_BEGIN = GRP_WEB_REF_END + 2,
127 : GRP_WEB_REG_END = GRP_WEB_REG_BEGIN + 1,
128 :
129 : GRP_WEB_DB_BEGIN = GRP_WEB_REG_END, // the group is empty!
130 : GRP_WEB_DB_END = GRP_WEB_DB_BEGIN + 0,
131 :
132 : GRP_WEB_VAR_BEGIN = GRP_WEB_DB_END + 5,
133 : GRP_WEB_VAR_END = GRP_WEB_VAR_BEGIN + 1
134 : };
135 :
136 : static const sal_uInt16 VF_COUNT = 1; // { 0 }
137 : static const sal_uInt16 VF_USR_COUNT = 2; // { 0, nsSwExtendedSubType::SUB_CMD }
138 : static const sal_uInt16 VF_DB_COUNT = 1; // { nsSwExtendedSubType::SUB_OWN_FMT }
139 :
140 : // field types and subtypes
141 : struct SwFieldPack
142 : {
143 : sal_uInt16 nTypeId;
144 :
145 : sal_uInt16 nSubTypeStart;
146 : sal_uInt16 nSubTypeEnd;
147 :
148 : sal_uLong nFormatBegin;
149 : sal_uLong nFormatEnd;
150 : };
151 :
152 : // strings and formats
153 : static const SwFieldPack aSwFields[] =
154 : {
155 : // Document
156 : { TYP_EXTUSERFLD, FLD_EU_BEGIN, FLD_EU_END, 0, 0 },
157 : { TYP_AUTHORFLD, 0, 0, FMT_AUTHOR_BEGIN, FMT_AUTHOR_END },
158 : { TYP_DATEFLD, FLD_DATE_BEGIN, FLD_DATE_END, 0, 0 },
159 : { TYP_TIMEFLD, FLD_TIME_BEGIN, FLD_TIME_END, 0, 0 },
160 : { TYP_PAGENUMBERFLD, 0, 0, FMT_NUM_BEGIN, FMT_NUM_END-1 },
161 : { TYP_NEXTPAGEFLD, 0, 0, FMT_NUM_BEGIN, FMT_NUM_END },
162 : { TYP_PREVPAGEFLD, 0, 0, FMT_NUM_BEGIN, FMT_NUM_END },
163 : { TYP_FILENAMEFLD, 0, 0, FMT_FF_BEGIN, FMT_FF_END },
164 : { TYP_DOCSTATFLD, FLD_STAT_BEGIN, FLD_STAT_END, FMT_NUM_BEGIN, FMT_NUM_END-1 },
165 :
166 : { TYP_CHAPTERFLD, 0, 0, FMT_CHAPTER_BEGIN, FMT_CHAPTER_END },
167 : { TYP_TEMPLNAMEFLD, 0, 0, FMT_FF_BEGIN, FMT_FF_END },
168 :
169 : // Functions
170 : { TYP_CONDTXTFLD, 0, 0, 0, 0 },
171 : { TYP_DROPDOWN, 0, 0, 0, 0 },
172 : { TYP_INPUTFLD, FLD_INPUT_BEGIN, FLD_INPUT_END, 0, 0 },
173 : { TYP_MACROFLD, 0, 0, 0, 0 },
174 : { TYP_JUMPEDITFLD, 0, 0, FMT_MARK_BEGIN, FMT_MARK_END },
175 : { TYP_COMBINED_CHARS, 0, 0, 0, 0 },
176 : { TYP_HIDDENTXTFLD, 0, 0, 0, 0 },
177 : { TYP_HIDDENPARAFLD, 0, 0, 0, 0 },
178 :
179 : // Cross-References
180 : { TYP_SETREFFLD, 0, 0, 0, 0 },
181 : { TYP_GETREFFLD, 0, 0, FMT_REF_BEGIN, FMT_REF_END },
182 :
183 : // DocInformation
184 : { TYP_DOCINFOFLD, 0, 0, FMT_REG_BEGIN, FMT_REG_END },
185 :
186 : // Database
187 : { TYP_DBFLD, 0, 0, FMT_DBFLD_BEGIN, FMT_DBFLD_END },
188 : { TYP_DBNEXTSETFLD, 0, 0, 0, 0 },
189 : { TYP_DBNUMSETFLD, 0, 0, 0, 0 },
190 : { TYP_DBSETNUMBERFLD, 0, 0, FMT_NUM_BEGIN, FMT_NUM_END-2 },
191 : { TYP_DBNAMEFLD, 0, 0, 0, 0 },
192 :
193 : // Variables
194 : { TYP_SETFLD, 0, 0, FMT_SETVAR_BEGIN, FMT_SETVAR_END },
195 :
196 : { TYP_GETFLD, 0, 0, FMT_GETVAR_BEGIN, FMT_GETVAR_END },
197 : { TYP_DDEFLD, 0, 0, FMT_DDE_BEGIN, FMT_DDE_END },
198 : { TYP_FORMELFLD, 0, 0, FMT_GETVAR_BEGIN, FMT_GETVAR_END },
199 : { TYP_INPUTFLD, FLD_INPUT_BEGIN, FLD_INPUT_END, 0, 0 },
200 : { TYP_SEQFLD, 0, 0, FMT_NUM_BEGIN, FMT_NUM_END-2 },
201 : { TYP_SETREFPAGEFLD, FLD_PAGEREF_BEGIN, FLD_PAGEREF_END,0, 0 },
202 : { TYP_GETREFPAGEFLD, 0, 0, FMT_NUM_BEGIN, FMT_NUM_END-1 },
203 : { TYP_USERFLD, 0, 0, FMT_USERVAR_BEGIN, FMT_USERVAR_END }
204 : };
205 :
206 : // access to the shell
207 0 : static SwWrtShell* lcl_GetShell()
208 : {
209 : SwView* pView;
210 0 : if ( 0 != (pView = ::GetActiveView()) )
211 0 : return pView->GetWrtShellPtr();
212 : OSL_FAIL("no current shell found!");
213 0 : return 0;
214 : }
215 :
216 0 : inline sal_uInt16 GetPackCount() { return sizeof(aSwFields) / sizeof(SwFieldPack); }
217 :
218 : // FieldManager controls inserting and updating of fields
219 0 : SwFieldMgr::SwFieldMgr(SwWrtShell* pSh ) :
220 : pModule(0),
221 : pMacroItem(0),
222 : pWrtShell(pSh),
223 0 : bEvalExp(true)
224 : {
225 : // determine current field if existing
226 0 : GetCurField();
227 0 : }
228 :
229 0 : SwFieldMgr::~SwFieldMgr()
230 : {
231 0 : }
232 :
233 : // organise RefMark by names
234 0 : bool SwFieldMgr::CanInsertRefMark( const OUString& rStr )
235 : {
236 0 : bool bRet = false;
237 0 : SwWrtShell *pSh = pWrtShell ? pWrtShell : lcl_GetShell();
238 : OSL_ENSURE(pSh, "no SwWrtShell found");
239 0 : if(pSh)
240 : {
241 0 : sal_uInt16 nCnt = pSh->GetCrsrCnt();
242 :
243 : // the last Crsr doesn't have to be a spanned selection
244 0 : if( 1 < nCnt && !pSh->SwCrsrShell::HasSelection() )
245 0 : --nCnt;
246 :
247 0 : bRet = 2 > nCnt && 0 == pSh->GetRefMark( rStr );
248 : }
249 0 : return bRet;
250 : }
251 :
252 : // access over ResIds
253 0 : void SwFieldMgr::RemoveFieldType(sal_uInt16 nResId, const OUString& rName )
254 : {
255 0 : SwWrtShell * pSh = pWrtShell ? pWrtShell : lcl_GetShell();
256 : OSL_ENSURE(pSh, "no SwWrtShell found");
257 0 : if( pSh )
258 0 : pSh->RemoveFieldType(nResId, rName);
259 0 : }
260 :
261 0 : size_t SwFieldMgr::GetFieldTypeCount(sal_uInt16 nResId) const
262 : {
263 0 : SwWrtShell * pSh = pWrtShell ? pWrtShell : lcl_GetShell();
264 : OSL_ENSURE(pSh, "no SwWrtShell found");
265 0 : return pSh ? pSh->GetFieldTypeCount(nResId) : 0;
266 : }
267 :
268 0 : SwFieldType* SwFieldMgr::GetFieldType(sal_uInt16 nResId, size_t nField) const
269 : {
270 0 : SwWrtShell * pSh = pWrtShell ? pWrtShell : lcl_GetShell();
271 : OSL_ENSURE(pSh, "no SwWrtShell found");
272 0 : return pSh ? pSh->GetFieldType(nField, nResId) : 0;
273 : }
274 :
275 0 : SwFieldType* SwFieldMgr::GetFieldType(sal_uInt16 nResId, const OUString& rName) const
276 : {
277 0 : SwWrtShell * pSh = pWrtShell ? pWrtShell : lcl_GetShell();
278 : OSL_ENSURE(pSh, "no SwWrtShell found");
279 0 : return pSh ? pSh->GetFieldType(nResId, rName) : 0;
280 : }
281 :
282 : // determine current field
283 0 : SwField* SwFieldMgr::GetCurField()
284 : {
285 0 : SwWrtShell *pSh = pWrtShell ? pWrtShell : ::lcl_GetShell();
286 0 : if ( pSh )
287 0 : pCurField = pSh->GetCurField( true );
288 : else
289 0 : pCurField = NULL;
290 :
291 : // initialise strings and format
292 0 : aCurPar1.clear();
293 0 : aCurPar2.clear();
294 0 : sCurFrame.clear();
295 0 : nCurFormat = 0;
296 :
297 0 : if(!pCurField)
298 0 : return 0;
299 :
300 : // preprocess current values; determine parameter 1 and parameter 2
301 : // as well as the format
302 0 : const sal_uInt16 nTypeId = pCurField->GetTypeId();
303 :
304 0 : nCurFormat = pCurField->GetFormat();
305 0 : aCurPar1 = pCurField->GetPar1();
306 0 : aCurPar2 = pCurField->GetPar2();
307 :
308 0 : switch( nTypeId )
309 : {
310 : case TYP_PAGENUMBERFLD:
311 : case TYP_NEXTPAGEFLD:
312 : case TYP_PREVPAGEFLD:
313 : case TYP_GETREFPAGEFLD:
314 0 : if( nCurFormat == SVX_NUM_PAGEDESC )
315 0 : nCurFormat -= 2;
316 0 : break;
317 : }
318 0 : return pCurField;
319 : }
320 :
321 : // provide group range
322 0 : const SwFieldGroupRgn& SwFieldMgr::GetGroupRange(bool bHtmlMode, sal_uInt16 nGrpId)
323 : {
324 : static SwFieldGroupRgn const aRanges[] =
325 : {
326 : { /* Document */ GRP_DOC_BEGIN, GRP_DOC_END },
327 : { /* Functions */ GRP_FKT_BEGIN, GRP_FKT_END },
328 : { /* Cross-Refs */ GRP_REF_BEGIN, GRP_REF_END },
329 : { /* DocInfos */ GRP_REG_BEGIN, GRP_REG_END },
330 : { /* Database */ GRP_DB_BEGIN, GRP_DB_END },
331 : { /* User */ GRP_VAR_BEGIN, GRP_VAR_END }
332 : };
333 : static SwFieldGroupRgn const aWebRanges[] =
334 : {
335 : { /* Document */ GRP_WEB_DOC_BEGIN, GRP_WEB_DOC_END },
336 : { /* Functions */ GRP_WEB_FKT_BEGIN, GRP_WEB_FKT_END },
337 : { /* Cross-Refs */ GRP_WEB_REF_BEGIN, GRP_WEB_REF_END },
338 : { /* DocInfos */ GRP_WEB_REG_BEGIN, GRP_WEB_REG_END },
339 : { /* Database */ GRP_WEB_DB_BEGIN, GRP_WEB_DB_END },
340 : { /* User */ GRP_WEB_VAR_BEGIN, GRP_WEB_VAR_END }
341 : };
342 :
343 0 : if (bHtmlMode)
344 0 : return aWebRanges[(sal_uInt16)nGrpId];
345 : else
346 0 : return aRanges[(sal_uInt16)nGrpId];
347 : }
348 :
349 : // determine GroupId
350 0 : sal_uInt16 SwFieldMgr::GetGroup(bool bHtmlMode, sal_uInt16 nTypeId, sal_uInt16 nSubType)
351 : {
352 0 : if (nTypeId == TYP_SETINPFLD)
353 0 : nTypeId = TYP_SETFLD;
354 :
355 0 : if (nTypeId == TYP_INPUTFLD && (nSubType & INP_USR))
356 0 : nTypeId = TYP_USERFLD;
357 :
358 0 : if (nTypeId == TYP_FIXDATEFLD)
359 0 : nTypeId = TYP_DATEFLD;
360 :
361 0 : if (nTypeId == TYP_FIXTIMEFLD)
362 0 : nTypeId = TYP_TIMEFLD;
363 :
364 0 : for (sal_uInt16 i = GRP_DOC; i <= GRP_VAR; i++)
365 : {
366 0 : const SwFieldGroupRgn& rRange = GetGroupRange(bHtmlMode, i);
367 0 : for (sal_uInt16 nPos = rRange.nStart; nPos < rRange.nEnd; nPos++)
368 : {
369 0 : if (aSwFields[nPos].nTypeId == nTypeId)
370 0 : return i;
371 : }
372 : }
373 0 : return USHRT_MAX;
374 : }
375 :
376 : // determine names to TypeId
377 : // ACCESS over TYP_....
378 0 : sal_uInt16 SwFieldMgr::GetTypeId(sal_uInt16 nPos)
379 : {
380 : OSL_ENSURE(nPos < ::GetPackCount(), "forbidden Pos");
381 0 : return aSwFields[ nPos ].nTypeId;
382 : }
383 :
384 0 : OUString SwFieldMgr::GetTypeStr(sal_uInt16 nPos)
385 : {
386 : OSL_ENSURE(nPos < ::GetPackCount(), "forbidden TypeId");
387 :
388 0 : sal_uInt16 nFieldWh = aSwFields[ nPos ].nTypeId;
389 :
390 : // special treatment for date/time fields (without var/fix)
391 0 : if( TYP_DATEFLD == nFieldWh )
392 : {
393 0 : static OUString g_aDate( SW_RES( STR_DATEFLD ) );
394 0 : return g_aDate;
395 : }
396 0 : if( TYP_TIMEFLD == nFieldWh )
397 : {
398 0 : static OUString g_aTime( SW_RES( STR_TIMEFLD ) );
399 0 : return g_aTime;
400 : }
401 :
402 0 : return SwFieldType::GetTypeStr( nFieldWh );
403 : }
404 :
405 : // determine Pos in the list
406 0 : sal_uInt16 SwFieldMgr::GetPos(sal_uInt16 nTypeId)
407 : {
408 0 : switch( nTypeId )
409 : {
410 0 : case TYP_FIXDATEFLD: nTypeId = TYP_DATEFLD; break;
411 0 : case TYP_FIXTIMEFLD: nTypeId = TYP_TIMEFLD; break;
412 0 : case TYP_SETINPFLD: nTypeId = TYP_SETFLD; break;
413 0 : case TYP_USRINPFLD: nTypeId = TYP_USERFLD; break;
414 : }
415 :
416 0 : for(sal_uInt16 i = 0; i < GetPackCount(); i++)
417 0 : if(aSwFields[i].nTypeId == nTypeId)
418 0 : return i;
419 :
420 0 : return USHRT_MAX;
421 : }
422 :
423 : // localise subtypes of a field
424 0 : bool SwFieldMgr::GetSubTypes(sal_uInt16 nTypeId, std::vector<OUString>& rToFill)
425 : {
426 0 : bool bRet = false;
427 0 : SwWrtShell *pSh = pWrtShell ? pWrtShell : lcl_GetShell();
428 : OSL_ENSURE(pSh, "no SwWrtShell found");
429 0 : if(pSh)
430 : {
431 0 : const sal_uInt16 nPos = GetPos(nTypeId);
432 :
433 0 : switch(nTypeId)
434 : {
435 : case TYP_SETREFFLD:
436 : case TYP_GETREFFLD:
437 : {
438 : // references are no fields
439 0 : pSh->GetRefMarks( &rToFill );
440 0 : break;
441 : }
442 : case TYP_MACROFLD:
443 : {
444 0 : break;
445 : }
446 : case TYP_INPUTFLD:
447 : {
448 0 : rToFill.push_back(SW_RES(aSwFields[nPos].nSubTypeStart));
449 : // move on at generic types
450 : }
451 : case TYP_DDEFLD:
452 : case TYP_SEQFLD:
453 : case TYP_FORMELFLD:
454 : case TYP_GETFLD:
455 : case TYP_SETFLD:
456 : case TYP_USERFLD:
457 : {
458 :
459 0 : const size_t nCount = pSh->GetFieldTypeCount();
460 0 : for(size_t i = 0; i < nCount; ++i)
461 : {
462 0 : SwFieldType* pFieldType = pSh->GetFieldType( i );
463 0 : const sal_uInt16 nWhich = pFieldType->Which();
464 :
465 0 : if((nTypeId == TYP_DDEFLD && pFieldType->Which() == RES_DDEFLD) ||
466 :
467 0 : (nTypeId == TYP_USERFLD && nWhich == RES_USERFLD) ||
468 :
469 0 : (nTypeId == TYP_GETFLD && nWhich == RES_SETEXPFLD &&
470 0 : !(static_cast<SwSetExpFieldType*>(pFieldType)->GetType() & nsSwGetSetExpType::GSE_SEQ)) ||
471 :
472 0 : (nTypeId == TYP_SETFLD && nWhich == RES_SETEXPFLD &&
473 0 : !(static_cast<SwSetExpFieldType*>(pFieldType)->GetType() & nsSwGetSetExpType::GSE_SEQ)) ||
474 :
475 0 : (nTypeId == TYP_SEQFLD && nWhich == RES_SETEXPFLD &&
476 0 : (static_cast<SwSetExpFieldType*>(pFieldType)->GetType() & nsSwGetSetExpType::GSE_SEQ)) ||
477 :
478 0 : ((nTypeId == TYP_INPUTFLD || nTypeId == TYP_FORMELFLD) &&
479 0 : (nWhich == RES_USERFLD ||
480 0 : (nWhich == RES_SETEXPFLD &&
481 0 : !(static_cast<SwSetExpFieldType*>(pFieldType)->GetType() & nsSwGetSetExpType::GSE_SEQ))) ) )
482 : {
483 0 : rToFill.push_back(pFieldType->GetName());
484 : }
485 : }
486 0 : break;
487 : }
488 : case TYP_DBNEXTSETFLD:
489 : case TYP_DBNUMSETFLD:
490 : case TYP_DBNAMEFLD:
491 : case TYP_DBSETNUMBERFLD:
492 0 : break;
493 :
494 : default:
495 : {
496 : // static SubTypes
497 0 : if(nPos != USHRT_MAX)
498 : {
499 : sal_uInt16 nCount;
500 0 : if (nTypeId == TYP_DOCINFOFLD)
501 0 : nCount = DI_SUBTYPE_END - DI_SUBTYPE_BEGIN;
502 : else
503 0 : nCount = aSwFields[nPos].nSubTypeEnd - aSwFields[nPos].nSubTypeStart;
504 :
505 0 : for(sal_uInt16 i = 0; i < nCount; ++i)
506 : {
507 0 : OUString sNew;
508 0 : if (nTypeId == TYP_DOCINFOFLD)
509 : {
510 0 : if ( i == DI_CUSTOM )
511 0 : sNew = SW_RES( STR_CUSTOM );
512 : else
513 0 : sNew = SwViewShell::GetShellRes()->aDocInfoLst[i];
514 : }
515 : else
516 0 : sNew = SW_RES(aSwFields[nPos].nSubTypeStart + i);
517 :
518 0 : rToFill.push_back(sNew);
519 0 : }
520 : }
521 : }
522 : }
523 0 : bRet = true;
524 : }
525 0 : return bRet;
526 : }
527 :
528 : // determine format
529 : // ACCESS over TYP_....
530 0 : sal_uInt16 SwFieldMgr::GetFormatCount(sal_uInt16 nTypeId, bool bIsText, bool bHtmlMode) const
531 : {
532 : OSL_ENSURE(nTypeId < TYP_END, "forbidden TypeId");
533 : {
534 0 : const sal_uInt16 nPos = GetPos(nTypeId);
535 :
536 0 : if(nPos == USHRT_MAX || (bHtmlMode && nTypeId == TYP_SETFLD))
537 0 : return 0;
538 :
539 0 : sal_uLong nStart = aSwFields[nPos].nFormatBegin;
540 0 : sal_uLong nEnd = aSwFields[nPos].nFormatEnd;
541 :
542 0 : if (bIsText && nEnd - nStart >= 2)
543 0 : return 2;
544 :
545 0 : if (nTypeId == TYP_FILENAMEFLD)
546 0 : nEnd -= 2; // no range or template
547 :
548 0 : switch(nStart)
549 : {
550 : case FMT_GETVAR_BEGIN:
551 0 : case FMT_SETVAR_BEGIN: return VF_COUNT;
552 0 : case FMT_USERVAR_BEGIN: return VF_USR_COUNT;
553 0 : case FMT_DBFLD_BEGIN: return VF_DB_COUNT;
554 : case FMT_NUM_BEGIN:
555 : {
556 0 : sal_uInt16 nCount = (sal_uInt16)(nEnd - nStart);
557 0 : GetNumberingInfo();
558 0 : if(xNumberingInfo.is())
559 : {
560 0 : Sequence<sal_Int16> aTypes = xNumberingInfo->getSupportedNumberingTypes();
561 0 : const sal_Int16* pTypes = aTypes.getConstArray();
562 0 : for(sal_Int32 nType = 0; nType < aTypes.getLength(); nType++)
563 : {
564 0 : sal_Int16 nCurrent = pTypes[nType];
565 : //skip all values below or equal to CHARS_LOWER_LETTER_N
566 0 : if(nCurrent > NumberingType::CHARS_LOWER_LETTER_N)
567 : {
568 : // #i28073# it's not necessarily a sorted sequence
569 0 : ++nCount;
570 : }
571 0 : }
572 : }
573 0 : return nCount;
574 : }
575 :
576 : }
577 0 : return (sal_uInt16)(nEnd - nStart);
578 : }
579 : }
580 :
581 : // determine FormatString to a type
582 0 : OUString SwFieldMgr::GetFormatStr(sal_uInt16 nTypeId, sal_uLong nFormatId) const
583 : {
584 : OSL_ENSURE(nTypeId < TYP_END, "forbidden TypeId");
585 0 : const sal_uInt16 nPos = GetPos(nTypeId);
586 :
587 0 : if(nPos == USHRT_MAX)
588 0 : return OUString();
589 :
590 : sal_uLong nStart;
591 :
592 0 : nStart = aSwFields[nPos].nFormatBegin;
593 :
594 0 : if (TYP_AUTHORFLD == nTypeId|| TYP_FILENAMEFLD == nTypeId)
595 0 : nFormatId &= ~FF_FIXED; // mask out Fixed-Flag
596 :
597 0 : if((nStart + nFormatId) < aSwFields[nPos].nFormatEnd)
598 0 : return SW_RES((sal_uInt16)(nStart + nFormatId));
599 :
600 0 : OUString aRet;
601 0 : if( FMT_NUM_BEGIN == nStart)
602 : {
603 0 : if(xNumberingInfo.is())
604 : {
605 0 : SwOLENames aNames(SW_RES(STRRES_NUMTYPES));
606 0 : ResStringArray& rNames = aNames.GetNames();
607 :
608 0 : Sequence<sal_Int16> aTypes = xNumberingInfo->getSupportedNumberingTypes();
609 0 : const sal_Int16* pTypes = aTypes.getConstArray();
610 0 : sal_Int32 nOffset = aSwFields[nPos].nFormatEnd - nStart;
611 0 : sal_Int32 nValidEntry = 0;
612 0 : for(sal_Int32 nType = 0; nType < aTypes.getLength(); nType++)
613 : {
614 0 : sal_Int16 nCurrent = pTypes[nType];
615 0 : if(nCurrent > NumberingType::CHARS_LOWER_LETTER_N)
616 : {
617 0 : if(nValidEntry == ((sal_Int32)nFormatId) - nOffset)
618 : {
619 0 : sal_uInt32 n = rNames.FindIndex(pTypes[nType]);
620 0 : if (n != RESARRAY_INDEX_NOTFOUND)
621 : {
622 0 : aRet = rNames.GetString(n);
623 : }
624 : else
625 : {
626 0 : aRet = xNumberingInfo->getNumberingIdentifier( pTypes[nType] );
627 : }
628 0 : break;
629 : }
630 0 : ++nValidEntry;
631 : }
632 0 : }
633 : }
634 : }
635 :
636 0 : return aRet;
637 : }
638 :
639 : // determine FormatId from Pseudo-ID
640 0 : sal_uInt16 SwFieldMgr::GetFormatId(sal_uInt16 nTypeId, sal_uLong nFormatId) const
641 : {
642 0 : sal_uInt16 nId = (sal_uInt16)nFormatId;
643 0 : switch( nTypeId )
644 : {
645 : case TYP_DOCINFOFLD:
646 0 : switch( aSwFields[ GetPos( nTypeId ) ].nFormatBegin + nFormatId )
647 : {
648 0 : case FMT_REG_AUTHOR: nId = DI_SUB_AUTHOR; break;
649 0 : case FMT_REG_TIME: nId = DI_SUB_TIME; break;
650 0 : case FMT_REG_DATE: nId = DI_SUB_DATE; break;
651 : }
652 0 : break;
653 :
654 : case TYP_PAGENUMBERFLD:
655 : case TYP_NEXTPAGEFLD:
656 : case TYP_PREVPAGEFLD:
657 : case TYP_DOCSTATFLD:
658 : case TYP_DBSETNUMBERFLD:
659 : case TYP_SEQFLD:
660 : case TYP_GETREFPAGEFLD:
661 : {
662 0 : sal_uInt16 nPos = GetPos( nTypeId );
663 0 : sal_uLong nBegin = aSwFields[ nPos ].nFormatBegin;
664 0 : sal_uLong nEnd = aSwFields[nPos].nFormatEnd;
665 0 : if((nBegin + nFormatId) < nEnd)
666 : {
667 0 : switch( nBegin + nFormatId )
668 : {
669 0 : case FMT_NUM_ABC: nId = SVX_NUM_CHARS_UPPER_LETTER; break;
670 0 : case FMT_NUM_SABC: nId = SVX_NUM_CHARS_LOWER_LETTER; break;
671 0 : case FMT_NUM_ROMAN: nId = SVX_NUM_ROMAN_UPPER; break;
672 0 : case FMT_NUM_SROMAN: nId = SVX_NUM_ROMAN_LOWER; break;
673 0 : case FMT_NUM_ARABIC: nId = SVX_NUM_ARABIC; break;
674 0 : case FMT_NUM_PAGEDESC: nId = SVX_NUM_PAGEDESC; break;
675 0 : case FMT_NUM_PAGESPECIAL: nId = SVX_NUM_CHAR_SPECIAL; break;
676 0 : case FMT_NUM_ABC_N: nId = SVX_NUM_CHARS_UPPER_LETTER_N; break;
677 0 : case FMT_NUM_SABC_N: nId = SVX_NUM_CHARS_LOWER_LETTER_N; break;
678 : }
679 : }
680 0 : else if(xNumberingInfo.is())
681 : {
682 0 : Sequence<sal_Int16> aTypes = xNumberingInfo->getSupportedNumberingTypes();
683 0 : const sal_Int16* pTypes = aTypes.getConstArray();
684 0 : sal_Int32 nOffset = nEnd - nBegin;
685 0 : sal_Int32 nValidEntry = 0;
686 0 : for(sal_Int32 nType = 0; nType < aTypes.getLength(); nType++)
687 : {
688 0 : sal_Int16 nCurrent = pTypes[nType];
689 0 : if(nCurrent > NumberingType::CHARS_LOWER_LETTER_N)
690 : {
691 0 : if(nValidEntry == ((sal_Int32)nFormatId) - nOffset)
692 : {
693 0 : nId = pTypes[nType];
694 0 : break;
695 : }
696 0 : ++nValidEntry;
697 : }
698 0 : }
699 : }
700 : }
701 0 : break;
702 : case TYP_DDEFLD:
703 0 : switch ( aSwFields[ GetPos( nTypeId ) ].nFormatBegin + nFormatId )
704 : {
705 0 : case FMT_DDE_NORMAL: nId = static_cast<sal_uInt16>(SfxLinkUpdateMode::ONCALL); break;
706 0 : case FMT_DDE_HOT: nId = static_cast<sal_uInt16>(SfxLinkUpdateMode::ALWAYS); break;
707 : }
708 0 : break;
709 : }
710 :
711 0 : return nId;
712 :
713 : }
714 :
715 : // Traveling
716 0 : bool SwFieldMgr::GoNextPrev( bool bNext, SwFieldType* pTyp )
717 : {
718 0 : SwWrtShell* pSh = pWrtShell ? pWrtShell : ::lcl_GetShell();
719 0 : if(!pSh)
720 0 : return false;
721 :
722 0 : if( !pTyp && pCurField )
723 : {
724 0 : const sal_uInt16 nTypeId = pCurField->GetTypeId();
725 0 : if( TYP_SETINPFLD == nTypeId || TYP_USRINPFLD == nTypeId )
726 0 : pTyp = pSh->GetFieldType( 0, RES_INPUTFLD );
727 : else
728 0 : pTyp = pCurField->GetTyp();
729 : }
730 :
731 0 : if (pTyp && pTyp->Which() == RES_DBFLD)
732 : {
733 : // for fieldcommand-edit (hop to all DB fields)
734 0 : return pSh->MoveFieldType( 0, bNext, RES_DBFLD );
735 : }
736 :
737 0 : return pTyp && pSh && pSh->MoveFieldType( pTyp, bNext );
738 : }
739 :
740 : // insert field types
741 0 : void SwFieldMgr::InsertFieldType(SwFieldType& rType)
742 : {
743 0 : SwWrtShell* pSh = pWrtShell ? pWrtShell : ::lcl_GetShell();
744 : OSL_ENSURE(pSh, "no SwWrtShell found");
745 0 : if(pSh)
746 0 : pSh->InsertFieldType(rType);
747 0 : }
748 :
749 : // determine current TypeId
750 0 : sal_uInt16 SwFieldMgr::GetCurTypeId() const
751 : {
752 0 : return pCurField ? pCurField->GetTypeId() : USHRT_MAX;
753 : }
754 :
755 : // Over string insert field or update
756 0 : bool SwFieldMgr::InsertField(
757 : const SwInsertField_Data& rData)
758 : {
759 0 : SwField* pField = 0;
760 0 : bool bExp = false;
761 0 : bool bTable = false;
762 0 : bool bPageVar = false;
763 0 : sal_uLong nFormatId = rData.m_nFormatId;
764 0 : sal_uInt16 nSubType = rData.m_nSubType;
765 0 : sal_Unicode cSeparator = rData.m_cSeparator;
766 0 : SwWrtShell* pCurShell = rData.m_pSh;
767 0 : if(!pCurShell)
768 0 : pCurShell = pWrtShell ? pWrtShell : ::lcl_GetShell();
769 : OSL_ENSURE(pCurShell, "no SwWrtShell found");
770 0 : if(!pCurShell)
771 0 : return false;
772 :
773 0 : switch (rData.m_nTypeId)
774 : { // ATTENTION this field is inserted by a separate dialog
775 : case TYP_POSTITFLD:
776 : {
777 0 : SvtUserOptions aUserOpt;
778 0 : SwPostItFieldType* pType = static_cast<SwPostItFieldType*>(pCurShell->GetFieldType(0, RES_POSTITFLD));
779 : SwPostItField* pPostItField =
780 : new SwPostItField(
781 : pType,
782 : rData.m_sPar1, // author
783 : rData.m_sPar2, // content
784 : aUserOpt.GetID(), // author's initials
785 : OUString(), // name
786 0 : DateTime(DateTime::SYSTEM) );
787 0 : pField = pPostItField;
788 : }
789 0 : break;
790 : case TYP_SCRIPTFLD:
791 : {
792 : SwScriptFieldType* pType =
793 0 : static_cast<SwScriptFieldType*>(pCurShell->GetFieldType(0, RES_SCRIPTFLD));
794 0 : pField = new SwScriptField(pType, rData.m_sPar1, rData.m_sPar2, (bool)nFormatId);
795 0 : break;
796 : }
797 :
798 : case TYP_COMBINED_CHARS:
799 : {
800 : SwCombinedCharFieldType* pType = static_cast<SwCombinedCharFieldType*>(
801 0 : pCurShell->GetFieldType( 0, RES_COMBINED_CHARS ));
802 0 : pField = new SwCombinedCharField( pType, rData.m_sPar1 );
803 : }
804 0 : break;
805 :
806 : case TYP_AUTHORITY:
807 : {
808 : SwAuthorityFieldType* pType =
809 0 : static_cast<SwAuthorityFieldType*>(pCurShell->GetFieldType(0, RES_AUTHORITY));
810 0 : if (!pType)
811 : {
812 0 : SwAuthorityFieldType const type(pCurShell->GetDoc());
813 : pType = static_cast<SwAuthorityFieldType*>(
814 0 : pCurShell->InsertFieldType(type));
815 : }
816 0 : pField = new SwAuthorityField(pType, rData.m_sPar1);
817 : }
818 0 : break;
819 :
820 : case TYP_DATEFLD:
821 : case TYP_TIMEFLD:
822 : {
823 0 : sal_uInt16 nSub = static_cast< sal_uInt16 >(rData.m_nTypeId == TYP_DATEFLD ? DATEFLD : TIMEFLD);
824 0 : nSub |= nSubType == DATE_VAR ? 0 : FIXEDFLD;
825 :
826 : SwDateTimeFieldType* pTyp =
827 0 : static_cast<SwDateTimeFieldType*>( pCurShell->GetFieldType(0, RES_DATETIMEFLD) );
828 0 : pField = new SwDateTimeField(pTyp, nSub, nFormatId);
829 0 : pField->SetPar2(rData.m_sPar2);
830 0 : break;
831 : }
832 :
833 : case TYP_FILENAMEFLD:
834 : {
835 : SwFileNameFieldType* pTyp =
836 0 : static_cast<SwFileNameFieldType*>( pCurShell->GetFieldType(0, RES_FILENAMEFLD) );
837 0 : pField = new SwFileNameField(pTyp, nFormatId);
838 0 : break;
839 : }
840 :
841 : case TYP_TEMPLNAMEFLD:
842 : {
843 : SwTemplNameFieldType* pTyp =
844 0 : static_cast<SwTemplNameFieldType*>( pCurShell->GetFieldType(0, RES_TEMPLNAMEFLD) );
845 0 : pField = new SwTemplNameField(pTyp, nFormatId);
846 0 : break;
847 : }
848 :
849 : case TYP_CHAPTERFLD:
850 : {
851 0 : sal_uInt16 nByte = (sal_uInt16)rData.m_sPar2.toInt32();
852 : SwChapterFieldType* pTyp =
853 0 : static_cast<SwChapterFieldType*>( pCurShell->GetFieldType(0, RES_CHAPTERFLD) );
854 0 : pField = new SwChapterField(pTyp, nFormatId);
855 0 : nByte = std::max(sal_uInt16(1), nByte);
856 0 : nByte = std::min(nByte, sal_uInt16(MAXLEVEL));
857 0 : nByte -= 1;
858 0 : static_cast<SwChapterField*>(pField)->SetLevel((sal_uInt8)nByte);
859 0 : break;
860 : }
861 :
862 : case TYP_NEXTPAGEFLD:
863 : case TYP_PREVPAGEFLD:
864 : case TYP_PAGENUMBERFLD:
865 : {
866 0 : short nOff = (short)rData.m_sPar2.toInt32();
867 :
868 0 : if(rData.m_nTypeId == TYP_NEXTPAGEFLD)
869 : {
870 0 : if( SVX_NUM_CHAR_SPECIAL == nFormatId )
871 0 : nOff = 1;
872 : else
873 0 : nOff += 1;
874 0 : nSubType = PG_NEXT;
875 : }
876 0 : else if(rData.m_nTypeId == TYP_PREVPAGEFLD)
877 : {
878 0 : if( SVX_NUM_CHAR_SPECIAL == nFormatId )
879 0 : nOff = -1;
880 : else
881 0 : nOff -= 1;
882 0 : nSubType = PG_PREV;
883 : }
884 : else
885 0 : nSubType = PG_RANDOM;
886 :
887 : SwPageNumberFieldType* pTyp =
888 0 : static_cast<SwPageNumberFieldType*>( pCurShell->GetFieldType(0, RES_PAGENUMBERFLD) );
889 0 : pField = new SwPageNumberField(pTyp, nSubType, nFormatId, nOff);
890 :
891 0 : if( SVX_NUM_CHAR_SPECIAL == nFormatId &&
892 0 : ( PG_PREV == nSubType || PG_NEXT == nSubType ) )
893 0 : static_cast<SwPageNumberField*>(pField)->SetUserString( rData.m_sPar2 );
894 0 : break;
895 : }
896 :
897 : case TYP_DOCSTATFLD:
898 : {
899 : SwDocStatFieldType* pTyp =
900 0 : static_cast<SwDocStatFieldType*>( pCurShell->GetFieldType(0, RES_DOCSTATFLD) );
901 0 : pField = new SwDocStatField(pTyp, nSubType, nFormatId);
902 0 : break;
903 : }
904 :
905 : case TYP_AUTHORFLD:
906 : {
907 : SwAuthorFieldType* pTyp =
908 0 : static_cast<SwAuthorFieldType*>( pCurShell->GetFieldType(0, RES_AUTHORFLD) );
909 0 : pField = new SwAuthorField(pTyp, nFormatId);
910 0 : break;
911 : }
912 :
913 : case TYP_CONDTXTFLD:
914 : case TYP_HIDDENTXTFLD:
915 : {
916 : SwHiddenTextFieldType* pTyp =
917 0 : static_cast<SwHiddenTextFieldType*>( pCurShell->GetFieldType(0, RES_HIDDENTXTFLD) );
918 0 : pField = new SwHiddenTextField(pTyp, true, rData.m_sPar1, rData.m_sPar2, false, rData.m_nTypeId);
919 0 : bExp = true;
920 0 : break;
921 : }
922 :
923 : case TYP_HIDDENPARAFLD:
924 : {
925 : SwHiddenParaFieldType* pTyp =
926 0 : static_cast<SwHiddenParaFieldType*>( pCurShell->GetFieldType(0, RES_HIDDENPARAFLD) );
927 0 : pField = new SwHiddenParaField(pTyp, rData.m_sPar1);
928 0 : bExp = true;
929 0 : break;
930 : }
931 :
932 : case TYP_SETREFFLD:
933 : {
934 0 : if( !rData.m_sPar1.isEmpty() && CanInsertRefMark( rData.m_sPar1 ) )
935 : {
936 0 : pCurShell->SetAttrItem( SwFormatRefMark( rData.m_sPar1 ) );
937 0 : return true;
938 : }
939 0 : return false;
940 : }
941 :
942 : case TYP_GETREFFLD:
943 : {
944 : SwGetRefFieldType* pTyp =
945 0 : static_cast<SwGetRefFieldType*>( pCurShell->GetFieldType(0, RES_GETREFFLD) );
946 0 : sal_uInt16 nSeqNo = (sal_uInt16)rData.m_sPar2.toInt32();
947 0 : pField = new SwGetRefField(pTyp, rData.m_sPar1, nSubType, nSeqNo, nFormatId);
948 0 : bExp = true;
949 0 : break;
950 : }
951 :
952 : case TYP_DDEFLD:
953 : {
954 : //JP 28.08.95: DDE-Topics/-Items can have blanks in their names!
955 : // That's not yet considered here.
956 0 : sal_Int32 nIndex = 0;
957 0 : OUString sCmd = rData.m_sPar2.replaceFirst(OUString(' '), OUString(sfx2::cTokenSeparator), &nIndex);
958 0 : if (nIndex>=0 && ++nIndex<sCmd.getLength())
959 : {
960 0 : sCmd = sCmd.replaceFirst(OUString(' '), OUString(sfx2::cTokenSeparator), &nIndex);
961 : }
962 :
963 0 : SwDDEFieldType aType( rData.m_sPar1, sCmd, static_cast<SfxLinkUpdateMode>(nFormatId) );
964 0 : SwDDEFieldType* pTyp = static_cast<SwDDEFieldType*>( pCurShell->InsertFieldType( aType ) );
965 0 : pField = new SwDDEField( pTyp );
966 0 : break;
967 : }
968 :
969 : case TYP_MACROFLD:
970 : {
971 : SwMacroFieldType* pTyp =
972 0 : static_cast<SwMacroFieldType*>(pCurShell->GetFieldType(0, RES_MACROFLD));
973 :
974 0 : pField = new SwMacroField(pTyp, rData.m_sPar1, rData.m_sPar2);
975 :
976 0 : break;
977 : }
978 :
979 : case TYP_INTERNETFLD:
980 : {
981 0 : SwFormatINetFormat aFormat( rData.m_sPar1, sCurFrame );
982 0 : if( pMacroItem )
983 0 : aFormat.SetMacroTable( &pMacroItem->GetMacroTable() );
984 0 : return pCurShell->InsertURL( aFormat, rData.m_sPar2 );
985 : }
986 :
987 : case TYP_JUMPEDITFLD:
988 : {
989 : SwJumpEditFieldType* pTyp =
990 0 : static_cast<SwJumpEditFieldType*>(pCurShell->GetFieldType(0, RES_JUMPEDITFLD));
991 :
992 0 : pField = new SwJumpEditField(pTyp, nFormatId, rData.m_sPar1, rData.m_sPar2);
993 0 : break;
994 : }
995 :
996 : case TYP_DOCINFOFLD:
997 : {
998 : SwDocInfoFieldType* pTyp = static_cast<SwDocInfoFieldType*>( pCurShell->GetFieldType(
999 0 : 0, RES_DOCINFOFLD ) );
1000 0 : pField = new SwDocInfoField(pTyp, nSubType, rData.m_sPar1, nFormatId);
1001 0 : break;
1002 : }
1003 :
1004 : case TYP_EXTUSERFLD:
1005 : {
1006 : SwExtUserFieldType* pTyp = static_cast<SwExtUserFieldType*>( pCurShell->GetFieldType(
1007 0 : 0, RES_EXTUSERFLD) );
1008 0 : pField = new SwExtUserField(pTyp, nSubType, nFormatId);
1009 0 : break;
1010 : }
1011 :
1012 : case TYP_DBFLD:
1013 : {
1014 : #if HAVE_FEATURE_DBCONNECTIVITY
1015 0 : SwDBData aDBData;
1016 0 : OUString sPar1;
1017 :
1018 0 : if (rData.m_sPar1.indexOf(DB_DELIM)<0)
1019 : {
1020 0 : aDBData = pCurShell->GetDBData();
1021 0 : sPar1 = rData.m_sPar1;
1022 : }
1023 : else
1024 : {
1025 0 : aDBData.sDataSource = rData.m_sPar1.getToken(0, DB_DELIM);
1026 0 : aDBData.sCommand = rData.m_sPar1.getToken(1, DB_DELIM);
1027 0 : aDBData.nCommandType = rData.m_sPar1.getToken(2, DB_DELIM).toInt32();
1028 0 : sPar1 = rData.m_sPar1.getToken(3, DB_DELIM);
1029 : }
1030 :
1031 0 : if(!aDBData.sDataSource.isEmpty() && pCurShell->GetDBData() != aDBData)
1032 0 : pCurShell->ChgDBData(aDBData);
1033 :
1034 : SwDBFieldType* pTyp = static_cast<SwDBFieldType*>(pCurShell->InsertFieldType(
1035 0 : SwDBFieldType(pCurShell->GetDoc(), sPar1, aDBData) ) );
1036 0 : pField = new SwDBField(pTyp);
1037 0 : pField->SetSubType(nSubType);
1038 :
1039 0 : if( !(nSubType & nsSwExtendedSubType::SUB_OWN_FMT) ) // determinee database format
1040 : {
1041 0 : Reference< XDataSource> xSource;
1042 0 : rData.m_aDBDataSource >>= xSource;
1043 0 : Reference<XConnection> xConnection;
1044 0 : rData.m_aDBConnection >>= xConnection;
1045 0 : Reference<XPropertySet> xColumn;
1046 0 : rData.m_aDBColumn >>= xColumn;
1047 0 : if(xColumn.is())
1048 : {
1049 : nFormatId = SwDBManager::GetColumnFormat(xSource, xConnection, xColumn,
1050 0 : pCurShell->GetNumberFormatter(), GetCurrLanguage() );
1051 : }
1052 : else
1053 : nFormatId = pCurShell->GetDBManager()->GetColumnFormat(
1054 : aDBData.sDataSource, aDBData.sCommand, sPar1,
1055 0 : pCurShell->GetNumberFormatter(), GetCurrLanguage() );
1056 : }
1057 0 : pField->ChangeFormat( nFormatId );
1058 :
1059 0 : bExp = true;
1060 : #endif
1061 0 : break;
1062 : }
1063 :
1064 : case TYP_DBSETNUMBERFLD:
1065 : case TYP_DBNUMSETFLD:
1066 : case TYP_DBNEXTSETFLD:
1067 : case TYP_DBNAMEFLD:
1068 : {
1069 : #if HAVE_FEATURE_DBCONNECTIVITY
1070 0 : SwDBData aDBData;
1071 :
1072 : // excract DBName from rData.m_sPar1. Format: DBName.TableName.CommandType.ExpStrg
1073 0 : sal_Int32 nTablePos = rData.m_sPar1.indexOf(DB_DELIM);
1074 0 : sal_Int32 nCmdTypePos = -1;
1075 0 : sal_Int32 nExpPos = -1;
1076 :
1077 0 : if (nTablePos>=0)
1078 : {
1079 0 : aDBData.sDataSource = rData.m_sPar1.copy(0, nTablePos++);
1080 0 : nCmdTypePos = rData.m_sPar1.indexOf(DB_DELIM, nTablePos);
1081 0 : if (nCmdTypePos>=0)
1082 : {
1083 0 : aDBData.sCommand = rData.m_sPar1.copy(nTablePos, nCmdTypePos++ - nTablePos);
1084 0 : nExpPos = rData.m_sPar1.indexOf(DB_DELIM, nCmdTypePos);
1085 0 : if (nExpPos>=0)
1086 : {
1087 0 : aDBData.nCommandType = rData.m_sPar1.copy(nCmdTypePos, nExpPos++ - nCmdTypePos).toInt32();
1088 : }
1089 : }
1090 : }
1091 :
1092 0 : sal_Int32 nPos = 0;
1093 0 : if (nExpPos>=0)
1094 0 : nPos = nExpPos;
1095 0 : else if (nTablePos>=0)
1096 0 : nPos = nTablePos;
1097 :
1098 0 : OUString sPar1 = rData.m_sPar1.copy(nPos);
1099 :
1100 0 : if (!aDBData.sDataSource.isEmpty() && pCurShell->GetDBData() != aDBData)
1101 0 : pCurShell->ChgDBData(aDBData);
1102 :
1103 0 : switch(rData.m_nTypeId)
1104 : {
1105 : case TYP_DBNAMEFLD:
1106 : {
1107 : SwDBNameFieldType* pTyp =
1108 0 : static_cast<SwDBNameFieldType*>(pCurShell->GetFieldType(0, RES_DBNAMEFLD));
1109 0 : pField = new SwDBNameField(pTyp, aDBData);
1110 :
1111 0 : break;
1112 : }
1113 : case TYP_DBNEXTSETFLD:
1114 : {
1115 : SwDBNextSetFieldType* pTyp = static_cast<SwDBNextSetFieldType*>(pCurShell->GetFieldType(
1116 0 : 0, RES_DBNEXTSETFLD) );
1117 0 : pField = new SwDBNextSetField(pTyp, sPar1, rData.m_sPar2, aDBData);
1118 0 : bExp = true;
1119 0 : break;
1120 : }
1121 : case TYP_DBNUMSETFLD:
1122 : {
1123 : SwDBNumSetFieldType* pTyp = static_cast<SwDBNumSetFieldType*>( pCurShell->GetFieldType(
1124 0 : 0, RES_DBNUMSETFLD) );
1125 0 : pField = new SwDBNumSetField( pTyp, sPar1, rData.m_sPar2, aDBData);
1126 0 : bExp = true;
1127 0 : break;
1128 : }
1129 : case TYP_DBSETNUMBERFLD:
1130 : {
1131 : SwDBSetNumberFieldType* pTyp = static_cast<SwDBSetNumberFieldType*>(
1132 0 : pCurShell->GetFieldType(0, RES_DBSETNUMBERFLD) );
1133 0 : pField = new SwDBSetNumberField( pTyp, aDBData, nFormatId);
1134 0 : bExp = true;
1135 0 : break;
1136 : }
1137 : }
1138 : #endif
1139 0 : break;
1140 : }
1141 :
1142 : case TYP_USERFLD:
1143 : {
1144 : SwUserFieldType* pTyp =
1145 0 : static_cast<SwUserFieldType*>( pCurShell->GetFieldType(RES_USERFLD, rData.m_sPar1) );
1146 :
1147 : // only if existing
1148 0 : if(!pTyp)
1149 : {
1150 : pTyp = static_cast<SwUserFieldType*>( pCurShell->InsertFieldType(
1151 0 : SwUserFieldType(pCurShell->GetDoc(), rData.m_sPar1)) );
1152 : }
1153 0 : if (pTyp->GetContent(nFormatId) != rData.m_sPar2)
1154 0 : pTyp->SetContent(rData.m_sPar2, nFormatId);
1155 0 : pField = new SwUserField(pTyp, 0, nFormatId);
1156 0 : if (pField->GetSubType() != nSubType)
1157 0 : pField->SetSubType(nSubType);
1158 0 : bTable = true;
1159 0 : break;
1160 : }
1161 :
1162 : case TYP_INPUTFLD:
1163 : {
1164 0 : if ((nSubType & 0x00ff) == INP_VAR)
1165 : {
1166 : SwSetExpFieldType* pTyp = static_cast<SwSetExpFieldType*>(
1167 0 : pCurShell->GetFieldType(RES_SETEXPFLD, rData.m_sPar1) );
1168 :
1169 : // no Experssion Type with this name existing -> create
1170 0 : if(pTyp)
1171 : {
1172 : SwSetExpField* pExpField =
1173 0 : new SwSetExpField(pTyp, OUString(), nFormatId);
1174 :
1175 : // Don't change type of SwSetExpFieldType:
1176 0 : sal_uInt16 nOldSubType = pExpField->GetSubType();
1177 0 : pExpField->SetSubType(nOldSubType | (nSubType & 0xff00));
1178 :
1179 0 : pExpField->SetPromptText(rData.m_sPar2);
1180 0 : pExpField->SetInputFlag(true) ;
1181 0 : bExp = true;
1182 0 : pField = pExpField;
1183 : }
1184 : else
1185 0 : return false;
1186 : }
1187 : else
1188 : {
1189 : SwInputFieldType* pTyp =
1190 0 : static_cast<SwInputFieldType*>( pCurShell->GetFieldType(0, RES_INPUTFLD) );
1191 :
1192 : SwInputField* pInpField =
1193 0 : new SwInputField( pTyp, rData.m_sPar1, rData.m_sPar2, nSubType|nsSwExtendedSubType::SUB_INVISIBLE, nFormatId);
1194 0 : pField = pInpField;
1195 : }
1196 :
1197 : // start dialog
1198 0 : pCurShell->StartInputFieldDlg(pField, false, rData.m_pParent);
1199 0 : break;
1200 : }
1201 :
1202 : case TYP_SETFLD:
1203 : {
1204 0 : if (rData.m_sPar2.isEmpty()) // empty variables are not allowed
1205 0 : return false;
1206 :
1207 : SwSetExpFieldType* pTyp = static_cast<SwSetExpFieldType*>( pCurShell->InsertFieldType(
1208 0 : SwSetExpFieldType(pCurShell->GetDoc(), rData.m_sPar1) ) );
1209 :
1210 0 : SwSetExpField* pExpField = new SwSetExpField( pTyp, rData.m_sPar2, nFormatId);
1211 0 : pExpField->SetSubType(nSubType);
1212 0 : pExpField->SetPar2(rData.m_sPar2);
1213 0 : bExp = true;
1214 0 : pField = pExpField;
1215 0 : break;
1216 : }
1217 :
1218 : case TYP_SEQFLD:
1219 : {
1220 : SwSetExpFieldType* pTyp = static_cast<SwSetExpFieldType*>( pCurShell->InsertFieldType(
1221 0 : SwSetExpFieldType(pCurShell->GetDoc(), rData.m_sPar1, nsSwGetSetExpType::GSE_SEQ)));
1222 :
1223 0 : sal_uInt8 nLevel = static_cast< sal_uInt8 >(nSubType & 0xff);
1224 :
1225 0 : pTyp->SetOutlineLvl(nLevel);
1226 0 : if (nLevel != 0x7f && cSeparator == 0)
1227 0 : cSeparator = '.';
1228 :
1229 0 : pTyp->SetDelimiter(OUString(cSeparator));
1230 0 : SwSetExpField* pExpField = new SwSetExpField(pTyp, rData.m_sPar2, nFormatId);
1231 0 : bExp = true;
1232 0 : pField = pExpField;
1233 0 : nSubType = nsSwGetSetExpType::GSE_SEQ;
1234 0 : break;
1235 : }
1236 :
1237 : case TYP_GETFLD:
1238 : {
1239 : // is there a corresponding SetField
1240 : SwSetExpFieldType* pSetTyp = static_cast<SwSetExpFieldType*>(
1241 0 : pCurShell->GetFieldType(RES_SETEXPFLD, rData.m_sPar1));
1242 :
1243 0 : if(pSetTyp)
1244 : {
1245 : SwGetExpFieldType* pTyp = static_cast<SwGetExpFieldType*>( pCurShell->GetFieldType(
1246 0 : 0, RES_GETEXPFLD) );
1247 0 : pField = new SwGetExpField(pTyp, rData.m_sPar1, pSetTyp->GetType(), nFormatId);
1248 0 : pField->SetSubType(nSubType | pSetTyp->GetType());
1249 0 : bExp = true;
1250 : }
1251 : else
1252 0 : return false;
1253 0 : break;
1254 : }
1255 :
1256 : case TYP_FORMELFLD:
1257 : {
1258 0 : if(pCurShell->GetFrmType(0,false) & FrmTypeFlags::TABLE)
1259 : {
1260 0 : pCurShell->StartAllAction();
1261 :
1262 0 : SvNumberFormatter* pFormatter = pCurShell->GetDoc()->GetNumberFormatter();
1263 0 : const SvNumberformat* pEntry = pFormatter->GetEntry(nFormatId);
1264 :
1265 0 : if (pEntry)
1266 : {
1267 0 : SfxStringItem aFormat(FN_NUMBER_FORMAT, pEntry->GetFormatstring());
1268 0 : pCurShell->GetView().GetViewFrame()->GetDispatcher()->
1269 0 : Execute(FN_NUMBER_FORMAT, SfxCallMode::SYNCHRON, &aFormat, 0L);
1270 : }
1271 :
1272 0 : SfxItemSet aBoxSet( pCurShell->GetAttrPool(),
1273 0 : RES_BOXATR_FORMULA, RES_BOXATR_FORMULA );
1274 :
1275 0 : OUString sFormula(comphelper::string::stripStart(rData.m_sPar2, ' '));
1276 0 : if ( sFormula.startsWith("=") )
1277 : {
1278 0 : sFormula = sFormula.copy(1);
1279 : }
1280 :
1281 0 : aBoxSet.Put( SwTableBoxFormula( sFormula ));
1282 0 : pCurShell->SetTableBoxFormulaAttrs( aBoxSet );
1283 0 : pCurShell->UpdateTable();
1284 :
1285 0 : pCurShell->EndAllAction();
1286 0 : return true;
1287 :
1288 : }
1289 : else
1290 : {
1291 : SwGetExpFieldType* pTyp = static_cast<SwGetExpFieldType*>(
1292 0 : pCurShell->GetFieldType(0, RES_GETEXPFLD) );
1293 0 : pField = new SwGetExpField(pTyp, rData.m_sPar2, nsSwGetSetExpType::GSE_FORMULA, nFormatId);
1294 0 : pField->SetSubType(nSubType);
1295 0 : bExp = true;
1296 : }
1297 0 : break;
1298 : }
1299 : case TYP_SETREFPAGEFLD:
1300 : pField = new SwRefPageSetField( static_cast<SwRefPageSetFieldType*>(
1301 0 : pCurShell->GetFieldType( 0, RES_REFPAGESETFLD ) ),
1302 0 : (short)rData.m_sPar2.toInt32(), 0 != nSubType );
1303 0 : bPageVar = true;
1304 0 : break;
1305 :
1306 : case TYP_GETREFPAGEFLD:
1307 : pField = new SwRefPageGetField( static_cast<SwRefPageGetFieldType*>(
1308 0 : pCurShell->GetFieldType( 0, RES_REFPAGEGETFLD ) ), nFormatId );
1309 0 : bPageVar = true;
1310 0 : break;
1311 : case TYP_DROPDOWN :
1312 : {
1313 0 : pField = new SwDropDownField(pCurShell->GetFieldType( 0, RES_DROPDOWN ));
1314 0 : const sal_Int32 nTokenCount = comphelper::string::getTokenCount(rData.m_sPar2, DB_DELIM);
1315 0 : Sequence<OUString> aEntries(nTokenCount);
1316 0 : OUString* pArray = aEntries.getArray();
1317 0 : for(sal_Int32 nToken = 0; nToken < nTokenCount; nToken++)
1318 0 : pArray[nToken] = rData.m_sPar2.getToken(nToken, DB_DELIM);
1319 0 : static_cast<SwDropDownField*>(pField)->SetItems(aEntries);
1320 0 : static_cast<SwDropDownField*>(pField)->SetName(rData.m_sPar1);
1321 : }
1322 0 : break;
1323 : default:
1324 : { OSL_ENSURE(false, "wrong field type");
1325 0 : return false;
1326 : }
1327 : }
1328 : OSL_ENSURE(pField, "field not available");
1329 :
1330 : //the auto language flag has to be set prior to the language!
1331 0 : pField->SetAutomaticLanguage(rData.m_bIsAutomaticLanguage);
1332 0 : sal_uInt16 nLang = GetCurrLanguage();
1333 0 : pField->SetLanguage(nLang);
1334 :
1335 : // insert
1336 0 : pCurShell->StartAllAction();
1337 :
1338 0 : pCurShell->Insert( *pField );
1339 :
1340 0 : if(bExp && bEvalExp)
1341 0 : pCurShell->UpdateExpFields(true);
1342 :
1343 0 : if(bTable)
1344 : {
1345 0 : pCurShell->Left(CRSR_SKIP_CHARS, false, 1, false );
1346 0 : pCurShell->UpdateFields(*pField);
1347 0 : pCurShell->Right(CRSR_SKIP_CHARS, false, 1, false );
1348 : }
1349 0 : else if( bPageVar )
1350 0 : static_cast<SwRefPageGetFieldType*>(pCurShell->GetFieldType( 0, RES_REFPAGEGETFLD ))->UpdateFields();
1351 0 : else if( TYP_GETREFFLD == rData.m_nTypeId )
1352 0 : pField->GetTyp()->ModifyNotification( 0, 0 );
1353 :
1354 : // delete temporary field
1355 0 : delete pField;
1356 :
1357 0 : pCurShell->EndAllAction();
1358 0 : return true;
1359 : }
1360 :
1361 : // fields update
1362 0 : void SwFieldMgr::UpdateCurField(sal_uLong nFormat,
1363 : const OUString& rPar1,
1364 : const OUString& rPar2,
1365 : SwField * _pTmpField) // #111840#
1366 : {
1367 : // change format
1368 : OSL_ENSURE(pCurField, "no field at CursorPos");
1369 :
1370 0 : bool bDelete = false;
1371 : SwField *pTmpField; // mb: fixed memory leak
1372 0 : if (NULL != _pTmpField)
1373 : {
1374 0 : pTmpField = _pTmpField;
1375 : }
1376 : else
1377 : {
1378 0 : pTmpField = pCurField->CopyField();
1379 0 : bDelete = true;
1380 : }
1381 :
1382 0 : SwFieldType* pType = pTmpField->GetTyp();
1383 0 : const sal_uInt16 nTypeId = pTmpField->GetTypeId();
1384 :
1385 0 : SwWrtShell* pSh = pWrtShell ? pWrtShell : ::lcl_GetShell();
1386 : OSL_ENSURE(pSh, "no SwWrtShell found");
1387 0 : if(!pSh)
1388 0 : return;
1389 0 : pSh->StartAllAction();
1390 :
1391 0 : bool bSetPar2 = true;
1392 0 : bool bSetPar1 = true;
1393 0 : OUString sPar1( rPar1 );
1394 0 : OUString sPar2( rPar2 );
1395 :
1396 : // Order to Format
1397 0 : switch( nTypeId )
1398 : {
1399 : case TYP_DDEFLD:
1400 : {
1401 : // DDE-Topics/-Items can have blanks in their names!
1402 : // That's not yet considered here!
1403 0 : sal_Int32 nIndex = 0;
1404 0 : sPar2 = sPar2.replaceFirst(OUString(' '), OUString(sfx2::cTokenSeparator), &nIndex );
1405 0 : if (nIndex>=0 && ++nIndex<sPar2.getLength())
1406 : {
1407 0 : sPar2 = sPar2.replaceFirst(OUString(' '), OUString(sfx2::cTokenSeparator), &nIndex);
1408 : }
1409 0 : break;
1410 : }
1411 :
1412 : case TYP_CHAPTERFLD:
1413 : {
1414 0 : sal_uInt16 nByte = (sal_uInt16)rPar2.toInt32();
1415 0 : nByte = std::max(sal_uInt16(1), nByte);
1416 0 : nByte = std::min(nByte, sal_uInt16(MAXLEVEL));
1417 0 : nByte -= 1;
1418 0 : static_cast<SwChapterField*>(pTmpField)->SetLevel((sal_uInt8)nByte);
1419 0 : bSetPar2 = false;
1420 0 : break;
1421 : }
1422 :
1423 : case TYP_SCRIPTFLD:
1424 0 : static_cast<SwScriptField*>(pTmpField)->SetCodeURL((bool)nFormat);
1425 0 : break;
1426 :
1427 : case TYP_NEXTPAGEFLD:
1428 0 : if( SVX_NUM_CHAR_SPECIAL == nFormat )
1429 : {
1430 0 : static_cast<SwPageNumberField*>(pCurField)->SetUserString( sPar2 );
1431 0 : sPar2 = "1";
1432 : }
1433 : else
1434 : {
1435 0 : if( nFormat + 2 == SVX_NUM_PAGEDESC )
1436 0 : nFormat = SVX_NUM_PAGEDESC;
1437 0 : short nOff = (short)sPar2.toInt32();
1438 0 : nOff += 1;
1439 0 : sPar2 = OUString::number(nOff);
1440 : }
1441 0 : break;
1442 :
1443 : case TYP_PREVPAGEFLD:
1444 0 : if( SVX_NUM_CHAR_SPECIAL == nFormat )
1445 : {
1446 0 : static_cast<SwPageNumberField*>(pCurField)->SetUserString( sPar2 );
1447 0 : sPar2 = "-1";
1448 : }
1449 : else
1450 : {
1451 0 : if( nFormat + 2 == SVX_NUM_PAGEDESC )
1452 0 : nFormat = SVX_NUM_PAGEDESC;
1453 0 : short nOff = (short)sPar2.toInt32();
1454 0 : nOff -= 1;
1455 0 : sPar2 = OUString::number(nOff);
1456 : }
1457 0 : break;
1458 :
1459 : case TYP_PAGENUMBERFLD:
1460 : case TYP_GETREFPAGEFLD:
1461 0 : if( nFormat + 2 == SVX_NUM_PAGEDESC )
1462 0 : nFormat = SVX_NUM_PAGEDESC;
1463 0 : break;
1464 :
1465 : case TYP_GETREFFLD:
1466 : {
1467 0 : bSetPar2 = false;
1468 0 : static_cast<SwGetRefField*>(pTmpField)->SetSubType( (sal_uInt16)rPar2.toInt32() );
1469 0 : const sal_Int32 nPos = rPar2.indexOf( '|' );
1470 0 : if( nPos>=0 )
1471 0 : static_cast<SwGetRefField*>(pTmpField)->SetSeqNo( (sal_uInt16)rPar2.copy( nPos + 1 ).toInt32());
1472 : }
1473 0 : break;
1474 : case TYP_DROPDOWN:
1475 : {
1476 0 : sal_Int32 nTokenCount = comphelper::string::getTokenCount(sPar2, DB_DELIM);
1477 0 : Sequence<OUString> aEntries(nTokenCount);
1478 0 : OUString* pArray = aEntries.getArray();
1479 0 : for(sal_Int32 nToken = 0; nToken < nTokenCount; nToken++)
1480 0 : pArray[nToken] = sPar2.getToken(nToken, DB_DELIM);
1481 0 : static_cast<SwDropDownField*>(pTmpField)->SetItems(aEntries);
1482 0 : static_cast<SwDropDownField*>(pTmpField)->SetName(sPar1);
1483 0 : bSetPar1 = bSetPar2 = false;
1484 : }
1485 0 : break;
1486 : case TYP_AUTHORITY :
1487 : {
1488 : //#i99069# changes to a bibliography field should change the field type
1489 0 : SwAuthorityField* pAuthorityField = static_cast<SwAuthorityField*>(pTmpField);
1490 0 : SwAuthorityFieldType* pAuthorityType = static_cast<SwAuthorityFieldType*>(pType);
1491 0 : SwAuthEntry aTempEntry;
1492 0 : for( sal_uInt16 i = 0; i < AUTH_FIELD_END; ++i )
1493 : aTempEntry.SetAuthorField( (ToxAuthorityField)i,
1494 0 : rPar1.getToken( i, TOX_STYLE_DELIMITER ));
1495 0 : if( pAuthorityType->ChangeEntryContent( &aTempEntry ) )
1496 : {
1497 0 : pType->UpdateFields();
1498 0 : pSh->SetModified();
1499 : }
1500 :
1501 0 : if( aTempEntry.GetAuthorField( AUTH_FIELD_IDENTIFIER ) ==
1502 : pAuthorityField->GetFieldText( AUTH_FIELD_IDENTIFIER ) )
1503 0 : bSetPar1 = false; //otherwise it's a new or changed entry, the field needs to be updated
1504 0 : bSetPar2 = false;
1505 : }
1506 0 : break;
1507 : }
1508 :
1509 : // set format
1510 : // setup format before SetPar2 because of NumberFormatter!
1511 0 : pTmpField->ChangeFormat(nFormat);
1512 :
1513 0 : if(bSetPar1)
1514 0 : pTmpField->SetPar1( sPar1 );
1515 0 : if( bSetPar2 )
1516 0 : pTmpField->SetPar2( sPar2 );
1517 :
1518 : // kick off update
1519 0 : if(nTypeId == TYP_DDEFLD ||
1520 0 : nTypeId == TYP_USERFLD ||
1521 : nTypeId == TYP_USRINPFLD)
1522 : {
1523 0 : pType->UpdateFields();
1524 0 : pSh->SetModified();
1525 : }
1526 : else {
1527 : // mb: #32157
1528 0 : pSh->SwEditShell::UpdateFields(*pTmpField);
1529 0 : GetCurField();
1530 : }
1531 :
1532 0 : if (bDelete)
1533 0 : delete pTmpField;
1534 :
1535 0 : pSh->EndAllAction();
1536 : }
1537 :
1538 : // explicitly evaluate ExpressionFields
1539 0 : void SwFieldMgr::EvalExpFields(SwWrtShell* pSh)
1540 : {
1541 0 : if (pSh == NULL)
1542 0 : pSh = pWrtShell ? pWrtShell : ::lcl_GetShell();
1543 :
1544 0 : if(pSh)
1545 : {
1546 0 : pSh->StartAllAction();
1547 0 : pSh->UpdateExpFields(true);
1548 0 : pSh->EndAllAction();
1549 : }
1550 0 : }
1551 0 : sal_uInt16 SwFieldMgr::GetCurrLanguage() const
1552 : {
1553 0 : SwWrtShell* pSh = pWrtShell ? pWrtShell : ::lcl_GetShell();
1554 0 : if( pSh )
1555 0 : return pSh->GetCurLang();
1556 0 : return SvtSysLocale().GetLanguageTag().getLanguageType();
1557 : }
1558 :
1559 5 : void SwFieldType::_GetFieldName()
1560 : {
1561 : static const sal_uInt16 coFieldNms[] = {
1562 : FLD_DATE_STD,
1563 : FLD_TIME_STD,
1564 : STR_FILENAMEFLD,
1565 : STR_DBNAMEFLD,
1566 : STR_CHAPTERFLD,
1567 : STR_PAGENUMBERFLD,
1568 : STR_DOCSTATFLD,
1569 : STR_AUTHORFLD,
1570 : STR_SETFLD,
1571 : STR_GETFLD,
1572 : STR_FORMELFLD,
1573 : STR_HIDDENTXTFLD,
1574 : STR_SETREFFLD,
1575 : STR_GETREFFLD,
1576 : STR_DDEFLD,
1577 : STR_MACROFLD,
1578 : STR_INPUTFLD,
1579 : STR_HIDDENPARAFLD,
1580 : STR_DOCINFOFLD,
1581 : STR_DBFLD,
1582 : STR_USERFLD,
1583 : STR_POSTITFLD,
1584 : STR_TEMPLNAMEFLD,
1585 : STR_SEQFLD,
1586 : STR_DBNEXTSETFLD,
1587 : STR_DBNUMSETFLD,
1588 : STR_DBSETNUMBERFLD,
1589 : STR_CONDTXTFLD,
1590 : STR_NEXTPAGEFLD,
1591 : STR_PREVPAGEFLD,
1592 : STR_EXTUSERFLD,
1593 : FLD_DATE_FIX,
1594 : FLD_TIME_FIX,
1595 : STR_SETINPUTFLD,
1596 : STR_USRINPUTFLD,
1597 : STR_SETREFPAGEFLD,
1598 : STR_GETREFPAGEFLD,
1599 : STR_INTERNETFLD,
1600 : STR_JUMPEDITFLD,
1601 : STR_SCRIPTFLD,
1602 : STR_AUTHORITY,
1603 : STR_COMBINED_CHARS,
1604 : STR_DROPDOWN,
1605 : STR_CUSTOM
1606 : };
1607 :
1608 : // insert infos for fields
1609 5 : SwFieldType::s_pFieldNames = new std::vector<OUString>;
1610 5 : SwFieldType::s_pFieldNames->reserve(SAL_N_ELEMENTS(coFieldNms));
1611 225 : for( sal_uInt16 nIdx = 0; nIdx < SAL_N_ELEMENTS(coFieldNms); ++nIdx )
1612 : {
1613 220 : const OUString aTmp(SW_RES( coFieldNms[ nIdx ] ));
1614 220 : SwFieldType::s_pFieldNames->push_back(MnemonicGenerator::EraseAllMnemonicChars( aTmp ));
1615 220 : }
1616 5 : }
1617 :
1618 0 : bool SwFieldMgr::ChooseMacro(const OUString&)
1619 : {
1620 0 : bool bRet = false;
1621 :
1622 : // choose script dialog
1623 0 : OUString aScriptURL = SfxApplication::ChooseScript();
1624 :
1625 : // the script selector dialog returns a valid script URL
1626 0 : if ( !aScriptURL.isEmpty() )
1627 : {
1628 0 : SetMacroPath( aScriptURL );
1629 0 : bRet = true;
1630 : }
1631 :
1632 0 : return bRet;
1633 : }
1634 :
1635 0 : void SwFieldMgr::SetMacroPath(const OUString& rPath)
1636 : {
1637 0 : sMacroPath = rPath;
1638 0 : sMacroName = rPath;
1639 :
1640 : // try to set sMacroName member variable by parsing the macro path
1641 : // using the new URI parsing services
1642 :
1643 : Reference< XComponentContext > xContext =
1644 0 : ::comphelper::getProcessComponentContext();
1645 :
1646 : Reference< uri::XUriReferenceFactory >
1647 0 : xFactory = uri::UriReferenceFactory::create( xContext );
1648 :
1649 : Reference< uri::XVndSunStarScriptUrl >
1650 0 : xUrl( xFactory->parse( sMacroPath ), UNO_QUERY );
1651 :
1652 0 : if ( xUrl.is() )
1653 : {
1654 0 : sMacroName = xUrl->getName();
1655 0 : }
1656 0 : }
1657 :
1658 0 : sal_uLong SwFieldMgr::GetDefaultFormat(sal_uInt16 nTypeId, bool bIsText, SvNumberFormatter* pFormatter, double* pVal)
1659 : {
1660 : double fValue;
1661 : short nDefFormat;
1662 :
1663 0 : switch (nTypeId)
1664 : {
1665 : case TYP_TIMEFLD:
1666 : case TYP_DATEFLD:
1667 : {
1668 0 : Date aDate( Date::SYSTEM );
1669 0 : Date* pNullDate = pFormatter->GetNullDate();
1670 :
1671 0 : fValue = aDate - *pNullDate;
1672 :
1673 0 : tools::Time aTime( tools::Time::SYSTEM );
1674 :
1675 0 : sal_uLong nNumFormatTime = (sal_uLong)aTime.GetSec() + (sal_uLong)aTime.GetMin() * 60L +
1676 0 : (sal_uLong)aTime.GetHour() * 3600L;
1677 :
1678 0 : fValue += (double)nNumFormatTime / 86400.0;
1679 :
1680 0 : nDefFormat = (nTypeId == TYP_DATEFLD) ? css::util::NumberFormat::DATE : css::util::NumberFormat::TIME;
1681 : }
1682 0 : break;
1683 :
1684 : default:
1685 0 : if (bIsText)
1686 : {
1687 0 : fValue = 0.0;
1688 0 : nDefFormat = css::util::NumberFormat::TEXT;
1689 : }
1690 : else
1691 : {
1692 0 : fValue = 0.0;
1693 0 : nDefFormat = css::util::NumberFormat::ALL;
1694 : }
1695 0 : break;
1696 : }
1697 :
1698 0 : if (pVal)
1699 0 : *pVal = fValue;
1700 :
1701 0 : return pFormatter->GetStandardFormat(nDefFormat, GetCurrLanguage());
1702 : }
1703 :
1704 0 : Reference<XNumberingTypeInfo> SwFieldMgr::GetNumberingInfo() const
1705 : {
1706 0 : if(!xNumberingInfo.is())
1707 : {
1708 0 : Reference<XComponentContext> xContext( ::comphelper::getProcessComponentContext() );
1709 0 : Reference<XDefaultNumberingProvider> xDefNum = text::DefaultNumberingProvider::create(xContext);
1710 0 : const_cast<SwFieldMgr*>(this)->xNumberingInfo = Reference<XNumberingTypeInfo>(xDefNum, UNO_QUERY);
1711 : }
1712 0 : return xNumberingInfo;
1713 177 : }
1714 :
1715 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
