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