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