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