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