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