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