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 :
82 : using namespace com::sun::star::uno;
83 : using namespace com::sun::star::container;
84 : using namespace com::sun::star::lang;
85 : using namespace com::sun::star::beans;
86 : using namespace com::sun::star::text;
87 : using namespace com::sun::star::style;
88 : using namespace com::sun::star::sdbc;
89 : using namespace ::com::sun::star;
90 : using namespace nsSwDocInfoSubType;
91 :
92 : // groups of fields
93 : enum
94 : {
95 : GRP_DOC_BEGIN = 0,
96 : GRP_DOC_END = GRP_DOC_BEGIN + 11,
97 :
98 : GRP_FKT_BEGIN = GRP_DOC_END,
99 : GRP_FKT_END = GRP_FKT_BEGIN + 8,
100 :
101 : GRP_REF_BEGIN = GRP_FKT_END,
102 : GRP_REF_END = GRP_REF_BEGIN + 2,
103 :
104 : GRP_REG_BEGIN = GRP_REF_END,
105 : GRP_REG_END = GRP_REG_BEGIN + 1,
106 :
107 : GRP_DB_BEGIN = GRP_REG_END,
108 : GRP_DB_END = GRP_DB_BEGIN + 5,
109 :
110 : GRP_VAR_BEGIN = GRP_DB_END,
111 : GRP_VAR_END = GRP_VAR_BEGIN + 9
112 : };
113 :
114 : enum
115 : {
116 : GRP_WEB_DOC_BEGIN = 0,
117 : GRP_WEB_DOC_END = GRP_WEB_DOC_BEGIN + 9,
118 :
119 : GRP_WEB_FKT_BEGIN = GRP_WEB_DOC_END + 2,
120 : GRP_WEB_FKT_END = GRP_WEB_FKT_BEGIN + 0, // the group is empty!
121 :
122 : GRP_WEB_REF_BEGIN = GRP_WEB_FKT_END + 6, // the group is empty!
123 : GRP_WEB_REF_END = GRP_WEB_REF_BEGIN + 0,
124 :
125 : GRP_WEB_REG_BEGIN = GRP_WEB_REF_END + 2,
126 : GRP_WEB_REG_END = GRP_WEB_REG_BEGIN + 1,
127 :
128 : GRP_WEB_DB_BEGIN = GRP_WEB_REG_END, // the group is empty!
129 : GRP_WEB_DB_END = GRP_WEB_DB_BEGIN + 0,
130 :
131 : GRP_WEB_VAR_BEGIN = GRP_WEB_DB_END + 5,
132 : GRP_WEB_VAR_END = GRP_WEB_VAR_BEGIN + 1
133 : };
134 :
135 : static const sal_uInt16 VF_COUNT = 1; // { 0 }
136 : static const sal_uInt16 VF_USR_COUNT = 2; // { 0, nsSwExtendedSubType::SUB_CMD }
137 : static const sal_uInt16 VF_DB_COUNT = 1; // { nsSwExtendedSubType::SUB_OWN_FMT }
138 :
139 : // field types and subtypes
140 : struct SwFldPack
141 : {
142 : sal_uInt16 nTypeId;
143 :
144 : sal_uInt16 nSubTypeStart;
145 : sal_uInt16 nSubTypeEnd;
146 :
147 : sal_uLong nFmtBegin;
148 : sal_uLong nFmtEnd;
149 : };
150 :
151 : // strings and formats
152 : static const SwFldPack aSwFlds[] =
153 : {
154 : // Document
155 : { TYP_EXTUSERFLD, FLD_EU_BEGIN, FLD_EU_END, 0, 0 },
156 : { TYP_AUTHORFLD, 0, 0, FMT_AUTHOR_BEGIN, FMT_AUTHOR_END },
157 : { TYP_DATEFLD, FLD_DATE_BEGIN, FLD_DATE_END, 0, 0 },
158 : { TYP_TIMEFLD, FLD_TIME_BEGIN, FLD_TIME_END, 0, 0 },
159 : { TYP_PAGENUMBERFLD, 0, 0, FMT_NUM_BEGIN, FMT_NUM_END-1 },
160 : { TYP_NEXTPAGEFLD, 0, 0, FMT_NUM_BEGIN, FMT_NUM_END },
161 : { TYP_PREVPAGEFLD, 0, 0, FMT_NUM_BEGIN, FMT_NUM_END },
162 : { TYP_FILENAMEFLD, 0, 0, FMT_FF_BEGIN, FMT_FF_END },
163 : { TYP_DOCSTATFLD, FLD_STAT_BEGIN, FLD_STAT_END, FMT_NUM_BEGIN, FMT_NUM_END-1 },
164 :
165 : { TYP_CHAPTERFLD, 0, 0, FMT_CHAPTER_BEGIN, FMT_CHAPTER_END },
166 : { TYP_TEMPLNAMEFLD, 0, 0, FMT_FF_BEGIN, FMT_FF_END },
167 :
168 : // Functions
169 : { TYP_CONDTXTFLD, 0, 0, 0, 0 },
170 : { TYP_DROPDOWN, 0, 0, 0, 0 },
171 : { TYP_INPUTFLD, FLD_INPUT_BEGIN, FLD_INPUT_END, 0, 0 },
172 : { TYP_MACROFLD, 0, 0, 0, 0 },
173 : { TYP_JUMPEDITFLD, 0, 0, FMT_MARK_BEGIN, FMT_MARK_END },
174 : { TYP_COMBINED_CHARS, 0, 0, 0, 0 },
175 : { TYP_HIDDENTXTFLD, 0, 0, 0, 0 },
176 : { TYP_HIDDENPARAFLD, 0, 0, 0, 0 },
177 :
178 : // Cross-References
179 : { TYP_SETREFFLD, 0, 0, 0, 0 },
180 : { TYP_GETREFFLD, 0, 0, FMT_REF_BEGIN, FMT_REF_END },
181 :
182 : // DocInformation
183 : { TYP_DOCINFOFLD, 0, 0, FMT_REG_BEGIN, FMT_REG_END },
184 :
185 : // Database
186 : { TYP_DBFLD, 0, 0, FMT_DBFLD_BEGIN, FMT_DBFLD_END },
187 : { TYP_DBNEXTSETFLD, 0, 0, 0, 0 },
188 : { TYP_DBNUMSETFLD, 0, 0, 0, 0 },
189 : { TYP_DBSETNUMBERFLD, 0, 0, FMT_NUM_BEGIN, FMT_NUM_END-2 },
190 : { TYP_DBNAMEFLD, 0, 0, 0, 0 },
191 :
192 : // Variables
193 : { TYP_SETFLD, 0, 0, FMT_SETVAR_BEGIN, FMT_SETVAR_END },
194 :
195 : { TYP_GETFLD, 0, 0, FMT_GETVAR_BEGIN, FMT_GETVAR_END },
196 : { TYP_DDEFLD, 0, 0, FMT_DDE_BEGIN, FMT_DDE_END },
197 : { TYP_FORMELFLD, 0, 0, FMT_GETVAR_BEGIN, FMT_GETVAR_END },
198 : { TYP_INPUTFLD, FLD_INPUT_BEGIN, FLD_INPUT_END, 0, 0 },
199 : { TYP_SEQFLD, 0, 0, FMT_NUM_BEGIN, FMT_NUM_END-2 },
200 : { TYP_SETREFPAGEFLD, FLD_PAGEREF_BEGIN, FLD_PAGEREF_END,0, 0 },
201 : { TYP_GETREFPAGEFLD, 0, 0, FMT_NUM_BEGIN, FMT_NUM_END-1 },
202 : { TYP_USERFLD, 0, 0, FMT_USERVAR_BEGIN, FMT_USERVAR_END }
203 : };
204 :
205 : // access to the shell
206 0 : static SwWrtShell* lcl_GetShell()
207 : {
208 : SwView* pView;
209 0 : if ( 0 != (pView = ::GetActiveView()) )
210 0 : return pView->GetWrtShellPtr();
211 : OSL_FAIL("no current shell found!");
212 0 : return 0;
213 : }
214 :
215 0 : inline sal_uInt16 GetPackCount() { return sizeof(aSwFlds) / sizeof(SwFldPack); }
216 :
217 : // FieldManager controls inserting and updating of fields
218 0 : SwFldMgr::SwFldMgr(SwWrtShell* pSh ) :
219 : pModule(0),
220 : pMacroItem(0),
221 : pWrtShell(pSh),
222 0 : bEvalExp(true)
223 : {
224 : // determine current field if existing
225 0 : GetCurFld();
226 0 : }
227 :
228 0 : SwFldMgr::~SwFldMgr()
229 : {
230 0 : }
231 :
232 : // organise RefMark by names
233 0 : bool SwFldMgr::CanInsertRefMark( const OUString& rStr )
234 : {
235 0 : bool bRet = false;
236 0 : SwWrtShell *pSh = pWrtShell ? pWrtShell : lcl_GetShell();
237 : OSL_ENSURE(pSh, "no SwWrtShell found");
238 0 : if(pSh)
239 : {
240 0 : sal_uInt16 nCnt = pSh->GetCrsrCnt();
241 :
242 : // the last Crsr doesn't have to be a spanned selection
243 0 : if( 1 < nCnt && !pSh->SwCrsrShell::HasSelection() )
244 0 : --nCnt;
245 :
246 0 : bRet = 2 > nCnt && 0 == pSh->GetRefMark( rStr );
247 : }
248 0 : return bRet;
249 : }
250 :
251 : // access over ResIds
252 0 : void SwFldMgr::RemoveFldType(sal_uInt16 nResId, const OUString& rName )
253 : {
254 0 : SwWrtShell * pSh = pWrtShell ? pWrtShell : lcl_GetShell();
255 : OSL_ENSURE(pSh, "no SwWrtShell found");
256 0 : if( pSh )
257 0 : pSh->RemoveFldType(nResId, rName);
258 0 : }
259 :
260 0 : sal_uInt16 SwFldMgr::GetFldTypeCount(sal_uInt16 nResId) const
261 : {
262 0 : SwWrtShell * pSh = pWrtShell ? pWrtShell : lcl_GetShell();
263 : OSL_ENSURE(pSh, "no SwWrtShell found");
264 0 : return pSh ? pSh->GetFldTypeCount(nResId) : 0;
265 : }
266 :
267 0 : SwFieldType* SwFldMgr::GetFldType(sal_uInt16 nResId, sal_uInt16 nId) const
268 : {
269 0 : SwWrtShell * pSh = pWrtShell ? pWrtShell : lcl_GetShell();
270 : OSL_ENSURE(pSh, "no SwWrtShell found");
271 0 : return pSh ? pSh->GetFldType(nId, nResId) : 0;
272 : }
273 :
274 0 : SwFieldType* SwFldMgr::GetFldType(sal_uInt16 nResId, const OUString& rName) const
275 : {
276 0 : SwWrtShell * pSh = pWrtShell ? pWrtShell : lcl_GetShell();
277 : OSL_ENSURE(pSh, "no SwWrtShell found");
278 0 : return pSh ? pSh->GetFldType(nResId, rName) : 0;
279 : }
280 :
281 : // determine current field
282 0 : SwField* SwFldMgr::GetCurFld()
283 : {
284 0 : SwWrtShell *pSh = pWrtShell ? pWrtShell : ::lcl_GetShell();
285 0 : if ( pSh )
286 0 : pCurFld = pSh->GetCurFld( true );
287 : else
288 0 : pCurFld = NULL;
289 :
290 : // initialise strings and format
291 0 : aCurPar1 = "";
292 0 : aCurPar2 = "";
293 0 : sCurFrame = "";
294 0 : nCurFmt = 0;
295 :
296 0 : if(!pCurFld)
297 0 : return 0;
298 :
299 : // preprocess current values; determine parameter 1 and parameter 2
300 : // as well as the format
301 0 : const sal_uInt16 nTypeId = pCurFld->GetTypeId();
302 :
303 0 : nCurFmt = pCurFld->GetFormat();
304 0 : aCurPar1 = pCurFld->GetPar1();
305 0 : aCurPar2 = pCurFld->GetPar2();
306 :
307 0 : switch( nTypeId )
308 : {
309 : case TYP_PAGENUMBERFLD:
310 : case TYP_NEXTPAGEFLD:
311 : case TYP_PREVPAGEFLD:
312 : case TYP_GETREFPAGEFLD:
313 0 : if( nCurFmt == SVX_NUM_PAGEDESC )
314 0 : nCurFmt -= 2;
315 0 : break;
316 : }
317 0 : return pCurFld;
318 : }
319 :
320 : // provide group range
321 0 : const SwFldGroupRgn& SwFldMgr::GetGroupRange(bool bHtmlMode, sal_uInt16 nGrpId) const
322 : {
323 : static SwFldGroupRgn const aRanges[] =
324 : {
325 : { /* Document */ GRP_DOC_BEGIN, GRP_DOC_END },
326 : { /* Functions */ GRP_FKT_BEGIN, GRP_FKT_END },
327 : { /* Cross-Refs */ GRP_REF_BEGIN, GRP_REF_END },
328 : { /* DocInfos */ GRP_REG_BEGIN, GRP_REG_END },
329 : { /* Database */ GRP_DB_BEGIN, GRP_DB_END },
330 : { /* User */ GRP_VAR_BEGIN, GRP_VAR_END }
331 : };
332 : static SwFldGroupRgn const aWebRanges[] =
333 : {
334 : { /* Document */ GRP_WEB_DOC_BEGIN, GRP_WEB_DOC_END },
335 : { /* Functions */ GRP_WEB_FKT_BEGIN, GRP_WEB_FKT_END },
336 : { /* Cross-Refs */ GRP_WEB_REF_BEGIN, GRP_WEB_REF_END },
337 : { /* DocInfos */ GRP_WEB_REG_BEGIN, GRP_WEB_REG_END },
338 : { /* Database */ GRP_WEB_DB_BEGIN, GRP_WEB_DB_END },
339 : { /* User */ GRP_WEB_VAR_BEGIN, GRP_WEB_VAR_END }
340 : };
341 :
342 0 : if (bHtmlMode)
343 0 : return aWebRanges[(sal_uInt16)nGrpId];
344 : else
345 0 : return aRanges[(sal_uInt16)nGrpId];
346 : }
347 :
348 : // determine GroupId
349 0 : sal_uInt16 SwFldMgr::GetGroup(bool bHtmlMode, sal_uInt16 nTypeId, sal_uInt16 nSubType) const
350 : {
351 0 : if (nTypeId == TYP_SETINPFLD)
352 0 : nTypeId = TYP_SETFLD;
353 :
354 0 : if (nTypeId == TYP_INPUTFLD && (nSubType & INP_USR))
355 0 : nTypeId = TYP_USERFLD;
356 :
357 0 : if (nTypeId == TYP_FIXDATEFLD)
358 0 : nTypeId = TYP_DATEFLD;
359 :
360 0 : if (nTypeId == TYP_FIXTIMEFLD)
361 0 : nTypeId = TYP_TIMEFLD;
362 :
363 0 : for (sal_uInt16 i = GRP_DOC; i <= GRP_VAR; i++)
364 : {
365 0 : const SwFldGroupRgn& rRange = GetGroupRange(bHtmlMode, i);
366 0 : for (sal_uInt16 nPos = rRange.nStart; nPos < rRange.nEnd; nPos++)
367 : {
368 0 : if (aSwFlds[nPos].nTypeId == nTypeId)
369 0 : return i;
370 : }
371 : }
372 0 : return USHRT_MAX;
373 : }
374 :
375 : // determine names to TypeId
376 : // ACCESS over TYP_....
377 0 : sal_uInt16 SwFldMgr::GetTypeId(sal_uInt16 nPos)
378 : {
379 : OSL_ENSURE(nPos < ::GetPackCount(), "forbidden Pos");
380 0 : return aSwFlds[ nPos ].nTypeId;
381 : }
382 :
383 0 : OUString SwFldMgr::GetTypeStr(sal_uInt16 nPos)
384 : {
385 : OSL_ENSURE(nPos < ::GetPackCount(), "forbidden TypeId");
386 :
387 0 : sal_uInt16 nFldWh = aSwFlds[ nPos ].nTypeId;
388 :
389 : // special treatment for date/time fields (without var/fix)
390 0 : if( TYP_DATEFLD == nFldWh )
391 : {
392 0 : static OUString g_aDate( SW_RES( STR_DATEFLD ) );
393 0 : return g_aDate;
394 : }
395 0 : if( TYP_TIMEFLD == nFldWh )
396 : {
397 0 : static OUString g_aTime( SW_RES( STR_TIMEFLD ) );
398 0 : return g_aTime;
399 : }
400 :
401 0 : return SwFieldType::GetTypeStr( nFldWh );
402 : }
403 :
404 : // determine Pos in the list
405 0 : sal_uInt16 SwFldMgr::GetPos(sal_uInt16 nTypeId)
406 : {
407 0 : switch( nTypeId )
408 : {
409 0 : case TYP_FIXDATEFLD: nTypeId = TYP_DATEFLD; break;
410 0 : case TYP_FIXTIMEFLD: nTypeId = TYP_TIMEFLD; break;
411 0 : case TYP_SETINPFLD: nTypeId = TYP_SETFLD; break;
412 0 : case TYP_USRINPFLD: nTypeId = TYP_USERFLD; break;
413 : }
414 :
415 0 : for(sal_uInt16 i = 0; i < GetPackCount(); i++)
416 0 : if(aSwFlds[i].nTypeId == nTypeId)
417 0 : return i;
418 :
419 0 : return USHRT_MAX;
420 : }
421 :
422 : // localise subtypes of a field
423 0 : bool SwFldMgr::GetSubTypes(sal_uInt16 nTypeId, std::vector<OUString>& rToFill)
424 : {
425 0 : bool bRet = false;
426 0 : SwWrtShell *pSh = pWrtShell ? pWrtShell : lcl_GetShell();
427 : OSL_ENSURE(pSh, "no SwWrtShell found");
428 0 : if(pSh)
429 : {
430 0 : const sal_uInt16 nPos = GetPos(nTypeId);
431 :
432 0 : switch(nTypeId)
433 : {
434 : case TYP_SETREFFLD:
435 : case TYP_GETREFFLD:
436 : {
437 : // references are no fields
438 0 : pSh->GetRefMarks( &rToFill );
439 0 : break;
440 : }
441 : case TYP_MACROFLD:
442 : {
443 0 : break;
444 : }
445 : case TYP_INPUTFLD:
446 : {
447 0 : rToFill.push_back(SW_RES(aSwFlds[nPos].nSubTypeStart));
448 : // move on at generic types
449 : }
450 : case TYP_DDEFLD:
451 : case TYP_SEQFLD:
452 : case TYP_FORMELFLD:
453 : case TYP_GETFLD:
454 : case TYP_SETFLD:
455 : case TYP_USERFLD:
456 : {
457 :
458 0 : const sal_uInt16 nCount = pSh->GetFldTypeCount();
459 0 : for(sal_uInt16 i = 0; i < nCount; ++i)
460 : {
461 0 : SwFieldType* pFldType = pSh->GetFldType( i );
462 0 : const sal_uInt16 nWhich = pFldType->Which();
463 :
464 0 : if((nTypeId == TYP_DDEFLD && pFldType->Which() == RES_DDEFLD) ||
465 :
466 0 : (nTypeId == TYP_USERFLD && nWhich == RES_USERFLD) ||
467 :
468 0 : (nTypeId == TYP_GETFLD && nWhich == RES_SETEXPFLD &&
469 0 : !(((SwSetExpFieldType*)pFldType)->GetType() & nsSwGetSetExpType::GSE_SEQ)) ||
470 :
471 0 : (nTypeId == TYP_SETFLD && nWhich == RES_SETEXPFLD &&
472 0 : !(((SwSetExpFieldType*)pFldType)->GetType() & nsSwGetSetExpType::GSE_SEQ)) ||
473 :
474 0 : (nTypeId == TYP_SEQFLD && nWhich == RES_SETEXPFLD &&
475 0 : (((SwSetExpFieldType*)pFldType)->GetType() & nsSwGetSetExpType::GSE_SEQ)) ||
476 :
477 0 : ((nTypeId == TYP_INPUTFLD || nTypeId == TYP_FORMELFLD) &&
478 0 : (nWhich == RES_USERFLD ||
479 0 : (nWhich == RES_SETEXPFLD &&
480 0 : !(((SwSetExpFieldType*)pFldType)->GetType() & nsSwGetSetExpType::GSE_SEQ))) ) )
481 : {
482 0 : rToFill.push_back(pFldType->GetName());
483 : }
484 : }
485 0 : break;
486 : }
487 : case TYP_DBNEXTSETFLD:
488 : case TYP_DBNUMSETFLD:
489 : case TYP_DBNAMEFLD:
490 : case TYP_DBSETNUMBERFLD:
491 0 : break;
492 :
493 : default:
494 : {
495 : // static SubTypes
496 0 : if(nPos != USHRT_MAX)
497 : {
498 : sal_uInt16 nCount;
499 0 : if (nTypeId == TYP_DOCINFOFLD)
500 0 : nCount = DI_SUBTYPE_END - DI_SUBTYPE_BEGIN;
501 : else
502 0 : nCount = aSwFlds[nPos].nSubTypeEnd - aSwFlds[nPos].nSubTypeStart;
503 :
504 0 : for(sal_uInt16 i = 0; i < nCount; ++i)
505 : {
506 0 : OUString sNew;
507 0 : if (nTypeId == TYP_DOCINFOFLD)
508 : {
509 0 : if ( i == DI_CUSTOM )
510 0 : sNew = SW_RES( STR_CUSTOM );
511 : else
512 0 : sNew = SwViewShell::GetShellRes()->aDocInfoLst[i];
513 : }
514 : else
515 0 : sNew = SW_RES(aSwFlds[nPos].nSubTypeStart + i);
516 :
517 0 : rToFill.push_back(sNew);
518 0 : }
519 : }
520 : }
521 : }
522 0 : bRet = true;
523 : }
524 0 : return bRet;
525 : }
526 :
527 : // determine format
528 : // ACCESS over TYP_....
529 0 : sal_uInt16 SwFldMgr::GetFormatCount(sal_uInt16 nTypeId, bool bIsText, bool bHtmlMode) const
530 : {
531 : OSL_ENSURE(nTypeId < TYP_END, "forbidden TypeId");
532 : {
533 0 : const sal_uInt16 nPos = GetPos(nTypeId);
534 :
535 0 : if(nPos == USHRT_MAX || (bHtmlMode && nTypeId == TYP_SETFLD))
536 0 : return 0;
537 :
538 0 : sal_uLong nStart = aSwFlds[nPos].nFmtBegin;
539 0 : sal_uLong nEnd = aSwFlds[nPos].nFmtEnd;
540 :
541 0 : if (bIsText && nEnd - nStart >= 2)
542 0 : return 2;
543 :
544 0 : if (nTypeId == TYP_FILENAMEFLD)
545 0 : nEnd -= 2; // no range or template
546 :
547 0 : switch(nStart)
548 : {
549 : case FMT_GETVAR_BEGIN:
550 0 : case FMT_SETVAR_BEGIN: return VF_COUNT;
551 0 : case FMT_USERVAR_BEGIN: return VF_USR_COUNT;
552 0 : case FMT_DBFLD_BEGIN: return VF_DB_COUNT;
553 : case FMT_NUM_BEGIN:
554 : {
555 0 : sal_uInt16 nCount = (sal_uInt16)(nEnd - nStart);
556 0 : GetNumberingInfo();
557 0 : if(xNumberingInfo.is())
558 : {
559 0 : Sequence<sal_Int16> aTypes = xNumberingInfo->getSupportedNumberingTypes();
560 0 : const sal_Int16* pTypes = aTypes.getConstArray();
561 0 : for(sal_Int32 nType = 0; nType < aTypes.getLength(); nType++)
562 : {
563 0 : sal_Int16 nCurrent = pTypes[nType];
564 : //skip all values below or equal to CHARS_LOWER_LETTER_N
565 0 : if(nCurrent > NumberingType::CHARS_LOWER_LETTER_N)
566 : {
567 : // #i28073# it's not necessarily a sorted sequence
568 0 : ++nCount;
569 : }
570 0 : }
571 : }
572 0 : return nCount;
573 : }
574 :
575 : }
576 0 : return (sal_uInt16)(nEnd - nStart);
577 : }
578 : }
579 :
580 : // determine FormatString to a type
581 0 : OUString SwFldMgr::GetFormatStr(sal_uInt16 nTypeId, sal_uLong nFormatId) const
582 : {
583 : OSL_ENSURE(nTypeId < TYP_END, "forbidden TypeId");
584 0 : const sal_uInt16 nPos = GetPos(nTypeId);
585 :
586 0 : if(nPos == USHRT_MAX)
587 0 : return OUString();
588 :
589 : sal_uLong nStart;
590 :
591 0 : nStart = aSwFlds[nPos].nFmtBegin;
592 :
593 0 : if (TYP_AUTHORFLD == nTypeId|| TYP_FILENAMEFLD == nTypeId)
594 0 : nFormatId &= ~FF_FIXED; // mask out Fixed-Flag
595 :
596 0 : if((nStart + nFormatId) < aSwFlds[nPos].nFmtEnd)
597 0 : return SW_RES((sal_uInt16)(nStart + nFormatId));
598 :
599 0 : OUString aRet;
600 0 : if( FMT_NUM_BEGIN == nStart)
601 : {
602 0 : if(xNumberingInfo.is())
603 : {
604 0 : SwOLENames aNames(SW_RES(STRRES_NUMTYPES));
605 0 : ResStringArray& rNames = aNames.GetNames();
606 :
607 0 : Sequence<sal_Int16> aTypes = xNumberingInfo->getSupportedNumberingTypes();
608 0 : const sal_Int16* pTypes = aTypes.getConstArray();
609 0 : sal_Int32 nOffset = aSwFlds[nPos].nFmtEnd - nStart;
610 0 : sal_Int32 nValidEntry = 0;
611 0 : for(sal_Int32 nType = 0; nType < aTypes.getLength(); nType++)
612 : {
613 0 : sal_Int16 nCurrent = pTypes[nType];
614 0 : if(nCurrent > NumberingType::CHARS_LOWER_LETTER_N)
615 : {
616 0 : if(nValidEntry == ((sal_Int32)nFormatId) - nOffset)
617 : {
618 0 : sal_uInt32 n = rNames.FindIndex(pTypes[nType]);
619 0 : if (n != RESARRAY_INDEX_NOTFOUND)
620 : {
621 0 : aRet = rNames.GetString(n);
622 : }
623 : else
624 : {
625 0 : aRet = xNumberingInfo->getNumberingIdentifier( pTypes[nType] );
626 : }
627 0 : break;
628 : }
629 0 : ++nValidEntry;
630 : }
631 0 : }
632 : }
633 : }
634 :
635 0 : return aRet;
636 : }
637 :
638 : // determine FormatId from Pseudo-ID
639 0 : sal_uInt16 SwFldMgr::GetFormatId(sal_uInt16 nTypeId, sal_uLong nFormatId) const
640 : {
641 0 : sal_uInt16 nId = (sal_uInt16)nFormatId;
642 0 : switch( nTypeId )
643 : {
644 : case TYP_DOCINFOFLD:
645 0 : switch( aSwFlds[ GetPos( nTypeId ) ].nFmtBegin + nFormatId )
646 : {
647 0 : case FMT_REG_AUTHOR: nId = DI_SUB_AUTHOR; break;
648 0 : case FMT_REG_TIME: nId = DI_SUB_TIME; break;
649 0 : case FMT_REG_DATE: nId = DI_SUB_DATE; break;
650 : }
651 0 : break;
652 :
653 : case TYP_PAGENUMBERFLD:
654 : case TYP_NEXTPAGEFLD:
655 : case TYP_PREVPAGEFLD:
656 : case TYP_DOCSTATFLD:
657 : case TYP_DBSETNUMBERFLD:
658 : case TYP_SEQFLD:
659 : case TYP_GETREFPAGEFLD:
660 : {
661 0 : sal_uInt16 nPos = GetPos( nTypeId );
662 0 : sal_uLong nBegin = aSwFlds[ nPos ].nFmtBegin;
663 0 : sal_uLong nEnd = aSwFlds[nPos].nFmtEnd;
664 0 : if((nBegin + nFormatId) < nEnd)
665 : {
666 0 : switch( nBegin + nFormatId )
667 : {
668 0 : case FMT_NUM_ABC: nId = SVX_NUM_CHARS_UPPER_LETTER; break;
669 0 : case FMT_NUM_SABC: nId = SVX_NUM_CHARS_LOWER_LETTER; break;
670 0 : case FMT_NUM_ROMAN: nId = SVX_NUM_ROMAN_UPPER; break;
671 0 : case FMT_NUM_SROMAN: nId = SVX_NUM_ROMAN_LOWER; break;
672 0 : case FMT_NUM_ARABIC: nId = SVX_NUM_ARABIC; break;
673 0 : case FMT_NUM_PAGEDESC: nId = SVX_NUM_PAGEDESC; break;
674 0 : case FMT_NUM_PAGESPECIAL: nId = SVX_NUM_CHAR_SPECIAL; break;
675 0 : case FMT_NUM_ABC_N: nId = SVX_NUM_CHARS_UPPER_LETTER_N; break;
676 0 : case FMT_NUM_SABC_N: nId = SVX_NUM_CHARS_LOWER_LETTER_N; break;
677 : }
678 : }
679 0 : else if(xNumberingInfo.is())
680 : {
681 0 : Sequence<sal_Int16> aTypes = xNumberingInfo->getSupportedNumberingTypes();
682 0 : const sal_Int16* pTypes = aTypes.getConstArray();
683 0 : sal_Int32 nOffset = nEnd - nBegin;
684 0 : sal_Int32 nValidEntry = 0;
685 0 : for(sal_Int32 nType = 0; nType < aTypes.getLength(); nType++)
686 : {
687 0 : sal_Int16 nCurrent = pTypes[nType];
688 0 : if(nCurrent > NumberingType::CHARS_LOWER_LETTER_N)
689 : {
690 0 : if(nValidEntry == ((sal_Int32)nFormatId) - nOffset)
691 : {
692 0 : nId = pTypes[nType];
693 0 : break;
694 : }
695 0 : ++nValidEntry;
696 : }
697 0 : }
698 : }
699 : }
700 0 : break;
701 : case TYP_DDEFLD:
702 0 : switch ( aSwFlds[ GetPos( nTypeId ) ].nFmtBegin + nFormatId )
703 : {
704 0 : case FMT_DDE_NORMAL: nId = sfx2::LINKUPDATE_ONCALL; break;
705 0 : case FMT_DDE_HOT: nId = sfx2::LINKUPDATE_ALWAYS; break;
706 : }
707 0 : break;
708 : }
709 :
710 0 : return nId;
711 :
712 : }
713 :
714 : // Traveling
715 0 : bool SwFldMgr::GoNextPrev( bool bNext, SwFieldType* pTyp )
716 : {
717 0 : SwWrtShell* pSh = pWrtShell ? pWrtShell : ::lcl_GetShell();
718 0 : if(!pSh)
719 0 : return false;
720 :
721 0 : if( !pTyp && pCurFld )
722 : {
723 0 : const sal_uInt16 nTypeId = pCurFld->GetTypeId();
724 0 : if( TYP_SETINPFLD == nTypeId || TYP_USRINPFLD == nTypeId )
725 0 : pTyp = pSh->GetFldType( 0, RES_INPUTFLD );
726 : else
727 0 : pTyp = pCurFld->GetTyp();
728 : }
729 :
730 0 : if (pTyp && pTyp->Which() == RES_DBFLD)
731 : {
732 : // for fieldcommand-edit (hop to all DB fields)
733 0 : return pSh->MoveFldType( 0, bNext, RES_DBFLD );
734 : }
735 :
736 0 : return (pTyp && pSh)
737 0 : ? pSh->MoveFldType( pTyp, bNext )
738 0 : : sal_False;
739 : }
740 :
741 : // insert field types
742 0 : void SwFldMgr::InsertFldType(SwFieldType& rType)
743 : {
744 0 : SwWrtShell* pSh = pWrtShell ? pWrtShell : ::lcl_GetShell();
745 : OSL_ENSURE(pSh, "no SwWrtShell found");
746 0 : if(pSh)
747 0 : pSh->InsertFldType(rType);
748 0 : }
749 :
750 : // determine current TypeId
751 0 : sal_uInt16 SwFldMgr::GetCurTypeId() const
752 : {
753 0 : return pCurFld ? pCurFld->GetTypeId() : USHRT_MAX;
754 : }
755 :
756 : // Over string insert field or update
757 0 : bool SwFldMgr::InsertFld(
758 : const SwInsertFld_Data& rData)
759 : {
760 0 : SwField* pFld = 0;
761 0 : bool bExp = false;
762 0 : bool bTbl = false;
763 0 : bool bPageVar = false;
764 0 : sal_uLong nFormatId = rData.nFormatId;
765 0 : sal_uInt16 nSubType = rData.nSubType;
766 0 : sal_Unicode cSeparator = rData.cSeparator;
767 0 : SwWrtShell* pCurShell = rData.pSh;
768 0 : if(!pCurShell)
769 0 : pCurShell = pWrtShell ? pWrtShell : ::lcl_GetShell();
770 : OSL_ENSURE(pCurShell, "no SwWrtShell found");
771 0 : if(!pCurShell)
772 0 : return false;
773 :
774 0 : switch(rData.nTypeId)
775 : { // ATTENTION this field is inserted by a separate dialog
776 : case TYP_POSTITFLD:
777 : {
778 0 : SwPostItFieldType* pType = (SwPostItFieldType*)pCurShell->GetFldType(0, RES_POSTITFLD);
779 : SwPostItField* pPostItField =
780 : new SwPostItField(
781 : pType,
782 : rData.sPar1, // author
783 : rData.sPar2, // content
784 : OUString(), // author's initials
785 : OUString(), // name
786 0 : DateTime(DateTime::SYSTEM) );
787 0 : pFld = pPostItField;
788 : }
789 0 : break;
790 : case TYP_SCRIPTFLD:
791 : {
792 : SwScriptFieldType* pType =
793 0 : (SwScriptFieldType*)pCurShell->GetFldType(0, RES_SCRIPTFLD);
794 0 : pFld = new SwScriptField(pType, rData.sPar1, rData.sPar2, (bool)nFormatId);
795 0 : break;
796 : }
797 :
798 : case TYP_COMBINED_CHARS:
799 : {
800 : SwCombinedCharFieldType* pType = (SwCombinedCharFieldType*)
801 0 : pCurShell->GetFldType( 0, RES_COMBINED_CHARS );
802 0 : pFld = new SwCombinedCharField( pType, rData.sPar1 );
803 : }
804 0 : break;
805 :
806 : case TYP_AUTHORITY:
807 : {
808 : SwAuthorityFieldType* pType =
809 0 : (SwAuthorityFieldType*)pCurShell->GetFldType(0, RES_AUTHORITY);
810 0 : if (!pType)
811 : {
812 0 : SwAuthorityFieldType const type(pCurShell->GetDoc());
813 : pType = static_cast<SwAuthorityFieldType*>(
814 0 : pCurShell->InsertFldType(type));
815 : }
816 0 : pFld = new SwAuthorityField(pType, rData.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.nTypeId == TYP_DATEFLD ? DATEFLD : TIMEFLD);
824 0 : nSub |= nSubType == DATE_VAR ? 0 : FIXEDFLD;
825 :
826 : SwDateTimeFieldType* pTyp =
827 0 : (SwDateTimeFieldType*)pCurShell->GetFldType(0, RES_DATETIMEFLD);
828 0 : pFld = new SwDateTimeField(pTyp, nSub, nFormatId);
829 0 : pFld->SetPar2(rData.sPar2);
830 0 : break;
831 : }
832 :
833 : case TYP_FILENAMEFLD:
834 : {
835 : SwFileNameFieldType* pTyp =
836 0 : (SwFileNameFieldType*)pCurShell->GetFldType(0, RES_FILENAMEFLD);
837 0 : pFld = new SwFileNameField(pTyp, nFormatId);
838 0 : break;
839 : }
840 :
841 : case TYP_TEMPLNAMEFLD:
842 : {
843 : SwTemplNameFieldType* pTyp =
844 0 : (SwTemplNameFieldType*)pCurShell->GetFldType(0, RES_TEMPLNAMEFLD);
845 0 : pFld = new SwTemplNameField(pTyp, nFormatId);
846 0 : break;
847 : }
848 :
849 : case TYP_CHAPTERFLD:
850 : {
851 0 : sal_uInt16 nByte = (sal_uInt16)rData.sPar2.toInt32();
852 : SwChapterFieldType* pTyp =
853 0 : (SwChapterFieldType*)pCurShell->GetFldType(0, RES_CHAPTERFLD);
854 0 : pFld = 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 : ((SwChapterField*)pFld)->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.sPar2.toInt32();
867 :
868 0 : if(rData.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.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 : (SwPageNumberFieldType*)pCurShell->GetFldType(0, RES_PAGENUMBERFLD);
889 0 : pFld = 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 : ((SwPageNumberField*)pFld)->SetUserString( rData.sPar2 );
894 0 : break;
895 : }
896 :
897 : case TYP_DOCSTATFLD:
898 : {
899 : SwDocStatFieldType* pTyp =
900 0 : (SwDocStatFieldType*)pCurShell->GetFldType(0, RES_DOCSTATFLD);
901 0 : pFld = new SwDocStatField(pTyp, nSubType, nFormatId);
902 0 : break;
903 : }
904 :
905 : case TYP_AUTHORFLD:
906 : {
907 : SwAuthorFieldType* pTyp =
908 0 : (SwAuthorFieldType*)pCurShell->GetFldType(0, RES_AUTHORFLD);
909 0 : pFld = new SwAuthorField(pTyp, nFormatId);
910 0 : break;
911 : }
912 :
913 : case TYP_CONDTXTFLD:
914 : case TYP_HIDDENTXTFLD:
915 : {
916 : SwHiddenTxtFieldType* pTyp =
917 0 : (SwHiddenTxtFieldType*)pCurShell->GetFldType(0, RES_HIDDENTXTFLD);
918 0 : pFld = new SwHiddenTxtField(pTyp, true, rData.sPar1, rData.sPar2, false, rData.nTypeId);
919 0 : bExp = true;
920 0 : break;
921 : }
922 :
923 : case TYP_HIDDENPARAFLD:
924 : {
925 : SwHiddenParaFieldType* pTyp =
926 0 : (SwHiddenParaFieldType*)pCurShell->GetFldType(0, RES_HIDDENPARAFLD);
927 0 : pFld = new SwHiddenParaField(pTyp, rData.sPar1);
928 0 : bExp = true;
929 0 : break;
930 : }
931 :
932 : case TYP_SETREFFLD:
933 : {
934 0 : if( !rData.sPar1.isEmpty() && CanInsertRefMark( rData.sPar1 ) )
935 : {
936 0 : pCurShell->SetAttrItem( SwFmtRefMark( rData.sPar1 ) );
937 0 : return true;
938 : }
939 0 : return false;
940 : }
941 :
942 : case TYP_GETREFFLD:
943 : {
944 : SwGetRefFieldType* pTyp =
945 0 : (SwGetRefFieldType*)pCurShell->GetFldType(0, RES_GETREFFLD);
946 0 : sal_uInt16 nSeqNo = (sal_uInt16)rData.sPar2.toInt32();
947 0 : pFld = new SwGetRefField(pTyp, rData.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.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.sPar1, sCmd, (sal_uInt16) nFormatId );
964 0 : SwDDEFieldType* pTyp = (SwDDEFieldType*) pCurShell->InsertFldType( aType );
965 0 : pFld = new SwDDEField( pTyp );
966 0 : break;
967 : }
968 :
969 : case TYP_MACROFLD:
970 : {
971 : SwMacroFieldType* pTyp =
972 0 : (SwMacroFieldType*)pCurShell->GetFldType(0, RES_MACROFLD);
973 :
974 0 : pFld = new SwMacroField(pTyp, rData.sPar1, rData.sPar2);
975 :
976 0 : break;
977 : }
978 :
979 : case TYP_INTERNETFLD:
980 : {
981 0 : SwFmtINetFmt aFmt( rData.sPar1, sCurFrame );
982 0 : if( pMacroItem )
983 0 : aFmt.SetMacroTbl( &pMacroItem->GetMacroTable() );
984 0 : return pCurShell->InsertURL( aFmt, rData.sPar2 );
985 : }
986 :
987 : case TYP_JUMPEDITFLD:
988 : {
989 : SwJumpEditFieldType* pTyp =
990 0 : (SwJumpEditFieldType*)pCurShell->GetFldType(0, RES_JUMPEDITFLD);
991 :
992 0 : pFld = new SwJumpEditField(pTyp, nFormatId, rData.sPar1, rData.sPar2 );
993 0 : break;
994 : }
995 :
996 : case TYP_DOCINFOFLD:
997 : {
998 : SwDocInfoFieldType* pTyp = (SwDocInfoFieldType*)pCurShell->GetFldType(
999 0 : 0, RES_DOCINFOFLD );
1000 0 : pFld = new SwDocInfoField(pTyp, nSubType, rData.sPar1, nFormatId);
1001 0 : break;
1002 : }
1003 :
1004 : case TYP_EXTUSERFLD:
1005 : {
1006 : SwExtUserFieldType* pTyp = (SwExtUserFieldType*)pCurShell->GetFldType(
1007 0 : 0, RES_EXTUSERFLD);
1008 0 : pFld = 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.sPar1.indexOf(DB_DELIM)<0)
1019 : {
1020 0 : aDBData = pCurShell->GetDBData();
1021 0 : sPar1 = rData.sPar1;
1022 : }
1023 : else
1024 : {
1025 0 : aDBData.sDataSource = rData.sPar1.getToken(0, DB_DELIM);
1026 0 : aDBData.sCommand = rData.sPar1.getToken(1, DB_DELIM);
1027 0 : aDBData.nCommandType = rData.sPar1.getToken(2, DB_DELIM).toInt32();
1028 0 : sPar1 = rData.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 = (SwDBFieldType*)pCurShell->InsertFldType(
1035 0 : SwDBFieldType(pCurShell->GetDoc(), sPar1, aDBData) );
1036 0 : pFld = new SwDBField(pTyp);
1037 0 : pFld->SetSubType(nSubType);
1038 :
1039 0 : if( !(nSubType & nsSwExtendedSubType::SUB_OWN_FMT) ) // determinee database format
1040 : {
1041 0 : Reference< XDataSource> xSource;
1042 0 : rData.aDBDataSource >>= xSource;
1043 0 : Reference<XConnection> xConnection;
1044 0 : rData.aDBConnection >>= xConnection;
1045 0 : Reference<XPropertySet> xColumn;
1046 0 : rData.aDBColumn >>= xColumn;
1047 0 : if(xColumn.is())
1048 : {
1049 : nFormatId = pCurShell->GetDBManager()->GetColumnFmt(xSource, xConnection, xColumn,
1050 0 : pCurShell->GetNumberFormatter(), GetCurrLanguage() );
1051 : }
1052 : else
1053 : nFormatId = pCurShell->GetDBManager()->GetColumnFmt(
1054 : aDBData.sDataSource, aDBData.sCommand, sPar1,
1055 0 : pCurShell->GetNumberFormatter(), GetCurrLanguage() );
1056 : }
1057 0 : pFld->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.sPar1. Format: DBName.TableName.CommandType.ExpStrg
1073 0 : sal_Int32 nTablePos = rData.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.sPar1.copy(0, nTablePos++);
1080 0 : nCmdTypePos = rData.sPar1.indexOf(DB_DELIM, nTablePos);
1081 0 : if (nCmdTypePos>=0)
1082 : {
1083 0 : aDBData.sCommand = rData.sPar1.copy(nTablePos, nCmdTypePos++ - nTablePos);
1084 0 : nExpPos = rData.sPar1.indexOf(DB_DELIM, nCmdTypePos);
1085 0 : if (nExpPos>=0)
1086 : {
1087 0 : aDBData.nCommandType = rData.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.sPar1.copy(nPos);
1099 :
1100 0 : if (!aDBData.sDataSource.isEmpty() && pCurShell->GetDBData() != aDBData)
1101 0 : pCurShell->ChgDBData(aDBData);
1102 :
1103 0 : switch(rData.nTypeId)
1104 : {
1105 : case TYP_DBNAMEFLD:
1106 : {
1107 : SwDBNameFieldType* pTyp =
1108 0 : (SwDBNameFieldType*)pCurShell->GetFldType(0, RES_DBNAMEFLD);
1109 0 : pFld = new SwDBNameField(pTyp, aDBData);
1110 :
1111 0 : break;
1112 : }
1113 : case TYP_DBNEXTSETFLD:
1114 : {
1115 : SwDBNextSetFieldType* pTyp = (SwDBNextSetFieldType*)pCurShell->GetFldType(
1116 0 : 0, RES_DBNEXTSETFLD);
1117 0 : pFld = new SwDBNextSetField(pTyp, sPar1, rData.sPar2, aDBData);
1118 0 : bExp = true;
1119 0 : break;
1120 : }
1121 : case TYP_DBNUMSETFLD:
1122 : {
1123 : SwDBNumSetFieldType* pTyp = (SwDBNumSetFieldType*)pCurShell->GetFldType(
1124 0 : 0, RES_DBNUMSETFLD);
1125 0 : pFld = new SwDBNumSetField( pTyp, sPar1, rData.sPar2, aDBData);
1126 0 : bExp = true;
1127 0 : break;
1128 : }
1129 : case TYP_DBSETNUMBERFLD:
1130 : {
1131 : SwDBSetNumberFieldType* pTyp = (SwDBSetNumberFieldType*)
1132 0 : pCurShell->GetFldType(0, RES_DBSETNUMBERFLD);
1133 0 : pFld = 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 : (SwUserFieldType*)pCurShell->GetFldType(RES_USERFLD, rData.sPar1);
1146 :
1147 : // only if existing
1148 0 : if(!pTyp)
1149 : {
1150 : pTyp = (SwUserFieldType*)pCurShell->InsertFldType(
1151 0 : SwUserFieldType(pCurShell->GetDoc(), rData.sPar1));
1152 : }
1153 0 : if (pTyp->GetContent(nFormatId) != rData.sPar2)
1154 0 : pTyp->SetContent(rData.sPar2, nFormatId);
1155 0 : pFld = new SwUserField(pTyp, 0, nFormatId);
1156 0 : if (pFld->GetSubType() != nSubType)
1157 0 : pFld->SetSubType(nSubType);
1158 0 : bTbl = true;
1159 0 : break;
1160 : }
1161 :
1162 : case TYP_INPUTFLD:
1163 : {
1164 0 : if ((nSubType & 0x00ff) == INP_VAR)
1165 : {
1166 : SwSetExpFieldType* pTyp = (SwSetExpFieldType*)
1167 0 : pCurShell->GetFldType(RES_SETEXPFLD, rData.sPar1);
1168 :
1169 : // no Experssion Type with this name existing -> create
1170 0 : if(pTyp)
1171 : {
1172 : SwSetExpField* pExpFld =
1173 0 : new SwSetExpField(pTyp, OUString(), nFormatId);
1174 :
1175 : // Don't change type of SwSetExpFieldType:
1176 0 : sal_uInt16 nOldSubType = pExpFld->GetSubType();
1177 0 : pExpFld->SetSubType(nOldSubType | (nSubType & 0xff00));
1178 :
1179 0 : pExpFld->SetPromptText(rData.sPar2);
1180 0 : pExpFld->SetInputFlag(true) ;
1181 0 : bExp = true;
1182 0 : pFld = pExpFld;
1183 : }
1184 : else
1185 0 : return false;
1186 : }
1187 : else
1188 : {
1189 : SwInputFieldType* pTyp =
1190 0 : (SwInputFieldType*)pCurShell->GetFldType(0, RES_INPUTFLD);
1191 :
1192 : SwInputField* pInpFld =
1193 0 : new SwInputField( pTyp, rData.sPar1, rData.sPar2, nSubType|nsSwExtendedSubType::SUB_INVISIBLE, nFormatId);
1194 0 : pFld = pInpFld;
1195 : }
1196 :
1197 : // start dialog
1198 0 : pCurShell->StartInputFldDlg(pFld, false, rData.pParent);
1199 0 : break;
1200 : }
1201 :
1202 : case TYP_SETFLD:
1203 : {
1204 0 : if (rData.sPar2.isEmpty()) // empty variables are not allowed
1205 0 : return false;
1206 :
1207 : SwSetExpFieldType* pTyp = (SwSetExpFieldType*)pCurShell->InsertFldType(
1208 0 : SwSetExpFieldType(pCurShell->GetDoc(), rData.sPar1) );
1209 :
1210 0 : SwSetExpField* pExpFld = new SwSetExpField( pTyp, rData.sPar2, nFormatId);
1211 0 : pExpFld->SetSubType(nSubType);
1212 0 : pExpFld->SetPar2(rData.sPar2);
1213 0 : bExp = true;
1214 0 : pFld = pExpFld;
1215 0 : break;
1216 : }
1217 :
1218 : case TYP_SEQFLD:
1219 : {
1220 : SwSetExpFieldType* pTyp = (SwSetExpFieldType*)pCurShell->InsertFldType(
1221 0 : SwSetExpFieldType(pCurShell->GetDoc(), rData.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* pExpFld = new SwSetExpField(pTyp, rData.sPar2, nFormatId);
1231 0 : bExp = true;
1232 0 : pFld = pExpFld;
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 = (SwSetExpFieldType*)
1241 0 : pCurShell->GetFldType(RES_SETEXPFLD, rData.sPar1);
1242 :
1243 0 : if(pSetTyp)
1244 : {
1245 : SwGetExpFieldType* pTyp = (SwGetExpFieldType*)pCurShell->GetFldType(
1246 0 : 0, RES_GETEXPFLD);
1247 0 : pFld = new SwGetExpField(pTyp, rData.sPar1, pSetTyp->GetType(), nFormatId);
1248 0 : pFld->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) & FRMTYPE_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 sFml(comphelper::string::stripStart(rData.sPar2, ' '));
1276 0 : if ( sFml.startsWith("=") )
1277 : {
1278 0 : sFml = sFml.copy(1);
1279 : }
1280 :
1281 0 : aBoxSet.Put( SwTblBoxFormula( sFml ));
1282 0 : pCurShell->SetTblBoxFormulaAttrs( aBoxSet );
1283 0 : pCurShell->UpdateTable();
1284 :
1285 0 : pCurShell->EndAllAction();
1286 0 : return true;
1287 :
1288 : }
1289 : else
1290 : {
1291 : SwGetExpFieldType* pTyp = (SwGetExpFieldType*)
1292 0 : pCurShell->GetFldType(0, RES_GETEXPFLD);
1293 0 : pFld = new SwGetExpField(pTyp, rData.sPar2, nsSwGetSetExpType::GSE_FORMULA, nFormatId);
1294 0 : pFld->SetSubType(nSubType);
1295 0 : bExp = true;
1296 : }
1297 0 : break;
1298 : }
1299 : case TYP_SETREFPAGEFLD:
1300 : pFld = new SwRefPageSetField( (SwRefPageSetFieldType*)
1301 0 : pCurShell->GetFldType( 0, RES_REFPAGESETFLD ),
1302 0 : (short)rData.sPar2.toInt32(), 0 != nSubType );
1303 0 : bPageVar = true;
1304 0 : break;
1305 :
1306 : case TYP_GETREFPAGEFLD:
1307 : pFld = new SwRefPageGetField( (SwRefPageGetFieldType*)
1308 0 : pCurShell->GetFldType( 0, RES_REFPAGEGETFLD ), nFormatId );
1309 0 : bPageVar = true;
1310 0 : break;
1311 : case TYP_DROPDOWN :
1312 : {
1313 0 : pFld = new SwDropDownField(pCurShell->GetFldType( 0, RES_DROPDOWN ));
1314 0 : const sal_Int32 nTokenCount = comphelper::string::getTokenCount(rData.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.sPar2.getToken(nToken, DB_DELIM);
1319 0 : ((SwDropDownField*)pFld)->SetItems(aEntries);
1320 0 : ((SwDropDownField*)pFld)->SetName(rData.sPar1);
1321 : }
1322 0 : break;
1323 : default:
1324 : { OSL_ENSURE(false, "wrong field type");
1325 0 : return false;
1326 : }
1327 : }
1328 : OSL_ENSURE(pFld, "field not available");
1329 :
1330 : //the auto language flag has to be set prior to the language!
1331 0 : pFld->SetAutomaticLanguage(rData.bIsAutomaticLanguage);
1332 0 : sal_uInt16 nLang = GetCurrLanguage();
1333 0 : pFld->SetLanguage(nLang);
1334 :
1335 : // insert
1336 0 : pCurShell->StartAllAction();
1337 :
1338 0 : pCurShell->Insert( *pFld );
1339 :
1340 0 : if(bExp && bEvalExp)
1341 0 : pCurShell->UpdateExpFlds(true);
1342 :
1343 0 : if(bTbl)
1344 : {
1345 0 : pCurShell->Left(CRSR_SKIP_CHARS, false, 1, false );
1346 0 : pCurShell->UpdateFlds(*pFld);
1347 0 : pCurShell->Right(CRSR_SKIP_CHARS, false, 1, false );
1348 : }
1349 0 : else if( bPageVar )
1350 0 : ((SwRefPageGetFieldType*)pCurShell->GetFldType( 0, RES_REFPAGEGETFLD ))->UpdateFlds();
1351 0 : else if( TYP_GETREFFLD == rData.nTypeId )
1352 0 : pFld->GetTyp()->ModifyNotification( 0, 0 );
1353 :
1354 : // delete temporary field
1355 0 : delete pFld;
1356 :
1357 0 : pCurShell->EndAllAction();
1358 0 : return true;
1359 : }
1360 :
1361 : // fields update
1362 0 : void SwFldMgr::UpdateCurFld(sal_uLong nFormat,
1363 : const OUString& rPar1,
1364 : const OUString& rPar2,
1365 : SwField * _pTmpFld) // #111840#
1366 : {
1367 : // change format
1368 : OSL_ENSURE(pCurFld, "no field at CursorPos");
1369 :
1370 0 : bool bDelete = false;
1371 : SwField *pTmpFld; // mb: fixed memory leak
1372 0 : if (NULL != _pTmpFld)
1373 : {
1374 0 : pTmpFld = _pTmpFld;
1375 : }
1376 : else
1377 : {
1378 0 : pTmpFld = pCurFld->CopyField();
1379 0 : bDelete = true;
1380 : }
1381 :
1382 0 : SwFieldType* pType = pTmpFld->GetTyp();
1383 0 : const sal_uInt16 nTypeId = pTmpFld->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 : ((SwChapterField*)pTmpFld)->SetLevel((sal_uInt8)nByte);
1419 0 : bSetPar2 = false;
1420 0 : break;
1421 : }
1422 :
1423 : case TYP_SCRIPTFLD:
1424 0 : ((SwScriptField*)pTmpFld)->SetCodeURL((bool)nFormat);
1425 0 : break;
1426 :
1427 : case TYP_NEXTPAGEFLD:
1428 0 : if( SVX_NUM_CHAR_SPECIAL == nFormat )
1429 : {
1430 0 : ((SwPageNumberField*)pCurFld)->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 : ((SwPageNumberField*)pCurFld)->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 : ((SwGetRefField*)pTmpFld)->SetSubType( (sal_uInt16)rPar2.toInt32() );
1469 0 : const sal_Int32 nPos = rPar2.indexOf( '|' );
1470 0 : if( nPos>=0 )
1471 0 : ((SwGetRefField*)pTmpFld)->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 : ((SwDropDownField*)pTmpFld)->SetItems(aEntries);
1482 0 : ((SwDropDownField*)pTmpFld)->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*>(pTmpFld);
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->UpdateFlds();
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 : pTmpFld->ChangeFormat(nFormat);
1512 :
1513 0 : if(bSetPar1)
1514 0 : pTmpFld->SetPar1( sPar1 );
1515 0 : if( bSetPar2 )
1516 0 : pTmpFld->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->UpdateFlds();
1524 0 : pSh->SetModified();
1525 : }
1526 : else {
1527 : // mb: #32157
1528 0 : pSh->SwEditShell::UpdateFlds(*pTmpFld);
1529 0 : GetCurFld();
1530 : }
1531 :
1532 0 : if (bDelete)
1533 0 : delete pTmpFld;
1534 :
1535 0 : pSh->EndAllAction();
1536 : }
1537 :
1538 : // explicitly evaluate ExpressionFields
1539 0 : void SwFldMgr::EvalExpFlds(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->UpdateExpFlds(true);
1548 0 : pSh->EndAllAction();
1549 : }
1550 0 : }
1551 0 : sal_uInt16 SwFldMgr::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 10 : void SwFieldType::_GetFldName()
1560 : {
1561 : static const sal_uInt16 coFldNms[] = {
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 10 : SwFieldType::pFldNames = new std::vector<OUString>;
1610 10 : SwFieldType::pFldNames->reserve(SAL_N_ELEMENTS(coFldNms));
1611 450 : for( sal_uInt16 nIdx = 0; nIdx < SAL_N_ELEMENTS(coFldNms); ++nIdx )
1612 : {
1613 440 : const OUString aTmp(SW_RES( coFldNms[ nIdx ] ));
1614 440 : SwFieldType::pFldNames->push_back(MnemonicGenerator::EraseAllMnemonicChars( aTmp ));
1615 440 : }
1616 10 : }
1617 :
1618 0 : bool SwFldMgr::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 SwFldMgr::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 SwFldMgr::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 nNumFmtTime = (sal_uLong)aTime.GetSec() + (sal_uLong)aTime.GetMin() * 60L +
1676 0 : (sal_uLong)aTime.GetHour() * 3600L;
1677 :
1678 0 : fValue += (double)nNumFmtTime / 86400.0;
1679 :
1680 0 : nDefFormat = (nTypeId == TYP_DATEFLD) ? NUMBERFORMAT_DATE : NUMBERFORMAT_TIME;
1681 : }
1682 0 : break;
1683 :
1684 : default:
1685 0 : if (bIsText)
1686 : {
1687 0 : fValue = 0.0;
1688 0 : nDefFormat = NUMBERFORMAT_TEXT;
1689 : }
1690 : else
1691 : {
1692 0 : fValue = 0.0;
1693 0 : nDefFormat = 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> SwFldMgr::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 : ((SwFldMgr*)this)->xNumberingInfo = Reference<XNumberingTypeInfo>(xDefNum, UNO_QUERY);
1711 : }
1712 0 : return xNumberingInfo;
1713 270 : }
1714 :
1715 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
