?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update ooo320-m1
[ooovba.git] / sw / source / core / unocore / unofield.cxx
blobf8dc8e5cced7a820c8c3702ddd2b4b5531d103e4
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: unofield.cxx,v $
10 * $Revision: 1.108 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_sw.hxx"
33
34
35 #include <swtypes.hxx>
36 #include <cmdid.h>
37 #include <doc.hxx>
38 #include <hints.hxx>
39 #include <fmtfld.hxx>
40 #include <txtfld.hxx>
41 #include <ndtxt.hxx>
42 #include <unomap.hxx>
43 #include <unoprnms.hxx>
44 #include <unoobj.hxx>
45 #include <unocoll.hxx>
46 #include <svx/linkmgr.hxx>
47 #include <docstat.hxx>
48 #include <editsh.hxx>
49 #include <viewsh.hxx>
50 #include <comphelper/types.hxx>
51 #include <comphelper/processfactory.hxx>
52 #include <com/sun/star/util/Time.hpp>
53 #include <com/sun/star/util/DateTimeRange.hpp>
54 #include <com/sun/star/util/DateTime.hpp>
55 #include <com/sun/star/util/Date.hpp>
56 #include <com/sun/star/beans/XFastPropertySet.hpp>
57 #include <com/sun/star/beans/XPropertyStateChangeListener.hpp>
58 #include <com/sun/star/beans/PropertyAttribute.hpp>
59 #include <com/sun/star/beans/XPropertyContainer.hpp>
60
61 //undef to prevent error (from sfx2/docfile.cxx)
62 #undef SEQUENCE
63 #include <com/sun/star/text/SetVariableType.hpp>
64 #include <com/sun/star/text/WrapTextMode.hpp>
65 #include <com/sun/star/text/TextContentAnchorType.hpp>
66 #include <com/sun/star/text/PageNumberType.hpp>
67 #include <unofield.hxx>
68 #include <unocrsr.hxx>
69 #include <authfld.hxx>
70 #include <flddat.hxx>
71 #include <dbfld.hxx>
72 #include <usrfld.hxx>
73 #include <docufld.hxx>
74 #include <expfld.hxx>
75 #include <chpfld.hxx>
76 #include <flddropdown.hxx>
77 #include <poolfmt.hxx>
78 #include <poolfmt.hrc>
79 #include <pagedesc.hxx>
80 #include <docary.hxx>
81 #include <reffld.hxx>
82 #include <ddefld.hxx>
83 #include <SwStyleNameMapper.hxx>
84 #include <swunohelper.hxx>
85 #include <unofldmid.h>
86 #include <scriptinfo.hxx>
87 #include <tools/datetime.hxx>
88 #include <tools/urlobj.hxx>
89 #include <svx/dataaccessdescriptor.hxx>
90 #define _SVSTDARR_STRINGS
91 #include <svtools/svstdarr.hxx>
92 #include <vos/mutex.hxx>
93 #include <vcl/svapp.hxx>
94 #include <textapi.hxx>
95 #include <svx/outliner.hxx>
96 #include <docsh.hxx>
97 #include <fmtmeta.hxx> // MetaFieldManager
98
99 using ::rtl::OUString;
100 using namespace ::com::sun::star;
101 using namespace nsSwDocInfoSubType;
102
103 #define COM_TEXT_FLDMASTER "com.sun.star.text.FieldMaster."
104
105 // case-corrected version of the first part for the service names (see #i67811)
106 #define COM_TEXT_FLDMASTER_CC "com.sun.star.text.fieldmaster."
107
108 // note: this thing is indexed as an array, so do not insert/remove entries!
109 static const sal_uInt16 aDocInfoSubTypeFromService[] =
110 {
111 DI_CHANGE | DI_SUB_AUTHOR, //PROPERTY_MAP_FLDTYP_DOCINFO_CHANGE_AUTHOR
112 DI_CHANGE | DI_SUB_DATE, //PROPERTY_MAP_FLDTYP_DOCINFO_CHANGE_DATE_TIME
113 DI_EDIT | DI_SUB_TIME, //PROPERTY_MAP_FLDTYP_DOCINFO_EDIT_TIME
114 DI_COMMENT, //PROPERTY_MAP_FLDTYP_DOCINFO_DESCRIPTION
115 DI_CREATE | DI_SUB_AUTHOR, //PROPERTY_MAP_FLDTYP_DOCINFO_CREATE_AUTHOR
116 DI_CREATE | DI_SUB_DATE, //PROPERTY_MAP_FLDTYP_DOCINFO_CREATE_DATE_TIME
117 0, //DUMMY
118 0, //DUMMY
119 0, //DUMMY
120 0, //DUMMY
121 DI_CUSTOM, //PROPERTY_MAP_FLDTYP_DOCINFO_CUSTOM
122 DI_PRINT | DI_SUB_AUTHOR, //PROPERTY_MAP_FLDTYP_DOCINFO_PRINT_AUTHOR
123 DI_PRINT | DI_SUB_DATE, //PROPERTY_MAP_FLDTYP_DOCINFO_PRINT_DATE_TIME
124 DI_KEYS, //PROPERTY_MAP_FLDTYP_DOCINFO_KEY_WORDS
125 DI_THEMA, //PROPERTY_MAP_FLDTYP_DOCINFO_SUBJECT
126 DI_TITEL, //PROPERTY_MAP_FLDTYP_DOCINFO_TITLE
127 DI_DOCNO //PROPERTY_MAP_FLDTYP_DOCINFO_REVISION
128 };
129 struct ServiceIdResId
130 {
131 USHORT nResId;
132 USHORT nServiceId;
133 };
134 static const ServiceIdResId aServiceToRes[] =
135 {
136 {RES_DATETIMEFLD, SW_SERVICE_FIELDTYPE_DATETIME },
137 {RES_USERFLD, SW_SERVICE_FIELDTYPE_USER },
138 {RES_SETEXPFLD, SW_SERVICE_FIELDTYPE_SET_EXP } ,
139 {RES_GETEXPFLD, SW_SERVICE_FIELDTYPE_GET_EXP } ,
140 {RES_FILENAMEFLD, SW_SERVICE_FIELDTYPE_FILE_NAME },
141 {RES_PAGENUMBERFLD, SW_SERVICE_FIELDTYPE_PAGE_NUM } ,
142 {RES_AUTHORFLD, SW_SERVICE_FIELDTYPE_AUTHOR } ,
143 {RES_CHAPTERFLD, SW_SERVICE_FIELDTYPE_CHAPTER },
144 {RES_GETREFFLD, SW_SERVICE_FIELDTYPE_GET_REFERENCE } ,
145 {RES_HIDDENTXTFLD, SW_SERVICE_FIELDTYPE_CONDITIONED_TEXT },
146 {RES_POSTITFLD, SW_SERVICE_FIELDTYPE_ANNOTATION } ,
147 {RES_INPUTFLD, SW_SERVICE_FIELDTYPE_INPUT },
148 {RES_MACROFLD, SW_SERVICE_FIELDTYPE_MACRO },
149 {RES_DDEFLD, SW_SERVICE_FIELDTYPE_DDE },
150 {RES_HIDDENPARAFLD, SW_SERVICE_FIELDTYPE_HIDDEN_PARA } ,
151 {RES_DOCINFOFLD, SW_SERVICE_FIELDTYPE_DOC_INFO },
152 {RES_TEMPLNAMEFLD, SW_SERVICE_FIELDTYPE_TEMPLATE_NAME },
153 {RES_EXTUSERFLD, SW_SERVICE_FIELDTYPE_USER_EXT },
154 {RES_REFPAGESETFLD, SW_SERVICE_FIELDTYPE_REF_PAGE_SET } ,
155 {RES_REFPAGEGETFLD, SW_SERVICE_FIELDTYPE_REF_PAGE_GET } ,
156 {RES_JUMPEDITFLD, SW_SERVICE_FIELDTYPE_JUMP_EDIT },
157 {RES_SCRIPTFLD, SW_SERVICE_FIELDTYPE_SCRIPT } ,
158 {RES_DBNEXTSETFLD, SW_SERVICE_FIELDTYPE_DATABASE_NEXT_SET },
159 {RES_DBNUMSETFLD, SW_SERVICE_FIELDTYPE_DATABASE_NUM_SET },
160 {RES_DBSETNUMBERFLD, SW_SERVICE_FIELDTYPE_DATABASE_SET_NUM } ,
161 {RES_DBFLD, SW_SERVICE_FIELDTYPE_DATABASE } ,
162 {RES_DBNAMEFLD, SW_SERVICE_FIELDTYPE_DATABASE_NAME },
163 {RES_DOCSTATFLD, SW_SERVICE_FIELDTYPE_PAGE_COUNT },
164 {RES_DOCSTATFLD, SW_SERVICE_FIELDTYPE_PARAGRAPH_COUNT },
165 {RES_DOCSTATFLD, SW_SERVICE_FIELDTYPE_WORD_COUNT },
166 {RES_DOCSTATFLD, SW_SERVICE_FIELDTYPE_CHARACTER_COUNT },
167 {RES_DOCSTATFLD, SW_SERVICE_FIELDTYPE_TABLE_COUNT },
168 {RES_DOCSTATFLD, SW_SERVICE_FIELDTYPE_GRAPHIC_OBJECT_COUNT },
169 {RES_DOCSTATFLD, SW_SERVICE_FIELDTYPE_EMBEDDED_OBJECT_COUNT },
170 {RES_DOCINFOFLD, SW_SERVICE_FIELDTYPE_DOCINFO_CHANGE_AUTHOR },
171 {RES_DOCINFOFLD, SW_SERVICE_FIELDTYPE_DOCINFO_CHANGE_DATE_TIME},
172 {RES_DOCINFOFLD, SW_SERVICE_FIELDTYPE_DOCINFO_EDIT_TIME },
173 {RES_DOCINFOFLD, SW_SERVICE_FIELDTYPE_DOCINFO_DESCRIPTION },
174 {RES_DOCINFOFLD, SW_SERVICE_FIELDTYPE_DOCINFO_CREATE_AUTHOR },
175 {RES_DOCINFOFLD, SW_SERVICE_FIELDTYPE_DOCINFO_CREATE_DATE_TIME},
176 {RES_DOCINFOFLD, SW_SERVICE_FIELDTYPE_DOCINFO_CUSTOM },
177 {RES_DOCINFOFLD, SW_SERVICE_FIELDTYPE_DOCINFO_PRINT_AUTHOR },
178 {RES_DOCINFOFLD, SW_SERVICE_FIELDTYPE_DOCINFO_PRINT_DATE_TIME },
179 {RES_DOCINFOFLD, SW_SERVICE_FIELDTYPE_DOCINFO_KEY_WORDS },
180 {RES_DOCINFOFLD, SW_SERVICE_FIELDTYPE_DOCINFO_SUBJECT },
181 {RES_DOCINFOFLD, SW_SERVICE_FIELDTYPE_DOCINFO_TITLE },
182 {RES_INPUTFLD, SW_SERVICE_FIELDTYPE_INPUT_USER },
183 {RES_HIDDENTXTFLD, SW_SERVICE_FIELDTYPE_HIDDEN_TEXT },
184 {RES_AUTHORITY, SW_SERVICE_FIELDTYPE_BIBLIOGRAPHY },
185 {RES_COMBINED_CHARS, SW_SERVICE_FIELDTYPE_COMBINED_CHARACTERS },
186 {RES_DROPDOWN, SW_SERVICE_FIELDTYPE_DROPDOWN },
187 {RES_TABLEFLD, SW_SERVICE_FIELDTYPE_TABLE_FORMULA },
188 {USHRT_MAX, USHRT_MAX }
189 };
190 //-----------------------------------------------------------------
191 sal_uInt16 lcl_ServiceIdToResId(sal_uInt16 nServiceId)
192 {
193 const ServiceIdResId* pMap = aServiceToRes;
194 while( USHRT_MAX != pMap->nServiceId && nServiceId != pMap->nServiceId )
195 ++pMap;
196 #ifdef DBG_UTIL
197 if( USHRT_MAX == pMap->nServiceId )
198 DBG_ERROR("service id not found");
199 #endif
200 return pMap->nResId;
201 }
202 //-----------------------------------------------------------------
203 sal_uInt16 lcl_GetServiceForField( const SwField& rFld )
204 {
205 sal_uInt16 nWhich = rFld.Which(), nSrvId = USHRT_MAX;
206 //special handling for some fields
207 switch( nWhich )
208 {
209 case RES_INPUTFLD:
210 if( INP_USR == (rFld.GetSubType() & 0x00ff) )
211 nSrvId = SW_SERVICE_FIELDTYPE_INPUT_USER;
212 break;
213
214 case RES_DOCINFOFLD:
215 {
216 USHORT nSubType = rFld.GetSubType();
217 switch( (nSubType & 0xff))
218 {
219 case DI_CHANGE:
220 nSrvId = ((nSubType&0x300) == DI_SUB_AUTHOR)
221 ? SW_SERVICE_FIELDTYPE_DOCINFO_CHANGE_AUTHOR
222 : SW_SERVICE_FIELDTYPE_DOCINFO_CHANGE_DATE_TIME;
223 break;
224 case DI_CREATE:
225 nSrvId = ((nSubType&0x300) == DI_SUB_AUTHOR)
226 ? SW_SERVICE_FIELDTYPE_DOCINFO_CREATE_AUTHOR
227 : SW_SERVICE_FIELDTYPE_DOCINFO_CREATE_DATE_TIME;
228 break;
229 case DI_PRINT:
230 nSrvId = ((nSubType&0x300) == DI_SUB_AUTHOR)
231 ? SW_SERVICE_FIELDTYPE_DOCINFO_PRINT_AUTHOR
232 : SW_SERVICE_FIELDTYPE_DOCINFO_PRINT_DATE_TIME;
233 break;
234 case DI_EDIT: nSrvId = SW_SERVICE_FIELDTYPE_DOCINFO_EDIT_TIME;break;
235 case DI_COMMENT:nSrvId = SW_SERVICE_FIELDTYPE_DOCINFO_DESCRIPTION;break;
236 case DI_KEYS: nSrvId = SW_SERVICE_FIELDTYPE_DOCINFO_KEY_WORDS;break;
237 case DI_THEMA: nSrvId = SW_SERVICE_FIELDTYPE_DOCINFO_SUBJECT; break;
238 case DI_TITEL: nSrvId = SW_SERVICE_FIELDTYPE_DOCINFO_TITLE; break;
239 case DI_DOCNO: nSrvId = SW_SERVICE_FIELDTYPE_DOCINFO_REVISION; break;
240 case DI_CUSTOM: nSrvId = SW_SERVICE_FIELDTYPE_DOCINFO_CUSTOM; break;
241 }
242 }
243 break;
244
245 case RES_HIDDENTXTFLD:
246 nSrvId = TYP_CONDTXTFLD == rFld.GetSubType()
247 ? SW_SERVICE_FIELDTYPE_CONDITIONED_TEXT
248 : SW_SERVICE_FIELDTYPE_HIDDEN_TEXT;
249 break;
250
251 case RES_DOCSTATFLD:
252 {
253 switch( rFld.GetSubType() )
254 {
255 case DS_PAGE: nSrvId = SW_SERVICE_FIELDTYPE_PAGE_COUNT; break;
256 case DS_PARA: nSrvId = SW_SERVICE_FIELDTYPE_PARAGRAPH_COUNT; break;
257 case DS_WORD: nSrvId = SW_SERVICE_FIELDTYPE_WORD_COUNT ; break;
258 case DS_CHAR: nSrvId = SW_SERVICE_FIELDTYPE_CHARACTER_COUNT; break;
259 case DS_TBL: nSrvId = SW_SERVICE_FIELDTYPE_TABLE_COUNT ; break;
260 case DS_GRF: nSrvId = SW_SERVICE_FIELDTYPE_GRAPHIC_OBJECT_COUNT; break;
261 case DS_OLE: nSrvId = SW_SERVICE_FIELDTYPE_EMBEDDED_OBJECT_COUNT; break;
262 }
263 }
264 break;
265 }
266 if( USHRT_MAX == nSrvId )
267 {
268 for( const ServiceIdResId* pMap = aServiceToRes;
269 USHRT_MAX != pMap->nResId; ++pMap )
270 if( nWhich == pMap->nResId )
271 {
272 nSrvId = pMap->nServiceId;
273 break;
274 }
275 }
276 #ifdef DBG_UTIL
277 if( USHRT_MAX == nSrvId )
278 DBG_ERROR("resid not found");
279 #endif
280 return nSrvId;
281 }
282
283 sal_uInt16 lcl_GetPropMapIdForFieldType( USHORT nWhich )
284 {
285 sal_uInt16 nId;
286 switch( nWhich )
287 {
288 case RES_USERFLD: nId = PROPERTY_MAP_FLDMSTR_USER; break;
289 case RES_DBFLD: nId = PROPERTY_MAP_FLDMSTR_DATABASE; break;
290 case RES_SETEXPFLD: nId = PROPERTY_MAP_FLDMSTR_SET_EXP; break;
291 case RES_DDEFLD: nId = PROPERTY_MAP_FLDMSTR_DDE; break;
292 case RES_AUTHORITY: nId = PROPERTY_MAP_FLDMSTR_BIBLIOGRAPHY; break;
293 default: nId = PROPERTY_MAP_FLDMSTR_DUMMY0;
294 }
295 return nId;
296 }
297
298
299 USHORT GetFieldTypeMId( const OUString& rProperty, const SwFieldType& rTyp )
300 {
301 USHORT nId = lcl_GetPropMapIdForFieldType( rTyp.Which() );
302 const SfxItemPropertySet* pSet = aSwMapProvider.GetPropertySet( nId );
303 if( !pSet )
304 nId = USHRT_MAX;
305 else
306 {
307 const SfxItemPropertySimpleEntry* pEntry = pSet->getPropertyMap()->getByName(rProperty);
308 nId = pEntry ? pEntry->nWID : USHRT_MAX;
309 }
310 return nId;
311 }
312
313 USHORT lcl_GetPropertyMapOfService( USHORT nServiceId )
314 {
315 USHORT nRet;
316 switch ( nServiceId)
317 {
318 case SW_SERVICE_FIELDTYPE_DATETIME: nRet = PROPERTY_MAP_FLDTYP_DATETIME; break;
319 case SW_SERVICE_FIELDTYPE_USER: nRet = PROPERTY_MAP_FLDTYP_USER; break;
320 case SW_SERVICE_FIELDTYPE_SET_EXP: nRet = PROPERTY_MAP_FLDTYP_SET_EXP; break;
321 case SW_SERVICE_FIELDTYPE_GET_EXP: nRet = PROPERTY_MAP_FLDTYP_GET_EXP; break;
322 case SW_SERVICE_FIELDTYPE_FILE_NAME: nRet = PROPERTY_MAP_FLDTYP_FILE_NAME; break;
323 case SW_SERVICE_FIELDTYPE_PAGE_NUM: nRet = PROPERTY_MAP_FLDTYP_PAGE_NUM; break;
324 case SW_SERVICE_FIELDTYPE_AUTHOR: nRet = PROPERTY_MAP_FLDTYP_AUTHOR; break;
325 case SW_SERVICE_FIELDTYPE_CHAPTER: nRet = PROPERTY_MAP_FLDTYP_CHAPTER; break;
326 case SW_SERVICE_FIELDTYPE_GET_REFERENCE: nRet = PROPERTY_MAP_FLDTYP_GET_REFERENCE; break;
327 case SW_SERVICE_FIELDTYPE_CONDITIONED_TEXT: nRet = PROPERTY_MAP_FLDTYP_CONDITIONED_TEXT; break;
328 case SW_SERVICE_FIELDTYPE_ANNOTATION: nRet = PROPERTY_MAP_FLDTYP_ANNOTATION; break;
329 case SW_SERVICE_FIELDTYPE_INPUT_USER:
330 case SW_SERVICE_FIELDTYPE_INPUT: nRet = PROPERTY_MAP_FLDTYP_INPUT; break;
331 case SW_SERVICE_FIELDTYPE_MACRO: nRet = PROPERTY_MAP_FLDTYP_MACRO; break;
332 case SW_SERVICE_FIELDTYPE_DDE: nRet = PROPERTY_MAP_FLDTYP_DDE; break;
333 case SW_SERVICE_FIELDTYPE_HIDDEN_PARA: nRet = PROPERTY_MAP_FLDTYP_HIDDEN_PARA; break;
334 case SW_SERVICE_FIELDTYPE_DOC_INFO: nRet = PROPERTY_MAP_FLDTYP_DOC_INFO; break;
335 case SW_SERVICE_FIELDTYPE_TEMPLATE_NAME: nRet = PROPERTY_MAP_FLDTYP_TEMPLATE_NAME; break;
336 case SW_SERVICE_FIELDTYPE_USER_EXT: nRet = PROPERTY_MAP_FLDTYP_USER_EXT; break;
337 case SW_SERVICE_FIELDTYPE_REF_PAGE_SET: nRet = PROPERTY_MAP_FLDTYP_REF_PAGE_SET; break;
338 case SW_SERVICE_FIELDTYPE_REF_PAGE_GET: nRet = PROPERTY_MAP_FLDTYP_REF_PAGE_GET; break;
339 case SW_SERVICE_FIELDTYPE_JUMP_EDIT: nRet = PROPERTY_MAP_FLDTYP_JUMP_EDIT; break;
340 case SW_SERVICE_FIELDTYPE_SCRIPT: nRet = PROPERTY_MAP_FLDTYP_SCRIPT; break;
341 case SW_SERVICE_FIELDTYPE_DATABASE_NEXT_SET: nRet = PROPERTY_MAP_FLDTYP_DATABASE_NEXT_SET; break;
342 case SW_SERVICE_FIELDTYPE_DATABASE_NUM_SET: nRet = PROPERTY_MAP_FLDTYP_DATABASE_NUM_SET; break;
343 case SW_SERVICE_FIELDTYPE_DATABASE_SET_NUM: nRet = PROPERTY_MAP_FLDTYP_DATABASE_SET_NUM; break;
344 case SW_SERVICE_FIELDTYPE_DATABASE: nRet = PROPERTY_MAP_FLDTYP_DATABASE; break;
345 case SW_SERVICE_FIELDTYPE_DATABASE_NAME: nRet = PROPERTY_MAP_FLDTYP_DATABASE_NAME; break;
346 case SW_SERVICE_FIELDTYPE_TABLE_FORMULA: nRet = PROPERTY_MAP_FLDTYP_TABLE_FORMULA; break;
347 case SW_SERVICE_FIELDTYPE_PAGE_COUNT:
348 case SW_SERVICE_FIELDTYPE_PARAGRAPH_COUNT:
349 case SW_SERVICE_FIELDTYPE_WORD_COUNT:
350 case SW_SERVICE_FIELDTYPE_CHARACTER_COUNT:
351 case SW_SERVICE_FIELDTYPE_TABLE_COUNT:
352 case SW_SERVICE_FIELDTYPE_GRAPHIC_OBJECT_COUNT:
353 case SW_SERVICE_FIELDTYPE_EMBEDDED_OBJECT_COUNT: nRet = PROPERTY_MAP_FLDTYP_DOCSTAT; break;
354 case SW_SERVICE_FIELDTYPE_DOCINFO_CHANGE_AUTHOR:
355 case SW_SERVICE_FIELDTYPE_DOCINFO_CREATE_AUTHOR:
356 case SW_SERVICE_FIELDTYPE_DOCINFO_PRINT_AUTHOR: nRet = PROPERTY_MAP_FLDTYP_DOCINFO_AUTHOR; break;
357 case SW_SERVICE_FIELDTYPE_DOCINFO_CHANGE_DATE_TIME:
358 case SW_SERVICE_FIELDTYPE_DOCINFO_CREATE_DATE_TIME:
359 case SW_SERVICE_FIELDTYPE_DOCINFO_PRINT_DATE_TIME: nRet = PROPERTY_MAP_FLDTYP_DOCINFO_DATE_TIME; break;
360 case SW_SERVICE_FIELDTYPE_DOCINFO_EDIT_TIME: nRet = PROPERTY_MAP_FLDTYP_DOCINFO_EDIT_TIME; break;
361 case SW_SERVICE_FIELDTYPE_DOCINFO_CUSTOM: nRet = PROPERTY_MAP_FLDTYP_DOCINFO_CUSTOM; break;
362 case SW_SERVICE_FIELDTYPE_DOCINFO_DESCRIPTION:
363 case SW_SERVICE_FIELDTYPE_DOCINFO_KEY_WORDS:
364 case SW_SERVICE_FIELDTYPE_DOCINFO_SUBJECT:
365 case SW_SERVICE_FIELDTYPE_DOCINFO_TITLE: nRet = PROPERTY_MAP_FLDTYP_DOCINFO_MISC; break;
366 case SW_SERVICE_FIELDTYPE_DOCINFO_REVISION: nRet = PROPERTY_MAP_FLDTYP_DOCINFO_REVISION; break;
367 case SW_SERVICE_FIELDTYPE_BIBLIOGRAPHY: nRet = PROPERTY_MAP_FLDTYP_BIBLIOGRAPHY; break;
368 case SW_SERVICE_FIELDTYPE_DUMMY_0:
369 case SW_SERVICE_FIELDTYPE_COMBINED_CHARACTERS: nRet = PROPERTY_MAP_FLDTYP_COMBINED_CHARACTERS; break;
370 case SW_SERVICE_FIELDTYPE_DROPDOWN: nRet = PROPERTY_MAP_FLDTYP_DROPDOWN; break;
371 case SW_SERVICE_FIELDTYPE_DUMMY_4:
372 case SW_SERVICE_FIELDTYPE_DUMMY_5:
373 case SW_SERVICE_FIELDTYPE_DUMMY_6:
374 case SW_SERVICE_FIELDTYPE_DUMMY_7:
375 nRet = PROPERTY_MAP_FLDTYP_DUMMY_0; break;
376 case SW_SERVICE_FIELDMASTER_USER: nRet = PROPERTY_MAP_FLDMSTR_USER; break;
377 case SW_SERVICE_FIELDMASTER_DDE: nRet = PROPERTY_MAP_FLDMSTR_DDE; break;
378 case SW_SERVICE_FIELDMASTER_SET_EXP: nRet = PROPERTY_MAP_FLDMSTR_SET_EXP; break;
379 case SW_SERVICE_FIELDMASTER_DATABASE: nRet = PROPERTY_MAP_FLDMSTR_DATABASE; break;
380 case SW_SERVICE_FIELDMASTER_BIBLIOGRAPHY: nRet = PROPERTY_MAP_FLDMSTR_BIBLIOGRAPHY; break;
381 case SW_SERVICE_FIELDMASTER_DUMMY2:
382 case SW_SERVICE_FIELDMASTER_DUMMY3:
383 case SW_SERVICE_FIELDMASTER_DUMMY4:
384 case SW_SERVICE_FIELDMASTER_DUMMY5: nRet = PROPERTY_MAP_FLDMSTR_DUMMY0; break;
385 case SW_SERVICE_FIELDTYPE_HIDDEN_TEXT: nRet = PROPERTY_MAP_FLDTYP_HIDDEN_TEXT; break;
386 default:
387 DBG_ERROR( "wrong service id" );
388 nRet = USHRT_MAX;
389 }
390 return nRet;
391 }
392
393 /******************************************************************
394 * SwXFieldMaster
395 ******************************************************************/
396 TYPEINIT1(SwXFieldMaster, SwClient);
397 /* -----------------------------13.03.00 12:15--------------------------------
398
399 ---------------------------------------------------------------------------*/
400 const uno::Sequence< sal_Int8 > & SwXFieldMaster::getUnoTunnelId()
401 {
402 static uno::Sequence< sal_Int8 > aSeq = ::CreateUnoTunnelId();
403 return aSeq;
404 }
405 /* -----------------------------10.03.00 18:04--------------------------------
406
407 ---------------------------------------------------------------------------*/
408 sal_Int64 SAL_CALL SwXFieldMaster::getSomething( const uno::Sequence< sal_Int8 >& rId )
409 throw(uno::RuntimeException)
410 {
411 if( rId.getLength() == 16
412 && 0 == rtl_compareMemory( getUnoTunnelId().getConstArray(),
413 rId.getConstArray(), 16 ) )
414 {
415 return sal::static_int_cast< sal_Int64 >( reinterpret_cast< sal_IntPtr >(this) );
416 }
417 return 0;
418 }
419 /* -----------------------------06.04.00 13:22--------------------------------
420
421 ---------------------------------------------------------------------------*/
422 OUString SwXFieldMaster::getImplementationName(void) throw( uno::RuntimeException )
423 {
424 return C2U("SwXFieldMaster");
425 }
426 /* -----------------------------06.04.00 13:22--------------------------------
427
428 ---------------------------------------------------------------------------*/
429 BOOL SwXFieldMaster::supportsService(const OUString& rServiceName) throw( uno::RuntimeException )
430 {
431 sal_Bool bRet = sal_False;
432 if(rServiceName.equalsAsciiL(
433 RTL_CONSTASCII_STRINGPARAM("com.sun.star.text.TextFieldMaster")))
434 bRet = sal_True;
435 else
436 {
437 const sal_Char* pEntry;
438 switch( nResTypeId )
439 {
440 case RES_USERFLD: pEntry = "User"; break;
441 case RES_DBFLD: pEntry = "Database"; break;
442 case RES_SETEXPFLD: pEntry = "SetExpression"; break;
443 case RES_DDEFLD: pEntry = "DDE"; break;
444 case RES_AUTHORITY: pEntry = "Bibliography"; break;
445 default: pEntry = 0;
446 }
447 if( pEntry )
448 {
449 ByteString aTmp( RTL_CONSTASCII_STRINGPARAM(
450 "com.sun.star.text.fieldmaster."));
451 aTmp.Append( pEntry );
452 bRet = rServiceName.equalsAsciiL(aTmp.GetBuffer(), aTmp.Len());
453 }
454 }
455 return bRet;
456 }
457 /* -----------------------------06.04.00 13:22--------------------------------
458
459 ---------------------------------------------------------------------------*/
460 uno::Sequence< OUString > SwXFieldMaster::getSupportedServiceNames(void) throw( uno::RuntimeException )
461 {
462 uno::Sequence< OUString > aRet(2);
463 OUString* pArray = aRet.getArray();
464 pArray[0] = C2U("com.sun.star.text.TextFieldMaster");
465
466 const sal_Char* pEntry1;
467 switch( nResTypeId )
468 {
469 case RES_USERFLD: pEntry1 = "User"; break;
470 case RES_DBFLD: pEntry1 = "Database"; break;
471 case RES_SETEXPFLD: pEntry1 = "SetExpression"; break;
472 case RES_DDEFLD: pEntry1 = "DDE"; break;
473 case RES_AUTHORITY: pEntry1 = "Bibliography"; break;
474 default: pEntry1 = 0;
475 }
476 if( pEntry1 )
477 {
478 String s;
479 s.AppendAscii( "com.sun.star.text.fieldmaster." ).AppendAscii( pEntry1 );
480 pArray[1] = s;
481 }
482 return aRet;
483 }
484 /*-- 14.12.98 11:08:33---------------------------------------------------
485
486 -----------------------------------------------------------------------*/
487 SwXFieldMaster::SwXFieldMaster(SwDoc* pDoc, sal_uInt16 nResId) :
488 aLstnrCntnr( (XPropertySet*)this),
489 nResTypeId(nResId),
490 m_pDoc(pDoc),
491 m_bIsDescriptor(sal_True),
492 fParam1(0.),
493 nParam1(-1),
494 bParam1(FALSE),
495 nParam2(0)
496 {
497 pDoc->GetPageDescFromPool(RES_POOLPAGE_STANDARD)->Add(this);
498 }
499 /*-- 14.12.98 11:08:33---------------------------------------------------
500
501 -----------------------------------------------------------------------*/
502 SwXFieldMaster::SwXFieldMaster(SwFieldType& rType, SwDoc* pDoc) :
503 SwClient(&rType),
504 aLstnrCntnr( (XPropertySet*)this),
505 nResTypeId(rType.Which()),
506 m_pDoc(pDoc),
507 m_bIsDescriptor(sal_False),
508 fParam1(0.),
509 nParam1(-1),
510 bParam1(FALSE)
511 {
512
513 }
514 /*-- 14.12.98 11:08:34---------------------------------------------------
515
516 -----------------------------------------------------------------------*/
517 SwXFieldMaster::~SwXFieldMaster()
518 {
519
520 }
521 /*-- 14.12.98 11:08:35---------------------------------------------------
522
523 -----------------------------------------------------------------------*/
524 uno::Reference< beans::XPropertySetInfo > SwXFieldMaster::getPropertySetInfo(void)
525 throw( uno::RuntimeException )
526 {
527 vos::OGuard aGuard(Application::GetSolarMutex());
528 uno::Reference< beans::XPropertySetInfo > aRef =
529 aSwMapProvider.GetPropertySet(
530 lcl_GetPropMapIdForFieldType( nResTypeId ) )->getPropertySetInfo();
531 return aRef;
532 }
533 /*-- 14.12.98 11:08:35---------------------------------------------------
534
535 -----------------------------------------------------------------------*/
536 void SwXFieldMaster::setPropertyValue( const OUString& rPropertyName,
537 const uno::Any& rValue)
538 throw( beans::UnknownPropertyException, beans::PropertyVetoException,
539 lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException)
540 {
541 vos::OGuard aGuard(Application::GetSolarMutex());
542 SwFieldType* pType = GetFldType(sal_True);
543 if(pType)
544 {
545 sal_Bool bSetValue = sal_True;
546 if( rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_SUB_TYPE)))
547 {
548 const SvStringsDtor& rExtraArr = SwStyleNameMapper::GetExtraUINameArray();
549 String sTypeName = pType->GetName();
550 static sal_uInt16 nIds[] =
551 {
552 RES_POOLCOLL_LABEL_DRAWING - RES_POOLCOLL_EXTRA_BEGIN,
553 RES_POOLCOLL_LABEL_ABB - RES_POOLCOLL_EXTRA_BEGIN,
554 RES_POOLCOLL_LABEL_TABLE - RES_POOLCOLL_EXTRA_BEGIN,
555 RES_POOLCOLL_LABEL_FRAME- RES_POOLCOLL_EXTRA_BEGIN,
556 0
557 };
558 for(const sal_uInt16 * pIds = nIds; *pIds; ++pIds)
559 {
560 if(sTypeName == *rExtraArr[ *pIds ] )
561 {
562 bSetValue = sal_False;
563 break;
564 }
565 }
566 }
567 if( bSetValue )
568 {
569 // nothing special to be done here for the properties
570 // UNO_NAME_DATA_BASE_NAME and UNO_NAME_DATA_BASE_URL.
571 // We just call PutValue (empty string is allowed).
572 // Thus the last property set will be used as Data Source.
573
574 USHORT nMId = GetFieldTypeMId( rPropertyName, *pType );
575 if( USHRT_MAX != nMId )
576 pType->PutValue( rValue, nMId );
577 else
578 throw beans::UnknownPropertyException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) );
579 }
580 }
581 else if(!pType && m_pDoc &&
582 ( rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_NAME))) )
583 {
584 OUString uTmp;
585 rValue >>= uTmp;
586 String sTypeName(uTmp);
587 SwFieldType* pType2 = m_pDoc->GetFldType(nResTypeId, sTypeName, sal_False);
588
589 String sTable(SW_RES(STR_POOLCOLL_LABEL_TABLE));
590 String sDrawing(SW_RES(STR_POOLCOLL_LABEL_DRAWING));
591 String sFrame(SW_RES(STR_POOLCOLL_LABEL_FRAME));
592 String sIllustration(SW_RES(STR_POOLCOLL_LABEL_ABB));
593
594 if(pType2 ||
595 (RES_SETEXPFLD == nResTypeId &&
596 ( sTypeName == sTable || sTypeName == sDrawing ||
597 sTypeName == sFrame || sTypeName == sIllustration )))
598 {
599 throw lang::IllegalArgumentException();
600 }
601 else
602 {
603 switch(nResTypeId)
604 {
605 case RES_USERFLD :
606 {
607 SwUserFieldType aType(m_pDoc, sTypeName);
608 pType2 = m_pDoc->InsertFldType(aType);
609 ((SwUserFieldType*)pType2)->SetContent(sParam1);
610 ((SwUserFieldType*)pType2)->SetValue(fParam1);
611 ((SwUserFieldType*)pType2)->SetType(bParam1 ? nsSwGetSetExpType::GSE_EXPR : nsSwGetSetExpType::GSE_STRING);
612 }
613 break;
614 case RES_DDEFLD :
615 {
616 SwDDEFieldType aType(sTypeName, sParam1,
617 sal::static_int_cast< USHORT >(bParam1 ? sfx2::LINKUPDATE_ALWAYS : sfx2::LINKUPDATE_ONCALL));
618 pType2 = m_pDoc->InsertFldType(aType);
619 }
620 break;
621 case RES_SETEXPFLD :
622 {
623 SwSetExpFieldType aType(m_pDoc, sTypeName);
624 if(sParam1.Len())
625 aType.SetDelimiter( sParam1.GetChar(0));
626 if(nParam1 > -1 && nParam1 < MAXLEVEL)
627 aType.SetOutlineLvl(nParam1);
628 pType2 = m_pDoc->InsertFldType(aType);
629 }
630 break;
631 case RES_DBFLD :
632 {
633 ::GetString( rValue, sParam3 );
634 pType = GetFldType();
635 }
636 break;
637 }
638 if(pType2)
639 {
640 pType2->Add(this);
641 m_bIsDescriptor = sal_False;
642 }
643 else
644 throw uno::RuntimeException();
645 }
646
647 DBG_ASSERT(pType2, "kein FieldType gefunden!" );
648 }
649 else
650 {
651 switch( nResTypeId )
652 {
653 case RES_USERFLD:
654 if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_CONTENT)))
655 ::GetString( rValue, sParam1 );
656 else if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_VALUE )))
657 {
658 if(rValue.getValueType() != ::getCppuType(static_cast<const double*>(0)))
659 throw lang::IllegalArgumentException();
660 fParam1 = *(double*)rValue.getValue();
661 }
662 else if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_IS_EXPRESSION )))
663 {
664 if(rValue.getValueType() != ::getBooleanCppuType())
665 throw lang::IllegalArgumentException();
666 bParam1 = *(sal_Bool*)rValue.getValue();
667 }
668
669 break;
670 case RES_DBFLD:
671 if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_DATA_BASE_NAME)))
672 ::GetString( rValue, sParam1 );
673 else if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_DATA_TABLE_NAME)))
674 ::GetString( rValue, sParam2 );
675 else if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_DATA_COLUMN_NAME)))
676 ::GetString( rValue, sParam3 );
677 else if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_DATA_COMMAND_TYPE)))
678 rValue >>= nParam2;
679 if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_DATA_BASE_URL)))
680 ::GetString( rValue, sParam5 );
681
682 if((sParam1.Len() || sParam5.Len())
683 && sParam2.Len() && sParam3.Len())
684 GetFldType();
685 break;
686 case RES_SETEXPFLD:
687 if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_NUMBERING_SEPARATOR)))
688 ::GetString( rValue, sParam1 );
689 else if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_CHAPTER_NUMBERING_LEVEL)))
690 rValue >>= nParam1;
691 break;
692 case RES_DDEFLD:
693 {
694 USHORT nPart = rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_DDE_COMMAND_TYPE)) ? 0 :
695 rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_DDE_COMMAND_FILE)) ? 1 :
696 rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_DDE_COMMAND_ELEMENT)) ? 2 :
697 rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_IS_AUTOMATIC_UPDATE)) ? 3 : USHRT_MAX;
698 if(nPart < 3 )
699 {
700 String sTmp;
701 if(!sParam1.Len())
702 (sParam1 = sfx2::cTokenSeperator)
703 += sfx2::cTokenSeperator;
704
705 sParam1.SetToken( nPart, sfx2::cTokenSeperator,
706 ::GetString( rValue, sTmp ));
707 }
708 else if(3 == nPart)
709 bParam1 = *(sal_Bool*)rValue.getValue();
710 }
711 break;
712 default:
713 throw beans::UnknownPropertyException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) );
714 }
715 }
716 }
717 /* -----------------------------30.03.01 14:40--------------------------------
718
719 ---------------------------------------------------------------------------*/
720 SwFieldType* SwXFieldMaster::GetFldType(sal_Bool bDontCreate) const
721 {
722 if(!bDontCreate && RES_DBFLD == nResTypeId && m_bIsDescriptor && m_pDoc)
723 {
724 SwDBData aData;
725
726 // set DataSource
727 svx::ODataAccessDescriptor aAcc;
728 if( sParam1.Len() > 0 )
729 aAcc[ svx::daDataSource ] <<= OUString(sParam1); // DataBaseName
730 else if( sParam5.Len() > 0 )
731 aAcc[ svx::daDatabaseLocation] <<= OUString(sParam5); // DataBaseURL
732 aData.sDataSource = aAcc.getDataSource();
733
734 aData.sCommand = sParam2;
735 aData.nCommandType = nParam2;
736 SwDBFieldType aType(m_pDoc, sParam3, aData);
737 SwFieldType* pType = m_pDoc->InsertFldType(aType);
738 SwXFieldMaster* pThis = ((SwXFieldMaster*)this);
739 pType->Add(pThis);
740 pThis->m_bIsDescriptor = sal_False;
741 }
742 if(m_bIsDescriptor)
743 return 0;
744 else
745 return (SwFieldType*)GetRegisteredIn();
746 }
747
748 /*-- 14.12.98 11:08:36---------------------------------------------------
749
750 -----------------------------------------------------------------------*/
751 typedef SwFmtFld* SwFmtFldPtr;
752 SV_DECL_PTRARR(SwDependentFields, SwFmtFldPtr, 5, 5)
753 SV_IMPL_PTRARR(SwDependentFields, SwFmtFldPtr)
754
755 uno::Any SwXFieldMaster::getPropertyValue(const OUString& rPropertyName)
756 throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
757 {
758 vos::OGuard aGuard(Application::GetSolarMutex());
759 uno::Any aRet;
760 SwFieldType* pType = GetFldType(sal_True);
761 if( rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_INSTANCE_NAME)) )
762 {
763 String sName;
764 if(pType)
765 SwXTextFieldMasters::getInstanceName(*pType, sName);
766 aRet <<= OUString(sName);
767 }
768 else if(pType)
769 {
770 if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_NAME) ))
771 {
772 aRet <<= SwXFieldMaster::GetProgrammaticName(*pType, *GetDoc());
773 }
774 else if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_DEPENDENT_TEXT_FIELDS)) )
775 {
776 //fill all text fields into a sequence
777 SwClientIter aIter( *pType );
778 SwDependentFields aFldArr;
779 SwFmtFldPtr pFld = (SwFmtFld*)aIter.First( TYPE( SwFmtFld ));
780 while(pFld)
781 {
782 if(pFld->IsFldInDoc())
783 aFldArr.Insert(pFld, aFldArr.Count());
784 pFld = (SwFmtFld*)aIter.Next();
785 }
786 uno::Sequence<uno::Reference <text::XDependentTextField> > aRetSeq(aFldArr.Count());
787 uno::Reference<text::XDependentTextField>* pRetSeq = aRetSeq.getArray();
788 for(USHORT i = 0; i < aFldArr.Count(); i++)
789 {
790 pFld = aFldArr.GetObject(i);
791 SwXTextField * pInsert = CreateSwXTextField(*GetDoc(), *pFld);
792
793 pRetSeq[i] = uno::Reference<text::XDependentTextField>(pInsert);
794 }
795 aRet <<= aRetSeq;
796 }
797 else if(pType)
798 {
799 //TODO: Properties fuer die uebrigen Feldtypen einbauen
800 USHORT nMId = GetFieldTypeMId( rPropertyName, *pType );
801 if( USHRT_MAX != nMId )
802 {
803 pType->QueryValue( aRet, nMId );
804
805 if( rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_DATA_BASE_NAME)) ||
806 rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_DATA_BASE_URL)))
807 {
808 OUString aDataSource;
809 aRet >>= aDataSource;
810 aRet <<= OUString();
811
812 OUString *pStr = 0; // only one of this properties will return
813 // a non-empty string.
814 INetURLObject aObj;
815 aObj.SetURL( aDataSource );
816 BOOL bIsURL = aObj.GetProtocol() != INET_PROT_NOT_VALID;
817 if (bIsURL && rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_DATA_BASE_URL)))
818 pStr = &aDataSource; // DataBaseURL
819 else if (!bIsURL && rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_DATA_BASE_NAME)))
820 pStr = &aDataSource; // DataBaseName
821
822 if (pStr)
823 aRet <<= *pStr;
824 }
825 }
826 else
827 throw beans::UnknownPropertyException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) );
828 }
829 else
830 {
831 if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_DATA_COMMAND_TYPE)) )
832 aRet <<= nParam2;
833 }
834 }
835 else
836 {
837 if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_DATA_COMMAND_TYPE)) )
838 aRet <<= nParam2;
839 else if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_DEPENDENT_TEXT_FIELDS)) )
840 {
841 uno::Sequence<uno::Reference <text::XDependentTextField> > aRetSeq(0);
842 aRet <<= aRetSeq;
843 }
844 else
845 {
846 const String* pStr = 0;
847 String sStr;
848 switch ( nResTypeId )
849 {
850 case RES_USERFLD:
851 if( rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_CONTENT)) )
852 pStr = &sParam1;
853 else if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_VALUE )))
854 aRet <<= fParam1;
855 else if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_IS_EXPRESSION )))
856 aRet.setValue(&bParam1, ::getBooleanCppuType());
857 break;
858 case RES_DBFLD:
859 if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_DATA_BASE_NAME)) ||
860 rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_DATA_BASE_URL)))
861 {
862 pStr = 0; // only one of this properties will return
863 // a non-empty string.
864 INetURLObject aObj;
865 aObj.SetURL( sParam5 ); // SetSmartURL
866 BOOL bIsURL = aObj.GetProtocol() != INET_PROT_NOT_VALID;
867 if (bIsURL && rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_DATA_BASE_URL)))
868 pStr = &sParam5; // DataBaseURL
869 else if ( rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_DATA_BASE_NAME)))
870 pStr = &sParam1; // DataBaseName
871 }
872 else if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_DATA_TABLE_NAME)))
873 pStr = &sParam2;
874 else if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_DATA_COLUMN_NAME)))
875 pStr = &sParam3;
876 break;
877 case RES_SETEXPFLD:
878 if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_NUMBERING_SEPARATOR)))
879 pStr = &sParam1;
880 else if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_CHAPTER_NUMBERING_LEVEL)))
881 aRet <<= nParam1;
882 break;
883 case RES_DDEFLD:
884 {
885 USHORT nPart = rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_DDE_COMMAND_TYPE)) ? 0 :
886 rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_DDE_COMMAND_FILE)) ? 1 :
887 rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_DDE_COMMAND_ELEMENT)) ? 2 :
888 rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_IS_AUTOMATIC_UPDATE)) ? 3 : USHRT_MAX;
889 if(nPart < 3 )
890 pStr = &(sStr = sParam1.GetToken(nPart, sfx2::cTokenSeperator));
891 else if(3 == nPart)
892 aRet.setValue(&bParam1, ::getBooleanCppuType());
893 }
894 break;
895 default:
896 throw beans::UnknownPropertyException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) );
897 }
898
899 if( pStr )
900 aRet <<= OUString( *pStr );
901 }
902 }
903 return aRet;
904 }
905 /*-- 14.12.98 11:08:36---------------------------------------------------
906
907 -----------------------------------------------------------------------*/
908 void SwXFieldMaster::addPropertyChangeListener(const OUString& /*PropertyName*/, const uno::Reference< beans::XPropertyChangeListener > & /*aListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
909 {
910 DBG_WARNING("not implemented");
911 }
912 /*-- 14.12.98 11:08:36---------------------------------------------------
913
914 -----------------------------------------------------------------------*/
915 void SwXFieldMaster::removePropertyChangeListener(const OUString& /*PropertyName*/, const uno::Reference< beans::XPropertyChangeListener > & /*aListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
916 {
917 DBG_WARNING("not implemented");
918 }
919 /*-- 14.12.98 11:08:37---------------------------------------------------
920
921 -----------------------------------------------------------------------*/
922 void SwXFieldMaster::addVetoableChangeListener(const OUString& /*PropertyName*/, const uno::Reference< beans::XVetoableChangeListener > & /*aListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
923 {
924 DBG_WARNING("not implemented");
925 }
926 /*-- 14.12.98 11:08:37---------------------------------------------------
927
928 -----------------------------------------------------------------------*/
929 void SwXFieldMaster::removeVetoableChangeListener(const OUString& /*PropertyName*/, const uno::Reference< beans::XVetoableChangeListener > & /*aListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
930 {
931 DBG_WARNING("not implemented");
932 }
933
934 /*-- 25.02.99 11:01:57---------------------------------------------------
935
936 -----------------------------------------------------------------------*/
937 void SwXFieldMaster::dispose(void) throw( uno::RuntimeException )
938 {
939 vos::OGuard aGuard(Application::GetSolarMutex());
940 SwFieldType* pFldType = GetFldType(sal_True);
941 if(pFldType)
942 {
943 sal_uInt16 nTypeIdx = USHRT_MAX;
944 const SwFldTypes* pTypes = GetDoc()->GetFldTypes();
945 for( sal_uInt16 i = 0; i < pTypes->Count(); i++ )
946 {
947 if((*pTypes)[i] == pFldType)
948 nTypeIdx = i;
949 }
950
951 // zuerst alle Felder loeschen
952 SwClientIter aIter( *pFldType );
953 SwFmtFld* pFld = (SwFmtFld*)aIter.First( TYPE( SwFmtFld ));
954 while(pFld)
955 {
956 // Feld im Undo?
957 SwTxtFld *pTxtFld = pFld->GetTxtFld();
958 if(pTxtFld && pTxtFld->GetTxtNode().GetNodes().IsDocNodes() )
959 {
960 SwTxtNode& rTxtNode = (SwTxtNode&)*pTxtFld->GetpTxtNode();
961 SwPaM aPam(rTxtNode, *pTxtFld->GetStart());
962 aPam.SetMark();
963 aPam.Move();
964 GetDoc()->DeleteAndJoin(aPam);
965 }
966 pFld = (SwFmtFld*)aIter.Next();
967 }
968 // dann den FieldType loeschen
969 GetDoc()->RemoveFldType(nTypeIdx);
970 }
971 else
972 throw uno::RuntimeException();
973 }
974 /*-- 25.02.99 11:02:00---------------------------------------------------
975
976 -----------------------------------------------------------------------*/
977 void SwXFieldMaster::addEventListener(const uno::Reference< lang::XEventListener > & aListener)
978 throw( uno::RuntimeException )
979 {
980 if(!GetRegisteredIn())
981 throw uno::RuntimeException();
982 aLstnrCntnr.AddListener(aListener);
983 }
984 /*-- 25.02.99 11:02:02---------------------------------------------------
985
986 -----------------------------------------------------------------------*/
987 void SwXFieldMaster::removeEventListener(const uno::Reference< lang::XEventListener > & aListener)
988 throw( uno::RuntimeException )
989 {
990 if(!GetRegisteredIn() || !aLstnrCntnr.RemoveListener(aListener))
991 throw uno::RuntimeException();
992 }
993
994 /*-- 14.12.98 11:08:38---------------------------------------------------
995
996 -----------------------------------------------------------------------*/
997 void SwXFieldMaster::Modify( SfxPoolItem *pOld, SfxPoolItem *pNew)
998 {
999 ClientModify(this, pOld, pNew);
1000 if(!GetRegisteredIn())
1001 {
1002 aLstnrCntnr.Disposing();
1003 m_pDoc = 0;
1004 }
1005 }
1006 /* -----------------------------06.11.00 09:44--------------------------------
1007
1008 const Programmatic2UIName_Impl* lcl_GetFieldNameTable()
1009 {
1010 static BOOL bInitialized = FALSE;
1011 static Programmatic2UIName_Impl aFieldNames[5];
1012 if(!bInitialized)
1013 {
1014 bInitialized = TRUE;
1015 int nName = 0;
1016 aFieldNames[nName].sUIName = String (SW_RES(STR_POOLCOLL_LABEL_ABB ));
1017 aFieldNames[nName++].sProgrammaticName = String (SW_RES(STR_POCO_PRGM_LABEL_ABB));
1018 aFieldNames[nName].sUIName = String (SW_RES(STR_POOLCOLL_LABEL_TABLE ));
1019 aFieldNames[nName++].sProgrammaticName = String (SW_RES(STR_POCO_PRGM_LABEL_TABLE));
1020 aFieldNames[nName].sUIName = String (SW_RES(STR_POOLCOLL_LABEL_FRAME));
1021 aFieldNames[nName++].sProgrammaticName = String (SW_RES(STR_POCO_PRGM_LABEL_FRAME));
1022 aFieldNames[nName].sUIName = String (SW_RES(STR_POOLCOLL_LABEL_DRAWING ));
1023 aFieldNames[nName++].sProgrammaticName = String (SW_RES(STR_POCO_PRGM_LABEL_DRAWING));
1024 }
1025 return &aFieldNames[0];
1026 }
1027 ---------------------------------------------------------------------------*/
1028 /* -----------------------------06.11.00 10:26--------------------------------
1029
1030 ---------------------------------------------------------------------------*/
1031 OUString SwXFieldMaster::GetProgrammaticName(const SwFieldType& rType, SwDoc& rDoc)
1032 {
1033 OUString sRet(rType.GetName());
1034 if(RES_SETEXPFLD == rType.Which())
1035 {
1036 const SwFldTypes* pTypes = rDoc.GetFldTypes();
1037 for( sal_uInt16 i = 0; i <= INIT_FLDTYPES; i++ )
1038 {
1039 if((*pTypes)[i] == &rType)
1040 {
1041 sRet = SwStyleNameMapper::GetProgName ( sRet, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL );
1042 break;
1043 }
1044 }
1045 }
1046 return sRet;
1047 }
1048 /* -----------------------------06.11.00 14:12--------------------------------
1049
1050 ---------------------------------------------------------------------------*/
1051 OUString SwXFieldMaster::LocalizeFormula(
1052 const SwSetExpField& rFld,
1053 const OUString& rFormula,
1054 sal_Bool bQuery)
1055 {
1056 const OUString sTypeName(rFld.GetTyp()->GetName());
1057 OUString sProgName = SwStyleNameMapper::GetProgName(sTypeName, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL );
1058 if(sProgName != sTypeName)
1059 {
1060 OUString sSource = bQuery ? sTypeName : sProgName;
1061 OUString sDest = bQuery ? sProgName : sTypeName;
1062 if(!rFormula.compareTo(sSource, sSource.getLength()))
1063 {
1064 OUString sTmpFormula = sDest;
1065 sTmpFormula += rFormula.copy(sSource.getLength());
1066 return sTmpFormula;
1067 }
1068 }
1069 return rFormula;
1070 }
1071
1072
1073 SwXTextField * CreateSwXTextField(SwDoc & rDoc, SwFmtFld const& rFmt)
1074 {
1075 SwClientIter aIter(*rFmt.GetFld()->GetTyp());
1076 SwXTextField * pField = 0;
1077 SwXTextField * pTemp =
1078 static_cast<SwXTextField*>(aIter.First( TYPE(SwXTextField) ));
1079 while (pTemp)
1080 {
1081 if (pTemp->GetFldFmt() == &rFmt)
1082 {
1083 pField = pTemp;
1084 break;
1085 }
1086 pTemp = static_cast<SwXTextField*>(aIter.Next());
1087 }
1088 return pField ? pField : new SwXTextField( rFmt, &rDoc );
1089 }
1090
1091 /******************************************************************
1092 *
1093 ******************************************************************/
1094 struct SwFieldProperties_Impl
1095 {
1096 String sPar1;
1097 String sPar2;
1098 String sPar3;
1099 String sPar4;
1100 String sPar5;
1101 String sPar6;
1102 Date aDate;
1103 double fDouble;
1104 uno::Sequence<beans::PropertyValue> aPropSeq;
1105 uno::Sequence<OUString> aStrings;
1106 util::DateTime* pDateTime;
1107
1108 sal_Int32 nSubType;
1109 sal_Int32 nFormat;
1110 sal_uInt16 nUSHORT1;
1111 sal_uInt16 nUSHORT2;
1112 sal_Int16 nSHORT1;
1113 sal_Int8 nByte1;
1114 sal_Bool bFormatIsDefault;
1115 sal_Bool bBool1;
1116 sal_Bool bBool2;
1117 sal_Bool bBool3;
1118 sal_Bool bBool4;
1119
1120 SwFieldProperties_Impl():
1121 fDouble(0.),
1122 pDateTime(0),
1123 nSubType(0),
1124 nFormat(0),
1125 nUSHORT1(0),
1126 nUSHORT2(0),
1127 nSHORT1(0),
1128 nByte1(0),
1129 bFormatIsDefault(sal_True),
1130 bBool1(sal_False),
1131 bBool2(sal_False),
1132 bBool3(sal_False),
1133 bBool4(sal_True) //Automatic language
1134 {}
1135 ~SwFieldProperties_Impl()
1136 {delete pDateTime;}
1137
1138 };
1139
1140 TYPEINIT1(SwXTextField, SwClient);
1141 /* -----------------------------13.03.00 12:15--------------------------------
1142
1143 ---------------------------------------------------------------------------*/
1144 const uno::Sequence< sal_Int8 > & SwXTextField::getUnoTunnelId()
1145 {
1146 static uno::Sequence< sal_Int8 > aSeq = ::CreateUnoTunnelId();
1147 return aSeq;
1148 }
1149 /* -----------------------------10.03.00 18:04--------------------------------
1150
1151 ---------------------------------------------------------------------------*/
1152 sal_Int64 SAL_CALL SwXTextField::getSomething( const uno::Sequence< sal_Int8 >& rId )
1153 throw(uno::RuntimeException)
1154 {
1155 if( rId.getLength() == 16
1156 && 0 == rtl_compareMemory( getUnoTunnelId().getConstArray(),
1157 rId.getConstArray(), 16 ) )
1158 {
1159 return sal::static_int_cast< sal_Int64 >( reinterpret_cast< sal_IntPtr >(this) );
1160 }
1161 return 0;
1162 }
1163 /*-- 14.12.98 11:37:14---------------------------------------------------
1164
1165 -----------------------------------------------------------------------*/
1166
1167 SwXTextField::SwXTextField(sal_uInt16 nServiceId, SwDoc* pDoc) :
1168 aLstnrCntnr( (XTextContent*)this),
1169 pFmtFld(0),
1170 m_pDoc(pDoc),
1171 m_pTextObject(0),
1172 m_bIsDescriptor(nServiceId != USHRT_MAX),
1173 m_bCallUpdate(sal_False),
1174 m_nServiceId(nServiceId),
1175 m_pProps(new SwFieldProperties_Impl)
1176 {
1177 //Set visible as default!
1178 if(SW_SERVICE_FIELDTYPE_SET_EXP == nServiceId ||
1179 SW_SERVICE_FIELDTYPE_DATABASE_SET_NUM == nServiceId ||
1180 SW_SERVICE_FIELDTYPE_DATABASE == nServiceId ||
1181 SW_SERVICE_FIELDTYPE_DATABASE_NAME == nServiceId )
1182 m_pProps->bBool2 = sal_True;
1183 else if(SW_SERVICE_FIELDTYPE_TABLE_FORMULA == nServiceId)
1184 m_pProps->bBool1 = sal_True;
1185 if(SW_SERVICE_FIELDTYPE_SET_EXP == nServiceId)
1186 m_pProps->nUSHORT2 = USHRT_MAX;
1187
1188 }
1189 /*-- 14.12.98 11:37:15---------------------------------------------------
1190
1191 -----------------------------------------------------------------------*/
1192 SwXTextField::SwXTextField(const SwFmtFld& rFmt, SwDoc* pDc) :
1193 aLstnrCntnr( (XTextContent*)this),
1194 pFmtFld(&rFmt),
1195 m_pDoc(pDc),
1196 m_pTextObject(0),
1197 m_bIsDescriptor(sal_False),
1198 m_bCallUpdate(sal_False),
1199 m_nServiceId( lcl_GetServiceForField( *pFmtFld->GetFld() ) ),
1200 m_pProps(0)
1201 {
1202 pDc->GetUnoCallBack()->Add(this);
1203 }
1204 /*-- 14.12.98 11:37:15---------------------------------------------------
1205
1206 -----------------------------------------------------------------------*/
1207 SwXTextField::~SwXTextField()
1208 {
1209 if ( m_pTextObject )
1210 {
1211 m_pTextObject->DisposeEditSource();
1212 m_pTextObject->release();
1213 }
1214
1215 delete m_pProps;
1216 }
1217 /*-- 14.12.98 11:37:16---------------------------------------------------
1218
1219 -----------------------------------------------------------------------*/
1220 void SwXTextField::attachTextFieldMaster(const uno::Reference< beans::XPropertySet > & xFieldMaster)
1221 throw( lang::IllegalArgumentException, uno::RuntimeException )
1222 {
1223 vos::OGuard aGuard(Application::GetSolarMutex());
1224 if(!m_bIsDescriptor)
1225 throw uno::RuntimeException();
1226 uno::Reference< lang::XUnoTunnel > xMasterTunnel(xFieldMaster, uno::UNO_QUERY);
1227 if (!xMasterTunnel.is())
1228 throw lang::IllegalArgumentException();
1229 SwXFieldMaster* pMaster = reinterpret_cast< SwXFieldMaster * >(
1230 sal::static_int_cast< sal_IntPtr >( xMasterTunnel->getSomething( SwXFieldMaster::getUnoTunnelId()) ));
1231
1232 SwFieldType* pFieldType = pMaster ? pMaster->GetFldType() : 0;
1233 if(pFieldType && pFieldType->Which() == lcl_ServiceIdToResId(m_nServiceId))
1234 {
1235 m_sTypeName = pFieldType->GetName();
1236 pFieldType->Add( &m_aFieldTypeClient );
1237 }
1238 else
1239 throw lang::IllegalArgumentException();
1240
1241 }
1242 /*-- 14.12.98 11:37:16---------------------------------------------------
1243
1244 -----------------------------------------------------------------------*/
1245 uno::Reference< beans::XPropertySet > SwXTextField::getTextFieldMaster(void) throw( uno::RuntimeException )
1246 {
1247 vos::OGuard aGuard(Application::GetSolarMutex());
1248 SwFieldType* pType = 0;
1249 if( m_bIsDescriptor && m_aFieldTypeClient.GetRegisteredIn() )
1250 {
1251 pType = (SwFieldType*)m_aFieldTypeClient.GetRegisteredIn();
1252 }
1253 else
1254 {
1255 if(!GetRegisteredIn())
1256 throw uno::RuntimeException();
1257 pType = pFmtFld->GetFld()->GetTyp();
1258 }
1259 SwXFieldMaster* pMaster = (SwXFieldMaster*)
1260 SwClientIter(*pType).First(TYPE(SwXFieldMaster));
1261 if(!pMaster)
1262 pMaster = new SwXFieldMaster(*pType, GetDoc());
1263
1264 return pMaster;
1265 }
1266 /*-- 14.12.98 11:37:16---------------------------------------------------
1267
1268 -----------------------------------------------------------------------*/
1269 OUString SwXTextField::getPresentation(sal_Bool bShowCommand) throw( uno::RuntimeException )
1270 {
1271 vos::OGuard aGuard(Application::GetSolarMutex());
1272 OUString sRet;
1273 const SwField* pField = GetField();
1274 if(pField)
1275 sRet = pField->GetCntnt(bShowCommand);
1276 else
1277 throw uno::RuntimeException();
1278 return sRet;
1279 }
1280 /* -----------------18.02.99 13:39-------------------
1281 *
1282 * --------------------------------------------------*/
1283 void SwXTextField::attachToRange(
1284 const uno::Reference< text::XTextRange > & xTextRange)
1285 throw( lang::IllegalArgumentException, uno::RuntimeException )
1286 {
1287 vos::OGuard aGuard(Application::GetSolarMutex());
1288 if(!m_bIsDescriptor)
1289 throw uno::RuntimeException();
1290 uno::Reference<lang::XUnoTunnel> xRangeTunnel( xTextRange, uno::UNO_QUERY);
1291 SwXTextRange* pRange = 0;
1292 OTextCursorHelper* pCursor = 0;
1293 if(xRangeTunnel.is())
1294 {
1295 pRange = reinterpret_cast< SwXTextRange * >(
1296 sal::static_int_cast< sal_IntPtr >( xRangeTunnel->getSomething( SwXTextRange::getUnoTunnelId()) ));
1297 pCursor = reinterpret_cast< OTextCursorHelper * >(
1298 sal::static_int_cast< sal_IntPtr >( xRangeTunnel->getSomething( OTextCursorHelper::getUnoTunnelId()) ));
1299 }
1300
1301 SwDoc* pDoc = pRange ? (SwDoc*)pRange->GetDoc() : pCursor ? (SwDoc*)pCursor->GetDoc() : 0;
1302 //wurde ein FieldMaster attached, dann ist das Dokument schon festgelegt!
1303 if(pDoc && (!m_pDoc || m_pDoc == pDoc))
1304 {
1305 SwUnoInternalPaM aPam(*pDoc);
1306 //das muss jetzt sal_True liefern
1307 SwXTextRange::XTextRangeToSwPaM(aPam, xTextRange);
1308 SwField* pFld = 0;
1309 switch(m_nServiceId)
1310 {
1311 case SW_SERVICE_FIELDTYPE_ANNOTATION:
1312 {
1313 SwFieldType* pFldType = pDoc->GetSysFldType(RES_POSTITFLD);
1314
1315 DateTime aDateTime;
1316 if (m_pProps->pDateTime)
1317 {
1318 aDateTime.SetYear(m_pProps->pDateTime->Year);
1319 aDateTime.SetMonth(m_pProps->pDateTime->Month);
1320 aDateTime.SetDay(m_pProps->pDateTime->Day);
1321 aDateTime.SetHour(m_pProps->pDateTime->Hours);
1322 aDateTime.SetMin(m_pProps->pDateTime->Minutes);
1323 aDateTime.SetSec(m_pProps->pDateTime->Seconds);
1324 }
1325 pFld = new SwPostItField((SwPostItFieldType*)pFldType,
1326 m_pProps->sPar1, m_pProps->sPar2,aDateTime);
1327 if ( m_pTextObject )
1328 {
1329 ((SwPostItField*)pFld)->SetTextObject( m_pTextObject->CreateText() );
1330 ((SwPostItField*)pFld)->SetPar2(m_pTextObject->GetText());
1331 }
1332 }
1333 break;
1334 case SW_SERVICE_FIELDTYPE_SCRIPT:
1335 {
1336 SwFieldType* pFldType = pDoc->GetSysFldType(RES_SCRIPTFLD);
1337 pFld = new SwScriptField((SwScriptFieldType*)pFldType,
1338 m_pProps->sPar1, m_pProps->sPar2,
1339 m_pProps->bBool1);
1340 }
1341 break;
1342 case SW_SERVICE_FIELDTYPE_DATETIME:
1343 {
1344 sal_uInt16 nSub = 0;
1345 if(m_pProps->bBool1)
1346 nSub |= FIXEDFLD;
1347 if(m_pProps->bBool2)
1348 nSub |= DATEFLD;
1349 else
1350 nSub |= TIMEFLD;
1351 SwFieldType* pFldType = pDoc->GetSysFldType(RES_DATETIMEFLD);
1352 pFld = new SwDateTimeField((SwDateTimeFieldType*)pFldType,
1353 nSub, m_pProps->nFormat);
1354 if(m_pProps->fDouble > 0.)
1355 ((SwDateTimeField*)pFld)->SetValue( m_pProps->fDouble );
1356 if(m_pProps->pDateTime)
1357 {
1358 uno::Any aVal; aVal <<= *m_pProps->pDateTime;
1359 pFld->PutValue( aVal, FIELD_PROP_DATE_TIME );
1360 }
1361 ((SwDateTimeField*)pFld)->SetOffset(m_pProps->nSubType);
1362 }
1363 break;
1364 case SW_SERVICE_FIELDTYPE_FILE_NAME:
1365 {
1366 SwFieldType* pFldType = pDoc->GetSysFldType(RES_FILENAMEFLD);
1367 sal_Int32 nFormat = m_pProps->nFormat;
1368 if(m_pProps->bBool2)
1369 nFormat |= FF_FIXED;
1370 pFld = new SwFileNameField((SwFileNameFieldType*)pFldType, nFormat);
1371 if(m_pProps->sPar3.Len())
1372 ((SwFileNameField*)pFld)->SetExpansion(m_pProps->sPar3);
1373 uno::Any aFormat(&m_pProps->nFormat, ::getCppuType(&m_pProps->nFormat));
1374 pFld->PutValue( aFormat, FIELD_PROP_FORMAT );
1375 }
1376 break;
1377 case SW_SERVICE_FIELDTYPE_TEMPLATE_NAME:
1378 {
1379 SwFieldType* pFldType = pDoc->GetSysFldType(RES_TEMPLNAMEFLD);
1380 pFld = new SwTemplNameField((SwTemplNameFieldType*)pFldType,
1381 m_pProps->nFormat);
1382 uno::Any aFormat(&m_pProps->nFormat, ::getCppuType(&m_pProps->nFormat));
1383 pFld->PutValue(aFormat, FIELD_PROP_FORMAT);
1384 }
1385 break;
1386 case SW_SERVICE_FIELDTYPE_CHAPTER:
1387 {
1388 SwFieldType* pFldType = pDoc->GetSysFldType(RES_CHAPTERFLD);
1389 pFld = new SwChapterField((SwChapterFieldType*)pFldType, m_pProps->nUSHORT1);
1390 ((SwChapterField*)pFld)->SetLevel(m_pProps->nByte1);
1391 uno::Any aVal; aVal <<= (sal_Int16)m_pProps->nUSHORT1;
1392 pFld->PutValue(aVal, FIELD_PROP_USHORT1 );
1393 }
1394 break;
1395 case SW_SERVICE_FIELDTYPE_AUTHOR:
1396 {
1397 long nFormat = m_pProps->bBool1 ? AF_NAME : AF_SHORTCUT;
1398 if(m_pProps->bBool2)
1399 nFormat |= AF_FIXED;
1400
1401 SwFieldType* pFldType = pDoc->GetSysFldType(RES_AUTHORFLD);
1402 pFld = new SwAuthorField((SwAuthorFieldType*)pFldType, nFormat);
1403 ((SwAuthorField*)pFld)->SetExpansion(m_pProps->sPar1);
1404 }
1405 break;
1406 case SW_SERVICE_FIELDTYPE_CONDITIONED_TEXT:
1407 case SW_SERVICE_FIELDTYPE_HIDDEN_TEXT:
1408 {
1409 SwFieldType* pFldType = pDoc->GetSysFldType(RES_HIDDENTXTFLD);
1410 pFld = new SwHiddenTxtField(((SwHiddenTxtFieldType*)pFldType),
1411 m_pProps->sPar1,
1412 m_pProps->sPar2, m_pProps->sPar3,
1413 static_cast< USHORT >(SW_SERVICE_FIELDTYPE_HIDDEN_TEXT == m_nServiceId ?
1414 TYP_HIDDENTXTFLD : TYP_CONDTXTFLD));
1415 ((SwHiddenTxtField*)pFld)->SetValue(m_pProps->bBool1);
1416 uno::Any aVal; aVal <<= (OUString)m_pProps->sPar4;
1417 pFld->PutValue(aVal, FIELD_PROP_PAR4 );
1418 }
1419 break;
1420 case SW_SERVICE_FIELDTYPE_HIDDEN_PARA:
1421 {
1422 SwFieldType* pFldType = pDoc->GetSysFldType(RES_HIDDENPARAFLD);
1423 pFld = new SwHiddenParaField((SwHiddenParaFieldType*)pFldType,
1424 m_pProps->sPar1);
1425 ((SwHiddenParaField*)pFld)->SetHidden(m_pProps->bBool1);
1426 }
1427 break;
1428 case SW_SERVICE_FIELDTYPE_GET_REFERENCE:
1429 {
1430 SwFieldType* pFldType = pDoc->GetSysFldType(RES_GETREFFLD);
1431 pFld = new SwGetRefField((SwGetRefFieldType*)pFldType,
1432 m_pProps->sPar1,
1433 0,
1434 0,
1435 0);
1436 if(m_pProps->sPar3.Len())
1437 ((SwGetRefField*)pFld)->SetExpand(m_pProps->sPar3);
1438 uno::Any aVal; aVal <<=(sal_Int16)m_pProps->nUSHORT1;
1439 pFld->PutValue(aVal, FIELD_PROP_USHORT1 );
1440 aVal <<=(sal_Int16)m_pProps->nUSHORT2;
1441 pFld->PutValue(aVal, FIELD_PROP_USHORT2 );
1442 aVal <<=(sal_Int16)m_pProps->nSHORT1;
1443 pFld->PutValue(aVal, FIELD_PROP_SHORT1 );
1444 }
1445 break;
1446 case SW_SERVICE_FIELDTYPE_JUMP_EDIT:
1447 {
1448 SwFieldType* pFldType = pDoc->GetSysFldType(RES_JUMPEDITFLD);
1449 pFld = new SwJumpEditField((SwJumpEditFieldType*)pFldType,
1450 m_pProps->nUSHORT1, m_pProps->sPar2, m_pProps->sPar1);
1451 }
1452 break;
1453 case SW_SERVICE_FIELDTYPE_DOCINFO_CHANGE_AUTHOR :
1454 case SW_SERVICE_FIELDTYPE_DOCINFO_CHANGE_DATE_TIME :
1455 case SW_SERVICE_FIELDTYPE_DOCINFO_EDIT_TIME :
1456 case SW_SERVICE_FIELDTYPE_DOCINFO_DESCRIPTION :
1457 case SW_SERVICE_FIELDTYPE_DOCINFO_CREATE_AUTHOR :
1458 case SW_SERVICE_FIELDTYPE_DOCINFO_CREATE_DATE_TIME :
1459 case SW_SERVICE_FIELDTYPE_DOCINFO_CUSTOM :
1460 case SW_SERVICE_FIELDTYPE_DOCINFO_PRINT_AUTHOR :
1461 case SW_SERVICE_FIELDTYPE_DOCINFO_PRINT_DATE_TIME :
1462 case SW_SERVICE_FIELDTYPE_DOCINFO_KEY_WORDS :
1463 case SW_SERVICE_FIELDTYPE_DOCINFO_SUBJECT :
1464 case SW_SERVICE_FIELDTYPE_DOCINFO_TITLE :
1465 case SW_SERVICE_FIELDTYPE_DOCINFO_REVISION :
1466 case SW_SERVICE_FIELDTYPE_DOC_INFO:
1467 {
1468 SwFieldType* pFldType = pDoc->GetSysFldType(RES_DOCINFOFLD);
1469 sal_uInt16 nSubType = aDocInfoSubTypeFromService[
1470 m_nServiceId - SW_SERVICE_FIELDTYPE_DOCINFO_CHANGE_AUTHOR];
1471 if( SW_SERVICE_FIELDTYPE_DOCINFO_CHANGE_DATE_TIME == m_nServiceId ||
1472 SW_SERVICE_FIELDTYPE_DOCINFO_CREATE_DATE_TIME == m_nServiceId ||
1473 SW_SERVICE_FIELDTYPE_DOCINFO_PRINT_DATE_TIME == m_nServiceId ||
1474 SW_SERVICE_FIELDTYPE_DOCINFO_EDIT_TIME == m_nServiceId )
1475 {
1476 if(m_pProps->bBool2) //IsDate
1477 {
1478 nSubType &= 0xf0ff;
1479 nSubType |= DI_SUB_DATE;
1480 }
1481 else
1482 {
1483 nSubType &= 0xf0ff;
1484 nSubType |= DI_SUB_TIME;
1485 }
1486 }
1487 if(m_pProps->bBool1)
1488 nSubType |= DI_SUB_FIXED;
1489 pFld = new SwDocInfoField((SwDocInfoFieldType*)pFldType, nSubType, m_pProps->sPar4, m_pProps->nFormat);
1490 if(m_pProps->sPar3.Len())
1491 ((SwDocInfoField*)pFld)->SetExpansion(m_pProps->sPar3);
1492 }
1493 break;
1494 case SW_SERVICE_FIELDTYPE_USER_EXT:
1495 {
1496 sal_Int32 nFormat = 0;
1497 if(m_pProps->bBool1)
1498 nFormat = AF_FIXED;
1499
1500 SwFieldType* pFldType = pDoc->GetSysFldType(RES_EXTUSERFLD);
1501 pFld = new SwExtUserField((SwExtUserFieldType*)pFldType, m_pProps->nUSHORT1, nFormat);
1502 ((SwExtUserField*)pFld)->SetExpansion(m_pProps->sPar1);
1503 }
1504 break;
1505 case SW_SERVICE_FIELDTYPE_USER:
1506 {
1507 SwFieldType* pFldType = pDoc->GetFldType(RES_USERFLD, m_sTypeName, sal_True);
1508 if(!pFldType)
1509 throw uno::RuntimeException();
1510 USHORT nUserSubType = m_pProps->bBool1 ? nsSwExtendedSubType::SUB_INVISIBLE : 0;
1511 if(m_pProps->bBool2)
1512 nUserSubType |= nsSwExtendedSubType::SUB_CMD;
1513 if(m_pProps->bFormatIsDefault &&
1514 nsSwGetSetExpType::GSE_STRING == ((SwUserFieldType*)pFldType)->GetType())
1515 m_pProps->nFormat = -1;
1516 pFld = new SwUserField((SwUserFieldType*)pFldType,
1517 nUserSubType,
1518 m_pProps->nFormat);
1519 }
1520 break;
1521 case SW_SERVICE_FIELDTYPE_REF_PAGE_SET:
1522 {
1523 SwFieldType* pFldType = pDoc->GetSysFldType(RES_REFPAGESETFLD);
1524 pFld = new SwRefPageSetField( (SwRefPageSetFieldType*)pFldType,
1525 m_pProps->nUSHORT1,
1526 m_pProps->bBool1 );
1527 }
1528 break;
1529 case SW_SERVICE_FIELDTYPE_REF_PAGE_GET:
1530 {
1531 SwFieldType* pFldType = pDoc->GetSysFldType(RES_REFPAGEGETFLD);
1532 pFld = new SwRefPageGetField( (SwRefPageGetFieldType*)pFldType,
1533 m_pProps->nUSHORT1 );
1534 ((SwRefPageGetField*)pFld)->SetText(m_pProps->sPar1);
1535 }
1536 break;
1537 case SW_SERVICE_FIELDTYPE_PAGE_NUM:
1538 {
1539 SwFieldType* pFldType = pDoc->GetSysFldType(RES_PAGENUMBERFLD);
1540 pFld = new SwPageNumberField((SwPageNumberFieldType*)pFldType,
1541 PG_RANDOM,
1542 m_pProps->nFormat,
1543 m_pProps->nUSHORT1);
1544 ((SwPageNumberField*)pFld)->SetUserString(m_pProps->sPar1);
1545 uno::Any aVal; aVal <<= m_pProps->nSubType;
1546 pFld->PutValue( aVal, FIELD_PROP_SUBTYPE );
1547 }
1548 break;
1549 case SW_SERVICE_FIELDTYPE_DDE:
1550 {
1551 SwFieldType* pFldType = pDoc->GetFldType(RES_DDEFLD, m_sTypeName, sal_True);
1552 if(!pFldType)
1553 throw uno::RuntimeException();
1554 pFld = new SwDDEField( (SwDDEFieldType*)pFldType );
1555 }
1556 break;
1557 case SW_SERVICE_FIELDTYPE_DATABASE_NAME:
1558 {
1559 SwFieldType* pFldType = pDoc->GetSysFldType(RES_DBNAMEFLD);
1560 SwDBData aData;
1561 aData.sDataSource = m_pProps->sPar1;
1562 aData.sCommand = m_pProps->sPar2;
1563 aData.nCommandType = m_pProps->nSHORT1;
1564 pFld = new SwDBNameField((SwDBNameFieldType*)pFldType, aData);
1565 sal_uInt16 nSubType = pFld->GetSubType();
1566 if(m_pProps->bBool2)
1567 nSubType &= ~nsSwExtendedSubType::SUB_INVISIBLE;
1568 else
1569 nSubType |= nsSwExtendedSubType::SUB_INVISIBLE;
1570 pFld->SetSubType(nSubType);
1571 }
1572 break;
1573 case SW_SERVICE_FIELDTYPE_DATABASE_NEXT_SET:
1574 {
1575 SwDBData aData;
1576 aData.sDataSource = m_pProps->sPar1;
1577 aData.sCommand = m_pProps->sPar2;
1578 aData.nCommandType = m_pProps->nSHORT1;
1579 SwFieldType* pFldType = pDoc->GetSysFldType(RES_DBNEXTSETFLD);
1580 pFld = new SwDBNextSetField((SwDBNextSetFieldType*)pFldType,
1581 m_pProps->sPar3, aEmptyStr,
1582 aData);
1583 }
1584 break;
1585 case SW_SERVICE_FIELDTYPE_DATABASE_NUM_SET:
1586 {
1587 SwDBData aData;
1588 aData.sDataSource = m_pProps->sPar1;
1589 aData.sCommand = m_pProps->sPar2;
1590 aData.nCommandType = m_pProps->nSHORT1;
1591 pFld = new SwDBNumSetField( (SwDBNumSetFieldType*)
1592 pDoc->GetSysFldType(RES_DBNUMSETFLD),
1593 m_pProps->sPar3,
1594 String::CreateFromInt32(m_pProps->nFormat),
1595 aData );
1596 }
1597 break;
1598 case SW_SERVICE_FIELDTYPE_DATABASE_SET_NUM:
1599 {
1600 SwDBData aData;
1601 aData.sDataSource = m_pProps->sPar1;
1602 aData.sCommand = m_pProps->sPar2;
1603 aData.nCommandType = m_pProps->nSHORT1;
1604 pFld = new SwDBSetNumberField((SwDBSetNumberFieldType*)
1605 pDoc->GetSysFldType(RES_DBSETNUMBERFLD),
1606 aData,
1607 m_pProps->nUSHORT1);
1608 ((SwDBSetNumberField*)pFld)->SetSetNumber(m_pProps->nFormat);
1609 sal_uInt16 nSubType = pFld->GetSubType();
1610 if(m_pProps->bBool2)
1611 nSubType &= ~nsSwExtendedSubType::SUB_INVISIBLE;
1612 else
1613 nSubType |= nsSwExtendedSubType::SUB_INVISIBLE;
1614 pFld->SetSubType(nSubType);
1615 }
1616 break;
1617 case SW_SERVICE_FIELDTYPE_DATABASE:
1618 {
1619 SwFieldType* pFldType = pDoc->GetFldType(RES_DBFLD, m_sTypeName, sal_False);
1620 if(!pFldType)
1621 throw uno::RuntimeException();
1622 pFld = new SwDBField((SwDBFieldType*)pFldType, m_pProps->nFormat);
1623 ((SwDBField*)pFld)->InitContent(m_pProps->sPar1);
1624 sal_uInt16 nSubType = pFld->GetSubType();
1625 if(m_pProps->bBool2)
1626 nSubType &= ~nsSwExtendedSubType::SUB_INVISIBLE;
1627 else
1628 nSubType |= nsSwExtendedSubType::SUB_INVISIBLE;
1629 pFld->SetSubType(nSubType);
1630 }
1631 break;
1632 case SW_SERVICE_FIELDTYPE_SET_EXP:
1633 {
1634 SwFieldType* pFldType = pDoc->GetFldType(RES_SETEXPFLD, m_sTypeName, sal_True);
1635 if(!pFldType)
1636 throw uno::RuntimeException();
1637 //#93192# detect the field type's sub type and set an appropriate number format
1638 if(m_pProps->bFormatIsDefault &&
1639 nsSwGetSetExpType::GSE_STRING == ((SwSetExpFieldType*)pFldType)->GetType())
1640 m_pProps->nFormat = -1;
1641 pFld = new SwSetExpField((SwSetExpFieldType*)pFldType,
1642 m_pProps->sPar2,
1643 m_pProps->nUSHORT2 != USHRT_MAX ? //#i79471# the field can have a number format or a number_ing_ format
1644 m_pProps->nUSHORT2 : m_pProps->nFormat);
1645
1646 sal_uInt16 nSubType = pFld->GetSubType();
1647 if(m_pProps->bBool2)
1648 nSubType &= ~nsSwExtendedSubType::SUB_INVISIBLE;
1649 else
1650 nSubType |= nsSwExtendedSubType::SUB_INVISIBLE;
1651 if(m_pProps->bBool3)
1652 nSubType |= nsSwExtendedSubType::SUB_CMD;
1653 else
1654 nSubType &= ~nsSwExtendedSubType::SUB_CMD;
1655 pFld->SetSubType(nSubType);
1656 ((SwSetExpField*)pFld)->SetSeqNumber( m_pProps->nUSHORT1 );
1657 ((SwSetExpField*)pFld)->SetInputFlag(m_pProps->bBool1);
1658 ((SwSetExpField*)pFld)->SetPromptText(m_pProps->sPar3);
1659 if(m_pProps->sPar4.Len())
1660 ((SwSetExpField*)pFld)->ChgExpStr(m_pProps->sPar4);
1661
1662 }
1663 break;
1664 case SW_SERVICE_FIELDTYPE_GET_EXP:
1665 {
1666 sal_uInt16 nSubType;
1667 switch(m_pProps->nSubType)
1668 {
1669 case text::SetVariableType::STRING: nSubType = nsSwGetSetExpType::GSE_STRING; break;
1670 case text::SetVariableType::VAR: nSubType = nsSwGetSetExpType::GSE_EXPR; break;
1671 //case text::SetVariableType::SEQUENCE: nSubType = nsSwGetSetExpType::GSE_SEQ; break;
1672 case text::SetVariableType::FORMULA: nSubType = nsSwGetSetExpType::GSE_FORMULA; break;
1673 default:
1674 DBG_ERROR("wrong value");
1675 nSubType = nsSwGetSetExpType::GSE_EXPR;
1676 }
1677 //make sure the SubType matches the field type
1678 SwFieldType* pSetExpFld = pDoc->GetFldType(RES_SETEXPFLD, m_pProps->sPar1, sal_False);
1679 bool bSetGetExpFieldUninitialized = false;
1680 if( pSetExpFld )
1681 {
1682 if( nSubType != nsSwGetSetExpType::GSE_STRING &&
1683 static_cast< SwSetExpFieldType* >(pSetExpFld)->GetType() == nsSwGetSetExpType::GSE_STRING )
1684 nSubType = nsSwGetSetExpType::GSE_STRING;
1685 }
1686 else
1687 bSetGetExpFieldUninitialized = true; // #i82544#
1688
1689 if(m_pProps->bBool2)
1690 nSubType |= nsSwExtendedSubType::SUB_CMD;
1691 else
1692 nSubType &= ~nsSwExtendedSubType::SUB_CMD;
1693 pFld = new SwGetExpField((SwGetExpFieldType*)
1694 pDoc->GetSysFldType(RES_GETEXPFLD),
1695 m_pProps->sPar1, nSubType, m_pProps->nFormat);
1696 //TODO: SubType auswerten!
1697 if(m_pProps->sPar4.Len())
1698 ((SwGetExpField*)pFld)->ChgExpStr(m_pProps->sPar4);
1699 // #i82544#
1700 if( bSetGetExpFieldUninitialized )
1701 ((SwGetExpField*)pFld)->SetLateInitialization();
1702 }
1703 break;
1704 case SW_SERVICE_FIELDTYPE_INPUT_USER:
1705 case SW_SERVICE_FIELDTYPE_INPUT:
1706 {
1707 SwFieldType* pFldType = pDoc->GetFldType(RES_INPUTFLD, m_sTypeName, sal_True);
1708 if(!pFldType)
1709 throw uno::RuntimeException();
1710 USHORT nInpSubType = sal::static_int_cast< USHORT >(SW_SERVICE_FIELDTYPE_INPUT_USER == m_nServiceId ? INP_USR : INP_TXT);
1711 SwInputField * pTxtField =
1712 new SwInputField((SwInputFieldType*)pFldType,
1713 m_pProps->sPar1, m_pProps->sPar2,
1714 nInpSubType);
1715 pTxtField->SetHelp(m_pProps->sPar3);
1716 pTxtField->SetToolTip(m_pProps->sPar4);
1717
1718 pFld = pTxtField;
1719 }
1720 break;
1721 case SW_SERVICE_FIELDTYPE_MACRO:
1722 {
1723 SwFieldType* pFldType = pDoc->GetSysFldType(RES_MACROFLD);
1724 String aName;
1725
1726 // support for Scripting Framework macros
1727 if (m_pProps->sPar4.Len() != 0)
1728 {
1729 aName = m_pProps->sPar4;
1730 }
1731 else
1732 {
1733 SwMacroField::CreateMacroString(
1734 aName, m_pProps->sPar1, m_pProps->sPar3 );
1735 }
1736 pFld = new SwMacroField((SwMacroFieldType*)pFldType, aName,
1737 m_pProps->sPar2);
1738 }
1739 break;
1740 case SW_SERVICE_FIELDTYPE_PAGE_COUNT :
1741 case SW_SERVICE_FIELDTYPE_PARAGRAPH_COUNT :
1742 case SW_SERVICE_FIELDTYPE_WORD_COUNT :
1743 case SW_SERVICE_FIELDTYPE_CHARACTER_COUNT :
1744 case SW_SERVICE_FIELDTYPE_TABLE_COUNT :
1745 case SW_SERVICE_FIELDTYPE_GRAPHIC_OBJECT_COUNT :
1746 case SW_SERVICE_FIELDTYPE_EMBEDDED_OBJECT_COUNT :
1747 {
1748 sal_uInt16 nSubType = DS_PAGE;
1749 switch(m_nServiceId)
1750 {
1751 // case SW_SERVICE_FIELDTYPE_PAGE_COUNT : break;
1752 case SW_SERVICE_FIELDTYPE_PARAGRAPH_COUNT : nSubType = DS_PARA;break;
1753 case SW_SERVICE_FIELDTYPE_WORD_COUNT : nSubType = DS_WORD;break;
1754 case SW_SERVICE_FIELDTYPE_CHARACTER_COUNT : nSubType = DS_CHAR;break;
1755 case SW_SERVICE_FIELDTYPE_TABLE_COUNT : nSubType = DS_TBL;break;
1756 case SW_SERVICE_FIELDTYPE_GRAPHIC_OBJECT_COUNT : nSubType = DS_GRF;break;
1757 case SW_SERVICE_FIELDTYPE_EMBEDDED_OBJECT_COUNT : nSubType = DS_OLE;break;
1758 }
1759 SwFieldType* pFldType = pDoc->GetSysFldType(RES_DOCSTATFLD);
1760 pFld = new SwDocStatField((SwDocStatFieldType*)pFldType, nSubType, m_pProps->nUSHORT2);
1761 }
1762 break;
1763 case SW_SERVICE_FIELDTYPE_BIBLIOGRAPHY:
1764 pFld = new SwAuthorityField( (SwAuthorityFieldType*)
1765 pDoc->InsertFldType(SwAuthorityFieldType(pDoc)),
1766 aEmptyStr );
1767 if(m_pProps->aPropSeq.getLength())
1768 {
1769 uno::Any aVal; aVal <<= m_pProps->aPropSeq;
1770 pFld->PutValue( aVal, FIELD_PROP_PROP_SEQ );
1771 }
1772 break;
1773 case SW_SERVICE_FIELDTYPE_COMBINED_CHARACTERS:
1774 // create field
1775 pFld = new SwCombinedCharField( (SwCombinedCharFieldType*)
1776 pDoc->GetSysFldType(RES_COMBINED_CHARS),
1777 m_pProps->sPar1);
1778 break;
1779 case SW_SERVICE_FIELDTYPE_DROPDOWN:
1780 pFld = new SwDropDownField
1781 ((SwDropDownFieldType *)
1782 pDoc->GetSysFldType(RES_DROPDOWN));
1783
1784 ((SwDropDownField *) pFld)->SetItems(m_pProps->aStrings);
1785 ((SwDropDownField *) pFld)->SetSelectedItem(m_pProps->sPar1);
1786 ((SwDropDownField *) pFld)->SetName(m_pProps->sPar2);
1787 ((SwDropDownField *) pFld)->SetHelp(m_pProps->sPar3);
1788 ((SwDropDownField *) pFld)->SetToolTip(m_pProps->sPar4);
1789 break;
1790
1791 case SW_SERVICE_FIELDTYPE_TABLE_FORMULA :
1792 {
1793
1794 // create field
1795 USHORT nType = nsSwGetSetExpType::GSE_FORMULA;
1796 if(m_pProps->bBool1)
1797 {
1798 nType |= nsSwExtendedSubType::SUB_CMD;
1799 if(m_pProps->bFormatIsDefault)
1800 m_pProps->nFormat = -1;
1801 }
1802 pFld = new SwTblField( (SwTblFieldType*)
1803 pDoc->GetSysFldType(RES_TABLEFLD),
1804 m_pProps->sPar2,
1805 nType,
1806 m_pProps->nFormat);
1807 ((SwTblField*)pFld)->ChgExpStr(m_pProps->sPar1);
1808 }
1809 break;
1810 default: DBG_ERROR("was ist das fuer ein Typ?");
1811 }
1812 if(pFld)
1813 {
1814 pFld->SetAutomaticLanguage(!m_pProps->bBool4);
1815 SwFmtFld aFmt( *pFld );
1816
1817 UnoActionContext aCont(pDoc);
1818 SwTxtAttr* pTxtAttr = 0;
1819 if(aPam.HasMark())
1820 pDoc->DeleteAndJoin(aPam);
1821
1822 SwXTextCursor const*const pTextCursor(
1823 dynamic_cast<SwXTextCursor*>(pCursor));
1824 const bool bForceExpandHints( (pTextCursor)
1825 ? pTextCursor->IsAtEndOfMeta() : false );
1826 const SetAttrMode nInsertFlags = (bForceExpandHints)
1827 ? nsSetAttrMode::SETATTR_FORCEHINTEXPAND
1828 : nsSetAttrMode::SETATTR_DEFAULT;
1829
1830 pDoc->InsertPoolItem(aPam, aFmt, nInsertFlags);
1831
1832 pTxtAttr = aPam.GetNode()->GetTxtNode()->GetTxtAttrForCharAt(
1833 aPam.GetPoint()->nContent.GetIndex()-1, RES_TXTATR_FIELD);
1834
1835 // was passiert mit dem Update der Felder ? (siehe fldmgr.cxx)
1836 if(pTxtAttr)
1837 {
1838 const SwFmtFld& rFld = pTxtAttr->GetFld();
1839 pFmtFld = &rFld;
1840 }
1841 }
1842 delete pFld;
1843
1844 m_pDoc = pDoc;
1845 m_pDoc->GetUnoCallBack()->Add(this);
1846 m_bIsDescriptor = sal_False;
1847 if(m_aFieldTypeClient.GetRegisteredIn())
1848 const_cast<SwModify*>(m_aFieldTypeClient.GetRegisteredIn())->Remove(&m_aFieldTypeClient);
1849 DELETEZ(m_pProps);
1850 if(m_bCallUpdate)
1851 update();
1852 }
1853 else
1854 throw lang::IllegalArgumentException();
1855 }
1856 /*-- 14.12.98 11:37:18---------------------------------------------------
1857
1858 -----------------------------------------------------------------------*/
1859 void SwXTextField::attach(const uno::Reference< text::XTextRange > & xTextRange)
1860 throw( lang::IllegalArgumentException, uno::RuntimeException )
1861 {
1862 vos::OGuard aGuard(Application::GetSolarMutex());
1863 attachToRange( xTextRange );
1864 }
1865 /*-- 14.12.98 11:37:18---------------------------------------------------
1866
1867 -----------------------------------------------------------------------*/
1868 uno::Reference< text::XTextRange > SwXTextField::getAnchor(void) throw( uno::RuntimeException )
1869 {
1870 vos::OGuard aGuard(Application::GetSolarMutex());
1871 uno::Reference< text::XTextRange > aRef;
1872 SwField* pField = (SwField*)GetField();
1873 if(pField)
1874 {
1875 const SwTxtFld* pTxtFld = pFmtFld->GetTxtFld();
1876 if(!pTxtFld)
1877 throw uno::RuntimeException();
1878 const SwTxtNode& rTxtNode = pTxtFld->GetTxtNode();
1879
1880 SwPaM aPam(rTxtNode, *pTxtFld->GetStart() + 1, rTxtNode, *pTxtFld->GetStart());
1881
1882 aRef = SwXTextRange::CreateTextRangeFromPosition(m_pDoc,
1883 *aPam.GetPoint(), aPam.GetMark());
1884 }
1885 return aRef;
1886
1887 }
1888 /*-- 14.12.98 11:37:18---------------------------------------------------
1889
1890 -----------------------------------------------------------------------*/
1891 void SwXTextField::dispose(void) throw( uno::RuntimeException )
1892 {
1893 vos::OGuard aGuard(Application::GetSolarMutex());
1894 SwField* pField = (SwField*)GetField();
1895 if(pField)
1896 {
1897 UnoActionContext aContext(GetDoc());
1898 const SwTxtFld* pTxtFld = pFmtFld->GetTxtFld();
1899 SwTxtNode& rTxtNode = (SwTxtNode&)*pTxtFld->GetpTxtNode();
1900 SwPaM aPam(rTxtNode, *pTxtFld->GetStart());
1901 aPam.SetMark();
1902 aPam.Move();
1903 GetDoc()->DeleteAndJoin(aPam);
1904 }
1905
1906 if ( m_pTextObject )
1907 {
1908 m_pTextObject->DisposeEditSource();
1909 m_pTextObject->release();
1910 m_pTextObject = 0;
1911 }
1912 }
1913 /*-- 14.12.98 11:37:18---------------------------------------------------
1914
1915 -----------------------------------------------------------------------*/
1916 void SwXTextField::addEventListener(const uno::Reference< lang::XEventListener > & aListener) throw( uno::RuntimeException )
1917 {
1918 if(!GetRegisteredIn())
1919 throw uno::RuntimeException();
1920 aLstnrCntnr.AddListener(aListener);
1921 }
1922 /*-- 14.12.98 11:37:18---------------------------------------------------
1923
1924 -----------------------------------------------------------------------*/
1925 void SwXTextField::removeEventListener(const uno::Reference< lang::XEventListener > & aListener) throw( uno::RuntimeException )
1926 {
1927 if(!GetRegisteredIn() || !aLstnrCntnr.RemoveListener(aListener))
1928 throw uno::RuntimeException();
1929 }
1930 /*-- 14.12.98 11:37:19---------------------------------------------------
1931
1932 -----------------------------------------------------------------------*/
1933 uno::Reference< beans::XPropertySetInfo > SwXTextField::getPropertySetInfo(void)
1934 throw( uno::RuntimeException )
1935 {
1936 vos::OGuard aGuard(Application::GetSolarMutex());
1937 //kein static
1938 uno::Reference< beans::XPropertySetInfo > aRef;
1939 if(m_nServiceId != USHRT_MAX)
1940 {
1941 const SfxItemPropertySet* pPropSet = aSwMapProvider.GetPropertySet(
1942 lcl_GetPropertyMapOfService( m_nServiceId ));
1943 uno::Reference< beans::XPropertySetInfo > xInfo = pPropSet->getPropertySetInfo();
1944 // extend PropertySetInfo!
1945 const uno::Sequence<beans::Property> aPropSeq = xInfo->getProperties();
1946 aRef = new SfxExtItemPropertySetInfo(
1947 aSwMapProvider.GetPropertyMapEntries(PROPERTY_MAP_PARAGRAPH_EXTENSIONS),
1948 aPropSeq );
1949 }
1950 else
1951 throw uno::RuntimeException();
1952 return aRef;
1953 }
1954 /*-- 14.12.98 11:37:19---------------------------------------------------
1955
1956 -----------------------------------------------------------------------*/
1957 void SwXTextField::setPropertyValue(const OUString& rPropertyName, const uno::Any& rValue)
1958 throw( beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException,
1959 lang::WrappedTargetException, uno::RuntimeException )
1960 {
1961 vos::OGuard aGuard(Application::GetSolarMutex());
1962 SwField* pField = (SwField*)GetField();
1963 const SfxItemPropertySet* _pPropSet = aSwMapProvider.GetPropertySet(
1964 lcl_GetPropertyMapOfService( m_nServiceId));
1965 const SfxItemPropertySimpleEntry* pEntry = _pPropSet->getPropertyMap()->getByName(rPropertyName);
1966
1967 if (!pEntry)
1968 throw beans::UnknownPropertyException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) );
1969 if ( pEntry->nFlags & beans::PropertyAttribute::READONLY)
1970 throw beans::PropertyVetoException ( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Property is read-only: " ) ) + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) );
1971
1972 if(pField)
1973 {
1974 // Sonderbehandlung Serienbrieffeld
1975 sal_uInt16 nWhich = pField->Which();
1976 if( RES_DBFLD == nWhich &&
1977 (rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_DATA_BASE_NAME)) ||
1978 rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_DATA_BASE_URL))||
1979 rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_DATA_TABLE_NAME))||
1980 rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_DATA_COLUMN_NAME))))
1981 {
1982 // hier muss ein neuer Feldtyp angelegt werden und
1983 // das Feld an den neuen Typ umgehaengt werden
1984 DBG_WARNING("not implemented");
1985 }
1986 else
1987 {
1988 // -> #111840#
1989 SwDoc * pDoc = GetDoc();
1990
1991 if (NULL != pDoc)
1992 {
1993 const SwTxtFld* pTxtFld = pFmtFld->GetTxtFld();
1994 if(!pTxtFld)
1995 throw uno::RuntimeException();
1996 SwPosition aPosition( pTxtFld->GetTxtNode() );
1997 aPosition.nContent = *pTxtFld->GetStart();
1998 pDoc->PutValueToField( aPosition, rValue, pEntry->nWID);
1999 }
2000 // <- #111840#
2001 }
2002 pField->PutValue( rValue, pEntry->nWID );
2003
2004 //#i100374# notify SwPostIt about new field content
2005 if (RES_POSTITFLD== nWhich && pFmtFld)
2006 {
2007 const_cast<SwFmtFld*>(pFmtFld)->Broadcast(SwFmtFldHint( 0, SWFMTFLD_CHANGED ));
2008 }
2009
2010 //#114571# changes of the expanded string have to be notified
2011 //#to the SwTxtFld
2012 if(RES_DBFLD == nWhich && pFmtFld->GetTxtFld())
2013 {
2014 pFmtFld->GetTxtFld()->Expand();
2015 }
2016
2017 //#i100374# changing a document field should set the modify flag
2018 SwDoc* pDoc = GetDoc();
2019 if (pDoc)
2020 pDoc->SetModified();
2021
2022 }
2023 else if(m_pProps)
2024 {
2025 String* pStr = 0;
2026 BOOL* pBool = 0;
2027 switch(pEntry->nWID)
2028 {
2029 case FIELD_PROP_PAR1:
2030 pStr = &m_pProps->sPar1;
2031 break;
2032 case FIELD_PROP_PAR2:
2033 pStr = &m_pProps->sPar2;
2034 break;
2035 case FIELD_PROP_PAR3:
2036 pStr = &m_pProps->sPar3;
2037 break;
2038 case FIELD_PROP_PAR4:
2039 pStr = &m_pProps->sPar4;
2040 break;
2041 case FIELD_PROP_FORMAT:
2042 rValue >>= m_pProps->nFormat;
2043 m_pProps->bFormatIsDefault = sal_False;
2044 break;
2045 case FIELD_PROP_SUBTYPE:
2046 m_pProps->nSubType = SWUnoHelper::GetEnumAsInt32( rValue );
2047 break;
2048 case FIELD_PROP_BYTE1 :
2049 rValue >>= m_pProps->nByte1;
2050 break;
2051 case FIELD_PROP_BOOL1 :
2052 pBool = &m_pProps->bBool1;
2053 break;
2054 case FIELD_PROP_BOOL2 :
2055 pBool = &m_pProps->bBool2;
2056 break;
2057 case FIELD_PROP_BOOL3 :
2058 pBool = &m_pProps->bBool3;
2059 break;
2060 case FIELD_PROP_BOOL4:
2061 pBool = &m_pProps->bBool4;
2062 break;
2063 case FIELD_PROP_DATE :
2064 {
2065 if(rValue.getValueType() != ::getCppuType(static_cast<const util::Date*>(0)))
2066 throw lang::IllegalArgumentException();
2067
2068 util::Date aTemp = *(const util::Date*)rValue.getValue();
2069 m_pProps->aDate = Date(aTemp.Day, aTemp.Month, aTemp.Year);
2070 }
2071 break;
2072 case FIELD_PROP_USHORT1:
2073 case FIELD_PROP_USHORT2:
2074 {
2075 sal_Int16 nVal = 0;
2076 rValue >>= nVal;
2077 if( FIELD_PROP_USHORT1 == pEntry->nWID)
2078 m_pProps->nUSHORT1 = nVal;
2079 else
2080 m_pProps->nUSHORT2 = nVal;
2081 }
2082 break;
2083 case FIELD_PROP_SHORT1:
2084 rValue >>= m_pProps->nSHORT1;
2085 break;
2086 case FIELD_PROP_DOUBLE:
2087 if(rValue.getValueType() != ::getCppuType(static_cast<const double*>(0)))
2088 throw lang::IllegalArgumentException();
2089 m_pProps->fDouble = *(double*)rValue.getValue();
2090 break;
2091
2092 case FIELD_PROP_DATE_TIME :
2093 if(!m_pProps->pDateTime)
2094 m_pProps->pDateTime = new util::DateTime;
2095 rValue >>= (*m_pProps->pDateTime);
2096 break;
2097 case FIELD_PROP_PROP_SEQ:
2098 rValue >>= m_pProps->aPropSeq;
2099 break;
2100 case FIELD_PROP_STRINGS:
2101 rValue >>= m_pProps->aStrings;
2102 break;
2103 }
2104 if( pStr )
2105 ::GetString( rValue, *pStr );
2106 else if( pBool )
2107 {
2108 if( rValue.getValueType() == getCppuBooleanType() )
2109 *pBool = *(sal_Bool*)rValue.getValue();
2110 else
2111 throw lang::IllegalArgumentException();
2112 }
2113 }
2114 else
2115 throw uno::RuntimeException();
2116 }
2117 /*-- 14.12.98 11:37:19---------------------------------------------------
2118
2119 -----------------------------------------------------------------------*/
2120 uno::Any SwXTextField::getPropertyValue(const OUString& rPropertyName)
2121 throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
2122 {
2123 vos::OGuard aGuard(Application::GetSolarMutex());
2124 uno::Any aRet;
2125 const SwField* pField = GetField();
2126 const SfxItemPropertySet* _pPropSet = aSwMapProvider.GetPropertySet(
2127 lcl_GetPropertyMapOfService( m_nServiceId));
2128 const SfxItemPropertySimpleEntry* pEntry = _pPropSet->getPropertyMap()->getByName(rPropertyName);
2129 if(!pEntry )
2130 {
2131 const SfxItemPropertySet* _pParaPropSet = aSwMapProvider.GetPropertySet(PROPERTY_MAP_PARAGRAPH_EXTENSIONS);
2132 pEntry = _pParaPropSet->getPropertyMap()->getByName(rPropertyName);
2133 }
2134 if (!pEntry)
2135 throw beans::UnknownPropertyException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) );
2136
2137 switch( pEntry->nWID )
2138 {
2139 case FN_UNO_TEXT_WRAP:
2140 aRet <<= text::WrapTextMode_NONE;
2141 break;
2142 case FN_UNO_ANCHOR_TYPE:
2143 aRet <<= text::TextContentAnchorType_AS_CHARACTER;
2144 break;
2145 case FN_UNO_ANCHOR_TYPES:
2146 {
2147 uno::Sequence<text::TextContentAnchorType> aTypes(1);
2148 text::TextContentAnchorType* pArray = aTypes.getArray();
2149 pArray[0] = text::TextContentAnchorType_AS_CHARACTER;
2150 aRet.setValue(&aTypes, ::getCppuType(static_cast<uno::Sequence<text::TextContentAnchorType>*>(0)));
2151 }
2152 break;
2153
2154 default:
2155 if( pField )
2156 {
2157 if (FIELD_PROP_IS_FIELD_USED == pEntry->nWID ||
2158 FIELD_PROP_IS_FIELD_DISPLAYED == pEntry->nWID)
2159 {
2160 sal_Bool bIsFieldUsed = sal_False;
2161 sal_Bool bIsFieldDisplayed = sal_False;
2162
2163 // in order to have the information about fields
2164 // correctly evaluated the document needs a layout
2165 // (has to be already formatted)
2166 SwDoc *pDoc = GetDoc();
2167 ViewShell *pViewShell = 0;
2168 SwEditShell *pEditShell = pDoc ? pDoc->GetEditShell( &pViewShell ) : 0;
2169 if (pEditShell)
2170 pEditShell->CalcLayout();
2171 else if (pViewShell) // a page preview has no SwEditShell it should only have a view shell
2172 pViewShell->CalcLayout();
2173 else
2174 throw uno::RuntimeException();
2175
2176 // get text node for the text field
2177 const SwFmtFld *pFldFmt = GetFldFmt();
2178 const SwTxtFld* pTxtFld = pFldFmt ? pFmtFld->GetTxtFld() : 0;
2179 if(!pTxtFld)
2180 throw uno::RuntimeException();
2181 const SwTxtNode& rTxtNode = pTxtFld->GetTxtNode();
2182
2183 // skip fields that are currently not in the document
2184 // e.g. fields in undo or redo array
2185 if (rTxtNode.GetNodes().IsDocNodes())
2186 {
2187 sal_Bool bFrame = 0 != rTxtNode.FindLayoutRect().Width(); // oder so
2188 sal_Bool bHidden = rTxtNode.IsHidden();
2189 if ( !bHidden )
2190 {
2191 xub_StrLen nHiddenStart;
2192 xub_StrLen nHiddenEnd;
2193
2194 SwPosition aPosition( pTxtFld->GetTxtNode() );
2195 aPosition.nContent = *pTxtFld->GetStart();
2196
2197 bHidden = SwScriptInfo::GetBoundsOfHiddenRange( pTxtFld->GetTxtNode(),
2198 *pTxtFld->GetStart(),
2199 nHiddenStart, nHiddenEnd );
2200 }
2201
2202 // !bFrame && !bHidden: aller Wahrscheinlichkeit handelt es
2203 // sich um ein Feld in einem unbenutzten Seitenstyle
2204 //
2205 // bHidden: Feld ist versteckt
2206 // FME: Problem: Verstecktes Feld in unbenutzter Seitenvorlage =>
2207 // bIsFieldUsed = true
2208 // bIsFieldDisplayed = false
2209 bIsFieldUsed = bFrame || bHidden;
2210 bIsFieldDisplayed = bIsFieldUsed && !bHidden;
2211 }
2212 sal_Bool bRetVal = (FIELD_PROP_IS_FIELD_USED == pEntry->nWID) ?
2213 bIsFieldUsed : bIsFieldDisplayed;
2214 aRet.setValue( &bRetVal, ::getCppuBooleanType() );
2215 }
2216 else
2217 pField->QueryValue( aRet, pEntry->nWID );
2218 }
2219 else if( m_pProps ) // currently just a descriptor...
2220 {
2221 switch(pEntry->nWID)
2222 {
2223 case FIELD_PROP_TEXT:
2224 {
2225 if (!m_pTextObject)
2226 {
2227 SwTextAPIEditSource* pObj = new SwTextAPIEditSource( m_pDoc );
2228 m_pTextObject = new SwTextAPIObject( pObj );
2229 m_pTextObject->acquire();
2230 }
2231
2232 uno::Reference < text::XText > xText( m_pTextObject );
2233 aRet <<= xText;
2234 break;
2235 }
2236 case FIELD_PROP_PAR1:
2237 aRet <<= OUString(m_pProps->sPar1);
2238 break;
2239 case FIELD_PROP_PAR2:
2240 aRet <<= OUString(m_pProps->sPar2);
2241 break;
2242 case FIELD_PROP_PAR3:
2243 aRet <<= OUString(m_pProps->sPar3);
2244 break;
2245 case FIELD_PROP_PAR4:
2246 aRet <<= OUString(m_pProps->sPar4);
2247 break;
2248 case FIELD_PROP_FORMAT:
2249 aRet <<= m_pProps->nFormat;
2250 break;
2251 case FIELD_PROP_SUBTYPE:
2252 aRet <<= m_pProps->nSubType;
2253 break;
2254 case FIELD_PROP_BYTE1 :
2255 aRet <<= m_pProps->nByte1;
2256 break;
2257 case FIELD_PROP_BOOL1 :
2258 aRet.setValue(&m_pProps->bBool1, ::getCppuBooleanType());
2259 break;
2260 case FIELD_PROP_BOOL2 :
2261 aRet.setValue(&m_pProps->bBool2, ::getCppuBooleanType());
2262 break;
2263 case FIELD_PROP_BOOL3 :
2264 aRet.setValue(&m_pProps->bBool3, ::getCppuBooleanType());
2265 break;
2266 case FIELD_PROP_BOOL4 :
2267 aRet.setValue(&m_pProps->bBool4, ::getCppuBooleanType());
2268 break;
2269 case FIELD_PROP_DATE :
2270 aRet.setValue(&m_pProps->aDate, ::getCppuType(static_cast<const util::Date*>(0)));
2271 break;
2272 case FIELD_PROP_USHORT1:
2273 aRet <<= (sal_Int16)m_pProps->nUSHORT1;
2274 break;
2275 case FIELD_PROP_USHORT2:
2276 aRet <<= (sal_Int16)m_pProps->nUSHORT2;
2277 break;
2278 case FIELD_PROP_SHORT1:
2279 aRet <<= m_pProps->nSHORT1;
2280 break;
2281 case FIELD_PROP_DOUBLE:
2282 aRet <<= m_pProps->fDouble;
2283 break;
2284 case FIELD_PROP_DATE_TIME :
2285 if(m_pProps->pDateTime)
2286 aRet <<= (*m_pProps->pDateTime);
2287 break;
2288 case FIELD_PROP_PROP_SEQ:
2289 aRet <<= m_pProps->aPropSeq;
2290 break;
2291 case FIELD_PROP_STRINGS:
2292 aRet <<= m_pProps->aStrings;
2293 break;
2294 case FIELD_PROP_IS_FIELD_USED:
2295 case FIELD_PROP_IS_FIELD_DISPLAYED:
2296 aRet.setValue( sal_False, ::getCppuBooleanType() );
2297 break;
2298 }
2299 }
2300 else
2301 throw uno::RuntimeException();
2302 }
2303 return aRet;
2304 }
2305 /*-- 14.12.98 11:37:20---------------------------------------------------
2306
2307 -----------------------------------------------------------------------*/
2308 void SwXTextField::addPropertyChangeListener(const OUString& /*PropertyName*/, const uno::Reference< beans::XPropertyChangeListener > & /*aListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
2309 {
2310 DBG_WARNING("not implemented");
2311 }
2312 /*-- 14.12.98 11:37:20---------------------------------------------------
2313
2314 -----------------------------------------------------------------------*/
2315 void SwXTextField::removePropertyChangeListener(const OUString& /*PropertyName*/, const uno::Reference< beans::XPropertyChangeListener > & /*aListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
2316 {
2317 DBG_WARNING("not implemented");
2318 }
2319 /*-- 14.12.98 11:37:20---------------------------------------------------
2320
2321 -----------------------------------------------------------------------*/
2322 void SwXTextField::addVetoableChangeListener(const OUString& /*PropertyName*/, const uno::Reference< beans::XVetoableChangeListener > & /*aListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
2323 {
2324 DBG_WARNING("not implemented");
2325 }
2326 /*-- 14.12.98 11:37:20---------------------------------------------------
2327
2328 -----------------------------------------------------------------------*/
2329 void SwXTextField::removeVetoableChangeListener(const OUString& /*PropertyName*/, const uno::Reference< beans::XVetoableChangeListener > & /*aListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
2330 {
2331 DBG_WARNING("not implemented");
2332 }
2333 /* -----------------------------23.03.01 13:15--------------------------------
2334
2335 ---------------------------------------------------------------------------*/
2336 void SwXTextField::update( ) throw (uno::RuntimeException)
2337 {
2338 vos::OGuard aGuard(Application::GetSolarMutex());
2339 const SwField* pFld = GetField();
2340 if(pFld)
2341 {
2342 switch(pFld->Which())
2343 {
2344 case RES_DATETIMEFLD:
2345 ((SwDateTimeField*)pFld)->SetDateTime( ::DateTime() );
2346 break;
2347
2348 case RES_EXTUSERFLD:
2349 {
2350 SwExtUserField* pExtUserFld = (SwExtUserField*)pFld;
2351 pExtUserFld->SetExpansion( ((SwExtUserFieldType*)pFld->GetTyp())->Expand(
2352 pExtUserFld->GetSubType(),
2353 pExtUserFld->GetFormat() ) );
2354 }
2355 break;
2356
2357 case RES_AUTHORFLD:
2358 {
2359 SwAuthorField* pAuthorFld = (SwAuthorField*)pFld;
2360 pAuthorFld->SetExpansion( ((SwAuthorFieldType*)pFld->GetTyp())->Expand(
2361 pAuthorFld->GetFormat() ) );
2362 }
2363 break;
2364
2365 case RES_FILENAMEFLD:
2366 {
2367 SwFileNameField* pFileNameFld = (SwFileNameField*)pFld;
2368 pFileNameFld->SetExpansion( ((SwFileNameFieldType*)pFld->GetTyp())->Expand(
2369 pFileNameFld->GetFormat() ) );
2370 }
2371 break;
2372
2373 case RES_DOCINFOFLD:
2374 {
2375 SwDocInfoField* pDocInfFld = (SwDocInfoField*)pFld;
2376 pDocInfFld->SetExpansion( ((SwDocInfoFieldType*)pFld->GetTyp())->Expand(
2377 pDocInfFld->GetSubType(),
2378 pDocInfFld->GetFormat(),
2379 pDocInfFld->GetLanguage(),
2380 pDocInfFld->GetName() ) );
2381 }
2382 break;
2383 }
2384 // --> FME 2004-10-06 #116480#
2385 // Text formatting has to be triggered.
2386 const_cast<SwFmtFld*>(pFmtFld)->Modify( 0, 0 );
2387 // <--
2388 }
2389 else
2390 m_bCallUpdate = sal_True;
2391 }
2392 /* -----------------19.03.99 14:11-------------------
2393 *
2394 * --------------------------------------------------*/
2395 OUString SwXTextField::getImplementationName(void) throw( uno::RuntimeException )
2396 {
2397 return C2U("SwXTextField");
2398 }
2399 /* -----------------19.03.99 14:11-------------------
2400 *
2401 * --------------------------------------------------*/
2402
2403 static OUString OldNameToNewName_Impl( const OUString &rOld )
2404 {
2405 static OUString aOldNamePart1( OUString::createFromAscii(".TextField.DocInfo.") );
2406 static OUString aOldNamePart2( OUString::createFromAscii(".TextField.") );
2407 static OUString aNewNamePart1( OUString::createFromAscii(".textfield.docinfo.") );
2408 static OUString aNewNamePart2( OUString::createFromAscii(".textfield.") );
2409 OUString sServiceNameCC( rOld );
2410 sal_Int32 nIdx = sServiceNameCC.indexOf( aOldNamePart1 );
2411 if (nIdx >= 0)
2412 sServiceNameCC = sServiceNameCC.replaceAt( nIdx, aOldNamePart1.getLength(), aNewNamePart1 );
2413 nIdx = sServiceNameCC.indexOf( aOldNamePart2 );
2414 if (nIdx >= 0)
2415 sServiceNameCC = sServiceNameCC.replaceAt( nIdx, aOldNamePart2.getLength(), aNewNamePart2 );
2416 return sServiceNameCC;
2417 }
2418
2419 sal_Bool SwXTextField::supportsService(const OUString& rServiceName) throw( uno::RuntimeException )
2420 {
2421 OUString sServiceName = SwXServiceProvider::GetProviderName(m_nServiceId);
2422
2423 // case-corected version of service-name (see #i67811)
2424 // (need to supply both because of compatibility to older versions)
2425 OUString sServiceNameCC( OldNameToNewName_Impl( sServiceName ) );
2426
2427 return sServiceName == rServiceName || sServiceNameCC == rServiceName ||
2428 rServiceName.equalsAsciiL(
2429 RTL_CONSTASCII_STRINGPARAM("com.sun.star.text.TextContent"));
2430 }
2431 /* -----------------19.03.99 14:11-------------------
2432 *
2433 * --------------------------------------------------*/
2434 uno::Sequence< OUString > SwXTextField::getSupportedServiceNames(void) throw( uno::RuntimeException )
2435 {
2436 OUString sServiceName = SwXServiceProvider::GetProviderName(m_nServiceId);
2437
2438 // case-corected version of service-name (see #i67811)
2439 // (need to supply both because of compatibility to older versions)
2440 OUString sServiceNameCC( OldNameToNewName_Impl( sServiceName ) );
2441 sal_Int32 nLen = sServiceName == sServiceNameCC ? 2 : 3;
2442
2443 uno::Sequence< OUString > aRet( nLen );
2444 OUString* pArray = aRet.getArray();
2445 *pArray++ = sServiceName;
2446 if (nLen == 3)
2447 *pArray++ = sServiceNameCC;
2448 *pArray++ = C2U("com.sun.star.text.TextContent");
2449 return aRet;
2450 }
2451
2452 void SwXTextField::Invalidate()
2453 {
2454 if (GetRegisteredIn())
2455 {
2456 ((SwModify*)GetRegisteredIn())->Remove(this);
2457 aLstnrCntnr.Disposing();
2458 pFmtFld = 0;
2459 m_pDoc = 0;
2460 }
2461 }
2462
2463 /* -----------------14.12.98 12:00-------------------
2464 *
2465 * --------------------------------------------------*/
2466 void SwXTextField::Modify( SfxPoolItem *pOld, SfxPoolItem *pNew)
2467 {
2468 switch( pOld ? pOld->Which() : 0 )
2469 {
2470 case RES_REMOVE_UNO_OBJECT:
2471 case RES_OBJECTDYING:
2472 if( (void*)GetRegisteredIn() == ((SwPtrMsgPoolItem *)pOld)->pObject )
2473 Invalidate();
2474 break;
2475
2476 case RES_FMT_CHG:
2477 // wurden wir an das neue umgehaengt und wird das alte geloscht?
2478 if( ((SwFmtChg*)pNew)->pChangedFmt == GetRegisteredIn() &&
2479 ((SwFmtChg*)pOld)->pChangedFmt->IsFmtInDTOR() )
2480 Invalidate();
2481 break;
2482 case RES_FIELD_DELETED:
2483 if( (void*)pFmtFld == ((SwPtrMsgPoolItem *)pOld)->pObject )
2484 Invalidate();
2485 break;
2486 }
2487 }
2488 /*-- 14.12.98 11:37:21---------------------------------------------------
2489
2490 -----------------------------------------------------------------------*/
2491 const SwField* SwXTextField::GetField() const
2492 {
2493 if(GetRegisteredIn() && pFmtFld)
2494 return pFmtFld->GetFld();
2495 return 0;
2496 }
2497
2498 /******************************************************************
2499 *
2500 ******************************************************************/
2501 /******************************************************************
2502 * SwXTextFieldMasters
2503 ******************************************************************/
2504 /* -----------------------------06.04.00 13:22--------------------------------
2505
2506 ---------------------------------------------------------------------------*/
2507 OUString SwXTextFieldMasters::getImplementationName(void) throw( uno::RuntimeException )
2508 {
2509 return C2U("SwXTextFieldMasters");
2510 }
2511 /* -----------------------------06.04.00 13:22--------------------------------
2512
2513 ---------------------------------------------------------------------------*/
2514 BOOL SwXTextFieldMasters::supportsService(const OUString& rServiceName) throw( uno::RuntimeException )
2515 {
2516 return rServiceName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(
2517 "com.sun.star.text.TextFieldMasters" ));
2518 }
2519 /* -----------------------------06.04.00 13:22--------------------------------
2520
2521 ---------------------------------------------------------------------------*/
2522 uno::Sequence< OUString > SwXTextFieldMasters::getSupportedServiceNames(void) throw( uno::RuntimeException )
2523 {
2524 uno::Sequence< OUString > aRet(1);
2525 OUString* pArray = aRet.getArray();
2526 pArray[0] = C2U("com.sun.star.text.TextFieldMasters");
2527 return aRet;
2528 }
2529 /*-- 21.12.98 10:37:14---------------------------------------------------
2530
2531 -----------------------------------------------------------------------*/
2532 SwXTextFieldMasters::SwXTextFieldMasters(SwDoc* _pDoc) :
2533 SwUnoCollection(_pDoc)
2534 {
2535 }
2536 /*-- 21.12.98 10:37:32---------------------------------------------------
2537
2538 -----------------------------------------------------------------------*/
2539 SwXTextFieldMasters::~SwXTextFieldMasters()
2540 {
2541
2542 }
2543 /*-- 21.12.98 10:37:33---------------------------------------------------
2544 Iteration ueber nicht-Standard Feldtypen
2545 USER/SETEXP/DDE/DATABASE
2546 Der Name ist demnach:
2547 "com.sun.star.text.fieldmaster.User" + <Feltypname>
2548 "com.sun.star.text.fieldmaster.DDE" + <Feltypname>
2549 "com.sun.star.text.fieldmaster.SetExpression" + <Feltypname>
2550 "com.sun.star.text.fieldmaster.DataBase" + <Feltypname>
2551
2552 Falls wir grosszuegig werden wollen, dann koennte man com.sun.star.text
2553 auch optional weglassen
2554 -----------------------------------------------------------------------*/
2555
2556 sal_uInt16 lcl_GetIdByName( String& rName, String& rTypeName )
2557 {
2558 if( rName.EqualsAscii( COM_TEXT_FLDMASTER, 0, RTL_CONSTASCII_LENGTH(COM_TEXT_FLDMASTER ))
2559 || rName.EqualsAscii( COM_TEXT_FLDMASTER_CC, 0, RTL_CONSTASCII_LENGTH(COM_TEXT_FLDMASTER_CC )))
2560 rName.Erase(0, 30);
2561
2562 sal_uInt16 nResId = USHRT_MAX;
2563 xub_StrLen nFound = 0;
2564 rTypeName = rName.GetToken( 0, '.', nFound );
2565 if(rTypeName.EqualsAscii("User"))
2566 nResId = RES_USERFLD;
2567 else if(rTypeName.EqualsAscii("DDE"))
2568 nResId = RES_DDEFLD;
2569 else if(rTypeName.EqualsAscii("SetExpression"))
2570 {
2571 nResId = RES_SETEXPFLD;
2572
2573 String sFldTypName( rName.GetToken( 1, '.' ));
2574 String sUIName( SwStyleNameMapper::GetSpecialExtraUIName( sFldTypName ) );
2575
2576 if( sUIName != sFldTypName )
2577 rName.SetToken( 1, '.', sUIName );
2578 }
2579 else if(rTypeName.EqualsAscii("DataBase"))
2580 {
2581 rName.Erase( 0, RTL_CONSTASCII_LENGTH( "DataBase." ));
2582 USHORT nDotCount = rName.GetTokenCount('.');
2583 if( 2 <= nDotCount )
2584 {
2585 // #i51815#
2586 //rName.SearchAndReplace('.', DB_DELIM);
2587 //rName.SetChar( rName.SearchBackward( '.' ), DB_DELIM );
2588
2589 rName.InsertAscii( "DataBase.", 0 );
2590 nResId = RES_DBFLD;
2591 }
2592 }
2593 else if( rTypeName.EqualsAscii("Bibliography"))
2594 nResId = RES_AUTHORITY;
2595 return nResId;
2596 }
2597
2598 //-----------------------------------------------------------------------------
2599 uno::Any SwXTextFieldMasters::getByName(const OUString& rName)
2600 throw( container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException )
2601 {
2602 vos::OGuard aGuard(Application::GetSolarMutex());
2603 if(!GetDoc())
2604 throw uno::RuntimeException();
2605
2606 String sName(rName), sTypeName;
2607 sal_uInt16 nResId = lcl_GetIdByName( sName, sTypeName );
2608 if( USHRT_MAX == nResId )
2609 throw container::NoSuchElementException();
2610
2611 sName.Erase(0, sTypeName.Len()+1);
2612 SwFieldType* pType = GetDoc()->GetFldType(nResId, sName, sal_True);
2613 if(!pType)
2614 throw container::NoSuchElementException();
2615 SwXFieldMaster* pMaster = (SwXFieldMaster*)
2616 SwClientIter(*pType).First(TYPE(SwXFieldMaster));
2617 if(!pMaster)
2618 pMaster = new SwXFieldMaster(*pType, GetDoc());
2619 uno::Reference< beans::XPropertySet > aRef = pMaster;
2620 uno::Any aRet(&aRef, ::getCppuType( static_cast<const uno::Reference<beans::XPropertySet>* >(0)));
2621 return aRet;
2622 }
2623 /*-- 06.03.2001 11:29:34,5-------------------------------------------------
2624
2625 -----------------------------------------------------------------------*/
2626 sal_Bool SwXTextFieldMasters::getInstanceName(
2627 const SwFieldType& rFldType, String& rName)
2628 {
2629 sal_Bool bRet = sal_True;
2630 switch( rFldType.Which() )
2631 {
2632 case RES_USERFLD:
2633 rName.AppendAscii( RTL_CONSTASCII_STRINGPARAM( COM_TEXT_FLDMASTER_CC ));
2634 rName.AppendAscii( RTL_CONSTASCII_STRINGPARAM( "User."));
2635 rName += rFldType.GetName();
2636 break;
2637 case RES_DDEFLD:
2638 rName.AppendAscii( RTL_CONSTASCII_STRINGPARAM( COM_TEXT_FLDMASTER_CC ));
2639 rName.AppendAscii( RTL_CONSTASCII_STRINGPARAM( "DDE."));
2640 rName += rFldType.GetName();
2641 break;
2642
2643 case RES_SETEXPFLD:
2644 rName.AppendAscii( RTL_CONSTASCII_STRINGPARAM( COM_TEXT_FLDMASTER_CC ));
2645 rName.AppendAscii( RTL_CONSTASCII_STRINGPARAM( "SetExpression."));
2646 rName += String( SwStyleNameMapper::GetSpecialExtraProgName( rFldType.GetName() ) );
2647 break;
2648
2649 case RES_DBFLD:
2650 {
2651 rName.AppendAscii( RTL_CONSTASCII_STRINGPARAM( COM_TEXT_FLDMASTER_CC ));
2652 rName.AppendAscii( RTL_CONSTASCII_STRINGPARAM( "DataBase."));
2653 String sDBName(rFldType.GetName());
2654 sDBName.SearchAndReplaceAll(DB_DELIM, '.');
2655 rName += sDBName;
2656 }
2657 break;
2658
2659 case RES_AUTHORITY:
2660 rName.AppendAscii( RTL_CONSTASCII_STRINGPARAM( COM_TEXT_FLDMASTER_CC ));
2661 rName.AppendAscii( RTL_CONSTASCII_STRINGPARAM( "Bibliography"));
2662 break;
2663
2664 default:
2665 bRet = sal_False;
2666 }
2667
2668 return bRet;
2669 }
2670
2671
2672 /*-- 21.12.98 10:37:33---------------------------------------------------
2673
2674 -----------------------------------------------------------------------*/
2675 uno::Sequence< OUString > SwXTextFieldMasters::getElementNames(void)
2676 throw( uno::RuntimeException )
2677 {
2678 vos::OGuard aGuard(Application::GetSolarMutex());
2679 if(!GetDoc())
2680 throw uno::RuntimeException();
2681
2682 const SwFldTypes* pFldTypes = GetDoc()->GetFldTypes();
2683 sal_uInt16 nCount = pFldTypes->Count();
2684
2685 SvStrings aFldNames;
2686 String* pString = new String();
2687 sal_uInt16 i;
2688
2689 for( i = 0; i < nCount; i++)
2690 {
2691 SwFieldType& rFldType = *((*pFldTypes)[i]);
2692
2693 if (SwXTextFieldMasters::getInstanceName(rFldType, *pString))
2694 {
2695 aFldNames.Insert(pString, aFldNames.Count());
2696 pString = new String();
2697 }
2698 }
2699 delete pString;
2700
2701 uno::Sequence< OUString > aSeq(aFldNames.Count());
2702 OUString* pArray = aSeq.getArray();
2703 for(i = 0; i < aFldNames.Count();i++)
2704 {
2705 pArray[i] = *aFldNames.GetObject(i);
2706 }
2707 aFldNames.DeleteAndDestroy(0, aFldNames.Count());
2708
2709 return aSeq;
2710
2711 }
2712 /*-- 21.12.98 10:37:33---------------------------------------------------
2713
2714 -----------------------------------------------------------------------*/
2715 sal_Bool SwXTextFieldMasters::hasByName(const OUString& rName) throw( uno::RuntimeException )
2716 {
2717 vos::OGuard aGuard(Application::GetSolarMutex());
2718 if(!GetDoc())
2719 throw uno::RuntimeException();
2720
2721 String sName(rName), sTypeName;
2722 sal_uInt16 nResId = lcl_GetIdByName( sName, sTypeName );
2723 sal_Bool bRet = sal_False;
2724 if( USHRT_MAX != nResId )
2725 {
2726 sName.Erase(0, sTypeName.Len()+1);
2727 bRet = USHRT_MAX != nResId && 0 != GetDoc()->GetFldType(nResId, sName, sal_True);
2728 }
2729 return bRet;
2730 }
2731 /*-- 21.12.98 10:37:34---------------------------------------------------
2732
2733 -----------------------------------------------------------------------*/
2734 uno::Type SwXTextFieldMasters::getElementType(void) throw( uno::RuntimeException )
2735 {
2736 return ::getCppuType(static_cast<const uno::Reference<beans::XPropertySet>*>(0));
2737
2738 }
2739 /*-- 21.12.98 10:37:34---------------------------------------------------
2740
2741 -----------------------------------------------------------------------*/
2742 sal_Bool SwXTextFieldMasters::hasElements(void) throw( uno::RuntimeException )
2743 {
2744 vos::OGuard aGuard(Application::GetSolarMutex());
2745 if(!IsValid())
2746 throw uno::RuntimeException();
2747 return sal_True;
2748 }
2749
2750 /******************************************************************
2751 *
2752 ******************************************************************/
2753 /* -----------------------------06.04.00 13:24--------------------------------
2754
2755 ---------------------------------------------------------------------------*/
2756 OUString SwXTextFieldTypes::getImplementationName(void) throw( uno::RuntimeException )
2757 {
2758 return C2U("SwXTextFieldTypes");
2759 }
2760 /* -----------------------------06.04.00 13:24--------------------------------
2761
2762 ---------------------------------------------------------------------------*/
2763 BOOL SwXTextFieldTypes::supportsService(const OUString& rServiceName) throw( uno::RuntimeException )
2764 {
2765 return rServiceName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(
2766 "com.sun.star.text.TextFields" ));
2767 }
2768 /* -----------------------------06.04.00 13:24--------------------------------
2769
2770 ---------------------------------------------------------------------------*/
2771 uno::Sequence< OUString > SwXTextFieldTypes::getSupportedServiceNames(void) throw( uno::RuntimeException )
2772 {
2773 uno::Sequence< OUString > aRet(1);
2774 OUString* pArray = aRet.getArray();
2775 pArray[0] = C2U("com.sun.star.text.TextFields");
2776 return aRet;
2777 }
2778 /*-- 21.12.98 10:35:15---------------------------------------------------
2779
2780 -----------------------------------------------------------------------*/
2781 SwXTextFieldTypes::SwXTextFieldTypes(SwDoc* _pDoc) :
2782 SwUnoCollection (_pDoc),
2783 aRefreshCont ( static_cast< XEnumerationAccess * >(this) )
2784 {
2785 }
2786 /*-- 21.12.98 10:35:16---------------------------------------------------
2787
2788 -----------------------------------------------------------------------*/
2789 SwXTextFieldTypes::~SwXTextFieldTypes()
2790 {
2791 }
2792 /*-- 11.07.02 14:25:00---------------------------------------------------
2793
2794 -----------------------------------------------------------------------*/
2795 void SwXTextFieldTypes::Invalidate()
2796 {
2797 SwUnoCollection::Invalidate();
2798 aRefreshCont.Disposing();
2799 }
2800 /*-- 21.12.98 10:35:17---------------------------------------------------
2801
2802 -----------------------------------------------------------------------*/
2803 uno::Reference< container::XEnumeration > SwXTextFieldTypes::createEnumeration(void)
2804 throw( uno::RuntimeException )
2805 {
2806 vos::OGuard aGuard(Application::GetSolarMutex());
2807 if(!IsValid())
2808 throw uno::RuntimeException();
2809 return new SwXFieldEnumeration(GetDoc());
2810 }
2811
2812 /*-- 21.12.98 10:35:17---------------------------------------------------
2813
2814 -----------------------------------------------------------------------*/
2815 uno::Type SwXTextFieldTypes::getElementType(void) throw( uno::RuntimeException )
2816 {
2817 return ::getCppuType(static_cast<const uno::Reference<text::XDependentTextField>*>(0));
2818 }
2819 /*-- 21.12.98 10:35:17---------------------------------------------------
2820
2821 -----------------------------------------------------------------------*/
2822 sal_Bool SwXTextFieldTypes::hasElements(void) throw( uno::RuntimeException )
2823 {
2824 vos::OGuard aGuard(Application::GetSolarMutex());
2825 if(!IsValid())
2826 throw uno::RuntimeException();
2827 //es gibt sie immer
2828 return sal_True;
2829 }
2830 /* -----------------24.02.99 16:19-------------------
2831 *
2832 * --------------------------------------------------*/
2833 void SwXTextFieldTypes::refresh(void) throw( uno::RuntimeException )
2834 {
2835 vos::OGuard aGuard(Application::GetSolarMutex());
2836 if(!IsValid())
2837 throw uno::RuntimeException();
2838 UnoActionContext aContext(GetDoc());
2839 SwDocStat aDocStat;
2840 GetDoc()->UpdateDocStat(aDocStat);
2841 GetDoc()->UpdateFlds(0, sal_False);
2842
2843 // call refresh listeners
2844 aRefreshCont.Refreshed();
2845 }
2846 /* -----------------24.02.99 16:19-------------------
2847 *
2848 * --------------------------------------------------*/
2849 void SwXTextFieldTypes::addRefreshListener(const uno::Reference< util::XRefreshListener > & l)
2850 throw( uno::RuntimeException )
2851 {
2852 ::vos::OGuard aGuard(Application::GetSolarMutex());
2853 if ( !IsValid() )
2854 throw uno::RuntimeException();
2855 aRefreshCont.AddListener ( reinterpret_cast < const uno::Reference < lang::XEventListener > &> ( l ));
2856 }
2857 /* -----------------24.02.99 16:19-------------------
2858 *
2859 * --------------------------------------------------*/
2860 void SwXTextFieldTypes::removeRefreshListener(const uno::Reference< util::XRefreshListener > & l)
2861 throw( uno::RuntimeException )
2862 {
2863 ::vos::OGuard aGuard(Application::GetSolarMutex());
2864 if ( !IsValid() || !aRefreshCont.RemoveListener ( reinterpret_cast < const uno::Reference < lang::XEventListener > &> ( l ) ) )
2865 throw uno::RuntimeException();
2866 }
2867 /******************************************************************
2868 * SwXFieldEnumeration
2869 ******************************************************************/
2870 /* -----------------------------06.04.00 13:25--------------------------------
2871
2872 ---------------------------------------------------------------------------*/
2873 OUString SwXFieldEnumeration::getImplementationName(void) throw( uno::RuntimeException )
2874 {
2875 return C2U("SwXFieldEnumeration");
2876 }
2877 /* -----------------------------06.04.00 13:25--------------------------------
2878
2879 ---------------------------------------------------------------------------*/
2880 BOOL SwXFieldEnumeration::supportsService(const OUString& rServiceName) throw( uno::RuntimeException )
2881 {
2882 return rServiceName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(
2883 "com.sun.star.text.FieldEnumeration" ));
2884 }
2885 /* -----------------------------06.04.00 13:25--------------------------------
2886
2887 ---------------------------------------------------------------------------*/
2888 uno::Sequence< OUString > SwXFieldEnumeration::getSupportedServiceNames(void) throw( uno::RuntimeException )
2889 {
2890 uno::Sequence< OUString > aRet(1);
2891 OUString* pArray = aRet.getArray();
2892 pArray[0] = C2U("com.sun.star.text.FieldEnumeration");
2893 return aRet;
2894 }
2895 /* -----------------21.12.98 14:57-------------------
2896 *
2897 * --------------------------------------------------*/
2898 SwXFieldEnumeration::SwXFieldEnumeration(SwDoc* pDc) :
2899 nNextIndex(0),
2900 pDoc(pDc)
2901 {
2902 pDoc->GetPageDescFromPool(RES_POOLPAGE_STANDARD)->Add(this);
2903
2904 // build sequence
2905 sal_Int32 nSize = 32;
2906 aItems.realloc( nSize );
2907 uno::Reference< text::XTextField > *pItems = aItems.getArray();
2908 sal_Int32 nFillPos = 0;
2909 //
2910 const SwFldTypes* pFldTypes = pDoc->GetFldTypes();
2911 sal_uInt16 nCount = pFldTypes->Count();
2912 for(sal_uInt16 nType = 0; nType < nCount; ++nType)
2913 {
2914 const SwFieldType *pCurType = pFldTypes->GetObject(nType);
2915
2916 SwClientIter aIter( *(SwFieldType*)pCurType );
2917 const SwFmtFld* pCurFldFmt = (SwFmtFld*)aIter.First( TYPE( SwFmtFld ));
2918 while (pCurFldFmt)
2919 {
2920 const SwTxtFld *pTxtFld = pCurFldFmt->GetTxtFld();
2921 // skip fields that are currently not in the document
2922 // e.g. fields in undo or redo array
2923 BOOL bSkip = !pTxtFld ||
2924 !pTxtFld->GetpTxtNode()->GetNodes().IsDocNodes();
2925 if (!bSkip)
2926 pItems[ nFillPos++ ] = new SwXTextField(*pCurFldFmt, pDoc);
2927 pCurFldFmt = (SwFmtFld*)aIter.Next();
2928
2929 // enlarge sequence if necessary
2930 if (aItems.getLength() == nFillPos)
2931 {
2932 aItems.realloc( 2 * aItems.getLength() );
2933 pItems = aItems.getArray();
2934 }
2935 }
2936 }
2937 // now handle meta-fields, which are not SwFields
2938 const ::std::vector< uno::Reference<text::XTextField> > MetaFields(
2939 pDc->GetMetaFieldManager().getMetaFields() );
2940 for (size_t i = 0; i < MetaFields.size(); ++i)
2941 {
2942 pItems[ nFillPos ] = MetaFields[i];
2943 nFillPos++;
2944
2945 //FIXME UGLY
2946 // enlarge sequence if necessary
2947 if (aItems.getLength() == nFillPos)
2948 {
2949 aItems.realloc( 2 * aItems.getLength() );
2950 pItems = aItems.getArray();
2951 }
2952 }
2953 // resize sequence to actual used size
2954 aItems.realloc( nFillPos );
2955 }
2956 /*-- 21.12.98 14:57:23---------------------------------------------------
2957
2958 -----------------------------------------------------------------------*/
2959 SwXFieldEnumeration::~SwXFieldEnumeration()
2960 {
2961
2962 }
2963 /*-- 21.12.98 14:57:42---------------------------------------------------
2964
2965 -----------------------------------------------------------------------*/
2966 sal_Bool SwXFieldEnumeration::hasMoreElements(void)
2967 throw( uno::RuntimeException )
2968 {
2969 vos::OGuard aGuard(Application::GetSolarMutex());
2970 return nNextIndex < aItems.getLength();
2971 }
2972 /*-- 21.12.98 14:57:42---------------------------------------------------
2973
2974 -----------------------------------------------------------------------*/
2975 uno::Any SwXFieldEnumeration::nextElement(void)
2976 throw( container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException )
2977 {
2978 vos::OGuard aGuard(Application::GetSolarMutex());
2979
2980 if (!(nNextIndex < aItems.getLength()))
2981 throw container::NoSuchElementException();
2982
2983 #if OSL_DEBUG_LEVEL > 1
2984 uno::Reference< text::XTextField > *pItems = aItems.getArray();
2985 (void)pItems;
2986 #endif
2987 uno::Reference< text::XTextField > &rxFld = aItems.getArray()[ nNextIndex++ ];
2988 uno::Any aRet(&rxFld, ::getCppuType(static_cast<const uno::Reference<text::XTextField>*>(0)));
2989 rxFld = 0; // free memory for item that is not longer used
2990 return aRet;
2991 }
2992 /* -----------------21.12.98 15:08-------------------
2993 *
2994 * --------------------------------------------------*/
2995 void SwXFieldEnumeration::Modify( SfxPoolItem *pOld, SfxPoolItem *pNew)
2996 {
2997 ClientModify(this, pOld, pNew);
2998 if(!GetRegisteredIn())
2999 pDoc = 0;
3000 }
3001
3002
3003 String& GetString( const uno::Any& rAny, String& rStr )
3004 {
3005 OUString aStr;
3006 rAny >>= aStr;
3007 rStr = String( aStr );
3008 return rStr;
3009 }
vba interoperability for OOo