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