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