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.GetFld()->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->GetFld() ) ), 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->GetFld()->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((SwInputFieldType*)pFldType, 1626 m_pProps->sPar1, m_pProps->sPar2, 1627 nInpSubType); 1628 pTxtField->SetHelp(m_pProps->sPar3); 1629 pTxtField->SetToolTip(m_pProps->sPar4); 1630 1631 pFld = pTxtField; 1632 } 1633 break; 1634 case SW_SERVICE_FIELDTYPE_MACRO: 1635 { 1636 SwFieldType* pFldType = pDoc->GetSysFldType(RES_MACROFLD); 1637 String aName; 1638 1639 // support for Scripting Framework macros 1640 if (m_pProps->sPar4.Len() != 0) 1641 { 1642 aName = m_pProps->sPar4; 1643 } 1644 else 1645 { 1646 SwMacroField::CreateMacroString( 1647 aName, m_pProps->sPar1, m_pProps->sPar3 ); 1648 } 1649 pFld = new SwMacroField((SwMacroFieldType*)pFldType, aName, 1650 m_pProps->sPar2); 1651 } 1652 break; 1653 case SW_SERVICE_FIELDTYPE_PAGE_COUNT : 1654 case SW_SERVICE_FIELDTYPE_PARAGRAPH_COUNT : 1655 case SW_SERVICE_FIELDTYPE_WORD_COUNT : 1656 case SW_SERVICE_FIELDTYPE_CHARACTER_COUNT : 1657 case SW_SERVICE_FIELDTYPE_TABLE_COUNT : 1658 case SW_SERVICE_FIELDTYPE_GRAPHIC_OBJECT_COUNT : 1659 case SW_SERVICE_FIELDTYPE_EMBEDDED_OBJECT_COUNT : 1660 { 1661 sal_uInt16 nSubType = DS_PAGE; 1662 switch(m_nServiceId) 1663 { 1664 // case SW_SERVICE_FIELDTYPE_PAGE_COUNT : break; 1665 case SW_SERVICE_FIELDTYPE_PARAGRAPH_COUNT : nSubType = DS_PARA;break; 1666 case SW_SERVICE_FIELDTYPE_WORD_COUNT : nSubType = DS_WORD;break; 1667 case SW_SERVICE_FIELDTYPE_CHARACTER_COUNT : nSubType = DS_CHAR;break; 1668 case SW_SERVICE_FIELDTYPE_TABLE_COUNT : nSubType = DS_TBL;break; 1669 case SW_SERVICE_FIELDTYPE_GRAPHIC_OBJECT_COUNT : nSubType = DS_GRF;break; 1670 case SW_SERVICE_FIELDTYPE_EMBEDDED_OBJECT_COUNT : nSubType = DS_OLE;break; 1671 } 1672 SwFieldType* pFldType = pDoc->GetSysFldType(RES_DOCSTATFLD); 1673 pFld = new SwDocStatField((SwDocStatFieldType*)pFldType, nSubType, m_pProps->nUSHORT2); 1674 } 1675 break; 1676 case SW_SERVICE_FIELDTYPE_BIBLIOGRAPHY: 1677 pFld = new SwAuthorityField( (SwAuthorityFieldType*) 1678 pDoc->InsertFldType(SwAuthorityFieldType(pDoc)), 1679 aEmptyStr ); 1680 if(m_pProps->aPropSeq.getLength()) 1681 { 1682 uno::Any aVal; aVal <<= m_pProps->aPropSeq; 1683 pFld->PutValue( aVal, FIELD_PROP_PROP_SEQ ); 1684 } 1685 break; 1686 case SW_SERVICE_FIELDTYPE_COMBINED_CHARACTERS: 1687 // create field 1688 pFld = new SwCombinedCharField( (SwCombinedCharFieldType*) 1689 pDoc->GetSysFldType(RES_COMBINED_CHARS), 1690 m_pProps->sPar1); 1691 break; 1692 case SW_SERVICE_FIELDTYPE_DROPDOWN: 1693 pFld = new SwDropDownField 1694 ((SwDropDownFieldType *) 1695 pDoc->GetSysFldType(RES_DROPDOWN)); 1696 1697 ((SwDropDownField *) pFld)->SetItems(m_pProps->aStrings); 1698 ((SwDropDownField *) pFld)->SetSelectedItem(m_pProps->sPar1); 1699 ((SwDropDownField *) pFld)->SetName(m_pProps->sPar2); 1700 ((SwDropDownField *) pFld)->SetHelp(m_pProps->sPar3); 1701 ((SwDropDownField *) pFld)->SetToolTip(m_pProps->sPar4); 1702 break; 1703 1704 case SW_SERVICE_FIELDTYPE_TABLE_FORMULA : 1705 { 1706 1707 // create field 1708 sal_uInt16 nType = nsSwGetSetExpType::GSE_FORMULA; 1709 if(m_pProps->bBool1) 1710 { 1711 nType |= nsSwExtendedSubType::SUB_CMD; 1712 if(m_pProps->bFormatIsDefault) 1713 m_pProps->nFormat = -1; 1714 } 1715 pFld = new SwTblField( (SwTblFieldType*) 1716 pDoc->GetSysFldType(RES_TABLEFLD), 1717 m_pProps->sPar2, 1718 nType, 1719 m_pProps->nFormat); 1720 ((SwTblField*)pFld)->ChgExpStr(m_pProps->sPar1); 1721 } 1722 break; 1723 default: DBG_ERROR("was ist das fuer ein Typ?"); 1724 } 1725 if(pFld) 1726 { 1727 pFld->SetAutomaticLanguage(!m_pProps->bBool4); 1728 SwFmtFld aFmt( *pFld ); 1729 1730 UnoActionContext aCont(pDoc); 1731 SwTxtAttr* pTxtAttr = 0; 1732 if(aPam.HasMark()) 1733 pDoc->DeleteAndJoin(aPam); 1734 1735 SwXTextCursor const*const pTextCursor( 1736 dynamic_cast<SwXTextCursor*>(pCursor)); 1737 const bool bForceExpandHints( (pTextCursor) 1738 ? pTextCursor->IsAtEndOfMeta() : false ); 1739 const SetAttrMode nInsertFlags = (bForceExpandHints) 1740 ? nsSetAttrMode::SETATTR_FORCEHINTEXPAND 1741 : nsSetAttrMode::SETATTR_DEFAULT; 1742 1743 pDoc->InsertPoolItem(aPam, aFmt, nInsertFlags); 1744 1745 pTxtAttr = aPam.GetNode()->GetTxtNode()->GetTxtAttrForCharAt( 1746 aPam.GetPoint()->nContent.GetIndex()-1, RES_TXTATR_FIELD); 1747 1748 // was passiert mit dem Update der Felder ? (siehe fldmgr.cxx) 1749 if(pTxtAttr) 1750 { 1751 const SwFmtFld& rFld = pTxtAttr->GetFld(); 1752 pFmtFld = &rFld; 1753 } 1754 } 1755 delete pFld; 1756 1757 m_pDoc = pDoc; 1758 m_pDoc->GetUnoCallBack()->Add(this); 1759 m_bIsDescriptor = sal_False; 1760 if(m_aFieldTypeClient.GetRegisteredIn()) 1761 const_cast<SwModify*>(m_aFieldTypeClient.GetRegisteredIn())->Remove(&m_aFieldTypeClient); 1762 DELETEZ(m_pProps); 1763 if(m_bCallUpdate) 1764 update(); 1765 } 1766 else 1767 throw lang::IllegalArgumentException(); 1768 } 1769 1770 void SwXTextField::attach(const uno::Reference< text::XTextRange > & xTextRange) 1771 throw( lang::IllegalArgumentException, uno::RuntimeException ) 1772 { 1773 vos::OGuard aGuard(Application::GetSolarMutex()); 1774 attachToRange( xTextRange ); 1775 } 1776 1777 uno::Reference< text::XTextRange > SwXTextField::getAnchor(void) throw( uno::RuntimeException ) 1778 { 1779 vos::OGuard aGuard(Application::GetSolarMutex()); 1780 uno::Reference< text::XTextRange > aRef; 1781 SwField* pField = (SwField*)GetField(); 1782 if(pField) 1783 { 1784 const SwTxtFld* pTxtFld = pFmtFld->GetTxtFld(); 1785 if(!pTxtFld) 1786 throw uno::RuntimeException(); 1787 const SwTxtNode& rTxtNode = pTxtFld->GetTxtNode(); 1788 1789 SwPaM aPam(rTxtNode, *pTxtFld->GetStart() + 1, rTxtNode, *pTxtFld->GetStart()); 1790 1791 aRef = SwXTextRange::CreateXTextRange( 1792 *m_pDoc, *aPam.GetPoint(), aPam.GetMark()); 1793 } 1794 return aRef; 1795 1796 } 1797 1798 void SwXTextField::dispose(void) throw( uno::RuntimeException ) 1799 { 1800 vos::OGuard aGuard(Application::GetSolarMutex()); 1801 SwField* pField = (SwField*)GetField(); 1802 if(pField) 1803 { 1804 UnoActionContext aContext(GetDoc()); 1805 const SwTxtFld* pTxtFld = pFmtFld->GetTxtFld(); 1806 SwTxtNode& rTxtNode = (SwTxtNode&)*pTxtFld->GetpTxtNode(); 1807 SwPaM aPam(rTxtNode, *pTxtFld->GetStart()); 1808 aPam.SetMark(); 1809 aPam.Move(); 1810 GetDoc()->DeleteAndJoin(aPam); 1811 } 1812 1813 if ( m_pTextObject ) 1814 { 1815 m_pTextObject->DisposeEditSource(); 1816 m_pTextObject->release(); 1817 m_pTextObject = 0; 1818 } 1819 } 1820 1821 void SwXTextField::addEventListener(const uno::Reference< lang::XEventListener > & aListener) throw( uno::RuntimeException ) 1822 { 1823 if(!GetRegisteredIn()) 1824 throw uno::RuntimeException(); 1825 aLstnrCntnr.AddListener(aListener); 1826 } 1827 1828 void SwXTextField::removeEventListener(const uno::Reference< lang::XEventListener > & aListener) throw( uno::RuntimeException ) 1829 { 1830 if(!GetRegisteredIn() || !aLstnrCntnr.RemoveListener(aListener)) 1831 throw uno::RuntimeException(); 1832 } 1833 1834 uno::Reference< beans::XPropertySetInfo > SwXTextField::getPropertySetInfo(void) 1835 throw( uno::RuntimeException ) 1836 { 1837 vos::OGuard aGuard(Application::GetSolarMutex()); 1838 //kein static 1839 uno::Reference< beans::XPropertySetInfo > aRef; 1840 if(m_nServiceId != USHRT_MAX) 1841 { 1842 const SfxItemPropertySet* pPropSet = aSwMapProvider.GetPropertySet( 1843 lcl_GetPropertyMapOfService( m_nServiceId )); 1844 uno::Reference< beans::XPropertySetInfo > xInfo = pPropSet->getPropertySetInfo(); 1845 // extend PropertySetInfo! 1846 const uno::Sequence<beans::Property> aPropSeq = xInfo->getProperties(); 1847 aRef = new SfxExtItemPropertySetInfo( 1848 aSwMapProvider.GetPropertyMapEntries(PROPERTY_MAP_PARAGRAPH_EXTENSIONS), 1849 aPropSeq ); 1850 } 1851 else 1852 throw uno::RuntimeException(); 1853 return aRef; 1854 } 1855 1856 void SwXTextField::setPropertyValue(const OUString& rPropertyName, const uno::Any& rValue) 1857 throw( beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, 1858 lang::WrappedTargetException, uno::RuntimeException ) 1859 { 1860 vos::OGuard aGuard(Application::GetSolarMutex()); 1861 SwField* pField = (SwField*)GetField(); 1862 const SfxItemPropertySet* _pPropSet = aSwMapProvider.GetPropertySet( 1863 lcl_GetPropertyMapOfService( m_nServiceId)); 1864 const SfxItemPropertySimpleEntry* pEntry = _pPropSet->getPropertyMap()->getByName(rPropertyName); 1865 1866 if (!pEntry) 1867 throw beans::UnknownPropertyException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) ); 1868 if ( pEntry->nFlags & beans::PropertyAttribute::READONLY) 1869 throw beans::PropertyVetoException ( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Property is read-only: " ) ) + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) ); 1870 1871 if(pField) 1872 { 1873 // Sonderbehandlung Serienbrieffeld 1874 sal_uInt16 nWhich = pField->Which(); 1875 if( RES_DBFLD == nWhich && 1876 (rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_DATA_BASE_NAME)) || 1877 rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_DATA_BASE_URL))|| 1878 rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_DATA_TABLE_NAME))|| 1879 rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_DATA_COLUMN_NAME)))) 1880 { 1881 // hier muss ein neuer Feldtyp angelegt werden und 1882 // das Feld an den neuen Typ umgehaengt werden 1883 DBG_WARNING("not implemented"); 1884 } 1885 else 1886 { 1887 // -> #111840# 1888 SwDoc * pDoc = GetDoc(); 1889 1890 if (NULL != pDoc) 1891 { 1892 const SwTxtFld* pTxtFld = pFmtFld->GetTxtFld(); 1893 if(!pTxtFld) 1894 throw uno::RuntimeException(); 1895 SwPosition aPosition( pTxtFld->GetTxtNode() ); 1896 aPosition.nContent = *pTxtFld->GetStart(); 1897 pDoc->PutValueToField( aPosition, rValue, pEntry->nWID); 1898 } 1899 // <- #111840# 1900 } 1901 pField->PutValue( rValue, pEntry->nWID ); 1902 1903 //#i100374# notify SwPostIt about new field content 1904 if (RES_POSTITFLD== nWhich && pFmtFld) 1905 { 1906 const_cast<SwFmtFld*>(pFmtFld)->Broadcast(SwFmtFldHint( 0, SWFMTFLD_CHANGED )); 1907 } 1908 1909 //#114571# changes of the expanded string have to be notified 1910 //#to the SwTxtFld 1911 if(RES_DBFLD == nWhich && pFmtFld->GetTxtFld()) 1912 { 1913 pFmtFld->GetTxtFld()->Expand(); 1914 } 1915 1916 //#i100374# changing a document field should set the modify flag 1917 SwDoc* pDoc = GetDoc(); 1918 if (pDoc) 1919 pDoc->SetModified(); 1920 1921 } 1922 else if(m_pProps) 1923 { 1924 String* pStr = 0; 1925 sal_Bool* pBool = 0; 1926 switch(pEntry->nWID) 1927 { 1928 case FIELD_PROP_PAR1: 1929 pStr = &m_pProps->sPar1; 1930 break; 1931 case FIELD_PROP_PAR2: 1932 pStr = &m_pProps->sPar2; 1933 break; 1934 case FIELD_PROP_PAR3: 1935 pStr = &m_pProps->sPar3; 1936 break; 1937 case FIELD_PROP_PAR4: 1938 pStr = &m_pProps->sPar4; 1939 break; 1940 case FIELD_PROP_FORMAT: 1941 rValue >>= m_pProps->nFormat; 1942 m_pProps->bFormatIsDefault = sal_False; 1943 break; 1944 case FIELD_PROP_SUBTYPE: 1945 m_pProps->nSubType = SWUnoHelper::GetEnumAsInt32( rValue ); 1946 break; 1947 case FIELD_PROP_BYTE1 : 1948 rValue >>= m_pProps->nByte1; 1949 break; 1950 case FIELD_PROP_BOOL1 : 1951 pBool = &m_pProps->bBool1; 1952 break; 1953 case FIELD_PROP_BOOL2 : 1954 pBool = &m_pProps->bBool2; 1955 break; 1956 case FIELD_PROP_BOOL3 : 1957 pBool = &m_pProps->bBool3; 1958 break; 1959 case FIELD_PROP_BOOL4: 1960 pBool = &m_pProps->bBool4; 1961 break; 1962 case FIELD_PROP_DATE : 1963 { 1964 if(rValue.getValueType() != ::getCppuType(static_cast<const util::Date*>(0))) 1965 throw lang::IllegalArgumentException(); 1966 1967 util::Date aTemp = *(const util::Date*)rValue.getValue(); 1968 m_pProps->aDate = Date(aTemp.Day, aTemp.Month, aTemp.Year); 1969 } 1970 break; 1971 case FIELD_PROP_USHORT1: 1972 case FIELD_PROP_USHORT2: 1973 { 1974 sal_Int16 nVal = 0; 1975 rValue >>= nVal; 1976 if( FIELD_PROP_USHORT1 == pEntry->nWID) 1977 m_pProps->nUSHORT1 = nVal; 1978 else 1979 m_pProps->nUSHORT2 = nVal; 1980 } 1981 break; 1982 case FIELD_PROP_SHORT1: 1983 rValue >>= m_pProps->nSHORT1; 1984 break; 1985 case FIELD_PROP_DOUBLE: 1986 if(rValue.getValueType() != ::getCppuType(static_cast<const double*>(0))) 1987 throw lang::IllegalArgumentException(); 1988 m_pProps->fDouble = *(double*)rValue.getValue(); 1989 break; 1990 1991 case FIELD_PROP_DATE_TIME : 1992 if(!m_pProps->pDateTime) 1993 m_pProps->pDateTime = new util::DateTime; 1994 rValue >>= (*m_pProps->pDateTime); 1995 break; 1996 case FIELD_PROP_PROP_SEQ: 1997 rValue >>= m_pProps->aPropSeq; 1998 break; 1999 case FIELD_PROP_STRINGS: 2000 rValue >>= m_pProps->aStrings; 2001 break; 2002 } 2003 if( pStr ) 2004 ::GetString( rValue, *pStr ); 2005 else if( pBool ) 2006 { 2007 if( rValue.getValueType() == getCppuBooleanType() ) 2008 *pBool = *(sal_Bool*)rValue.getValue(); 2009 else 2010 throw lang::IllegalArgumentException(); 2011 } 2012 } 2013 else 2014 throw uno::RuntimeException(); 2015 } 2016 2017 uno::Any SwXTextField::getPropertyValue(const OUString& rPropertyName) 2018 throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException ) 2019 { 2020 vos::OGuard aGuard(Application::GetSolarMutex()); 2021 uno::Any aRet; 2022 const SwField* pField = GetField(); 2023 const SfxItemPropertySet* _pPropSet = aSwMapProvider.GetPropertySet( 2024 lcl_GetPropertyMapOfService( m_nServiceId)); 2025 const SfxItemPropertySimpleEntry* pEntry = _pPropSet->getPropertyMap()->getByName(rPropertyName); 2026 if(!pEntry ) 2027 { 2028 const SfxItemPropertySet* _pParaPropSet = aSwMapProvider.GetPropertySet(PROPERTY_MAP_PARAGRAPH_EXTENSIONS); 2029 pEntry = _pParaPropSet->getPropertyMap()->getByName(rPropertyName); 2030 } 2031 if (!pEntry) 2032 throw beans::UnknownPropertyException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) ); 2033 2034 switch( pEntry->nWID ) 2035 { 2036 case FN_UNO_TEXT_WRAP: 2037 aRet <<= text::WrapTextMode_NONE; 2038 break; 2039 case FN_UNO_ANCHOR_TYPE: 2040 aRet <<= text::TextContentAnchorType_AS_CHARACTER; 2041 break; 2042 case FN_UNO_ANCHOR_TYPES: 2043 { 2044 uno::Sequence<text::TextContentAnchorType> aTypes(1); 2045 text::TextContentAnchorType* pArray = aTypes.getArray(); 2046 pArray[0] = text::TextContentAnchorType_AS_CHARACTER; 2047 aRet.setValue(&aTypes, ::getCppuType(static_cast<uno::Sequence<text::TextContentAnchorType>*>(0))); 2048 } 2049 break; 2050 2051 default: 2052 if( pField ) 2053 { 2054 if (FIELD_PROP_IS_FIELD_USED == pEntry->nWID || 2055 FIELD_PROP_IS_FIELD_DISPLAYED == pEntry->nWID) 2056 { 2057 sal_Bool bIsFieldUsed = sal_False; 2058 sal_Bool bIsFieldDisplayed = sal_False; 2059 2060 // in order to have the information about fields 2061 // correctly evaluated the document needs a layout 2062 // (has to be already formatted) 2063 SwDoc *pDoc = GetDoc(); 2064 ViewShell *pViewShell = 0; 2065 SwEditShell *pEditShell = pDoc ? pDoc->GetEditShell( &pViewShell ) : 0; 2066 if (pEditShell) 2067 pEditShell->CalcLayout(); 2068 else if (pViewShell) // a page preview has no SwEditShell it should only have a view shell 2069 pViewShell->CalcLayout(); 2070 else 2071 throw uno::RuntimeException(); 2072 2073 // get text node for the text field 2074 const SwFmtFld *pFldFmt = GetFldFmt(); 2075 const SwTxtFld* pTxtFld = pFldFmt ? pFmtFld->GetTxtFld() : 0; 2076 if(!pTxtFld) 2077 throw uno::RuntimeException(); 2078 const SwTxtNode& rTxtNode = pTxtFld->GetTxtNode(); 2079 2080 // skip fields that are currently not in the document 2081 // e.g. fields in undo or redo array 2082 if (rTxtNode.GetNodes().IsDocNodes()) 2083 { 2084 sal_Bool bFrame = 0 != rTxtNode.FindLayoutRect().Width(); // oder so 2085 sal_Bool bHidden = rTxtNode.IsHidden(); 2086 if ( !bHidden ) 2087 { 2088 xub_StrLen nHiddenStart; 2089 xub_StrLen nHiddenEnd; 2090 2091 SwPosition aPosition( pTxtFld->GetTxtNode() ); 2092 aPosition.nContent = *pTxtFld->GetStart(); 2093 2094 bHidden = SwScriptInfo::GetBoundsOfHiddenRange( pTxtFld->GetTxtNode(), 2095 *pTxtFld->GetStart(), 2096 nHiddenStart, nHiddenEnd ); 2097 } 2098 2099 // !bFrame && !bHidden: aller Wahrscheinlichkeit handelt es 2100 // sich um ein Feld in einem unbenutzten Seitenstyle 2101 // 2102 // bHidden: Feld ist versteckt 2103 // FME: Problem: Verstecktes Feld in unbenutzter Seitenvorlage => 2104 // bIsFieldUsed = true 2105 // bIsFieldDisplayed = false 2106 bIsFieldUsed = bFrame || bHidden; 2107 bIsFieldDisplayed = bIsFieldUsed && !bHidden; 2108 } 2109 sal_Bool bRetVal = (FIELD_PROP_IS_FIELD_USED == pEntry->nWID) ? 2110 bIsFieldUsed : bIsFieldDisplayed; 2111 aRet.setValue( &bRetVal, ::getCppuBooleanType() ); 2112 } 2113 else 2114 pField->QueryValue( aRet, pEntry->nWID ); 2115 } 2116 else if( m_pProps ) // currently just a descriptor... 2117 { 2118 switch(pEntry->nWID) 2119 { 2120 case FIELD_PROP_TEXT: 2121 { 2122 if (!m_pTextObject) 2123 { 2124 SwTextAPIEditSource* pObj = new SwTextAPIEditSource( m_pDoc ); 2125 m_pTextObject = new SwTextAPIObject( pObj ); 2126 m_pTextObject->acquire(); 2127 } 2128 2129 uno::Reference < text::XText > xText( m_pTextObject ); 2130 aRet <<= xText; 2131 break; 2132 } 2133 case FIELD_PROP_PAR1: 2134 aRet <<= OUString(m_pProps->sPar1); 2135 break; 2136 case FIELD_PROP_PAR2: 2137 aRet <<= OUString(m_pProps->sPar2); 2138 break; 2139 case FIELD_PROP_PAR3: 2140 aRet <<= OUString(m_pProps->sPar3); 2141 break; 2142 case FIELD_PROP_PAR4: 2143 aRet <<= OUString(m_pProps->sPar4); 2144 break; 2145 case FIELD_PROP_FORMAT: 2146 aRet <<= m_pProps->nFormat; 2147 break; 2148 case FIELD_PROP_SUBTYPE: 2149 aRet <<= m_pProps->nSubType; 2150 break; 2151 case FIELD_PROP_BYTE1 : 2152 aRet <<= m_pProps->nByte1; 2153 break; 2154 case FIELD_PROP_BOOL1 : 2155 aRet.setValue(&m_pProps->bBool1, ::getCppuBooleanType()); 2156 break; 2157 case FIELD_PROP_BOOL2 : 2158 aRet.setValue(&m_pProps->bBool2, ::getCppuBooleanType()); 2159 break; 2160 case FIELD_PROP_BOOL3 : 2161 aRet.setValue(&m_pProps->bBool3, ::getCppuBooleanType()); 2162 break; 2163 case FIELD_PROP_BOOL4 : 2164 aRet.setValue(&m_pProps->bBool4, ::getCppuBooleanType()); 2165 break; 2166 case FIELD_PROP_DATE : 2167 aRet.setValue(&m_pProps->aDate, ::getCppuType(static_cast<const util::Date*>(0))); 2168 break; 2169 case FIELD_PROP_USHORT1: 2170 aRet <<= (sal_Int16)m_pProps->nUSHORT1; 2171 break; 2172 case FIELD_PROP_USHORT2: 2173 aRet <<= (sal_Int16)m_pProps->nUSHORT2; 2174 break; 2175 case FIELD_PROP_SHORT1: 2176 aRet <<= m_pProps->nSHORT1; 2177 break; 2178 case FIELD_PROP_DOUBLE: 2179 aRet <<= m_pProps->fDouble; 2180 break; 2181 case FIELD_PROP_DATE_TIME : 2182 if(m_pProps->pDateTime) 2183 aRet <<= (*m_pProps->pDateTime); 2184 break; 2185 case FIELD_PROP_PROP_SEQ: 2186 aRet <<= m_pProps->aPropSeq; 2187 break; 2188 case FIELD_PROP_STRINGS: 2189 aRet <<= m_pProps->aStrings; 2190 break; 2191 case FIELD_PROP_IS_FIELD_USED: 2192 case FIELD_PROP_IS_FIELD_DISPLAYED: 2193 aRet.setValue( sal_False, ::getCppuBooleanType() ); 2194 break; 2195 } 2196 } 2197 else 2198 throw uno::RuntimeException(); 2199 } 2200 return aRet; 2201 } 2202 2203 void SwXTextField::addPropertyChangeListener(const OUString& /*PropertyName*/, const uno::Reference< beans::XPropertyChangeListener > & /*aListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException ) 2204 { 2205 DBG_WARNING("not implemented"); 2206 } 2207 2208 void SwXTextField::removePropertyChangeListener(const OUString& /*PropertyName*/, const uno::Reference< beans::XPropertyChangeListener > & /*aListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException ) 2209 { 2210 DBG_WARNING("not implemented"); 2211 } 2212 2213 void SwXTextField::addVetoableChangeListener(const OUString& /*PropertyName*/, const uno::Reference< beans::XVetoableChangeListener > & /*aListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException ) 2214 { 2215 DBG_WARNING("not implemented"); 2216 } 2217 2218 void SwXTextField::removeVetoableChangeListener(const OUString& /*PropertyName*/, const uno::Reference< beans::XVetoableChangeListener > & /*aListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException ) 2219 { 2220 DBG_WARNING("not implemented"); 2221 } 2222 2223 void SwXTextField::update( ) throw (uno::RuntimeException) 2224 { 2225 vos::OGuard aGuard(Application::GetSolarMutex()); 2226 const SwField* pFld = GetField(); 2227 if(pFld) 2228 { 2229 switch(pFld->Which()) 2230 { 2231 case RES_DATETIMEFLD: 2232 ((SwDateTimeField*)pFld)->SetDateTime( ::DateTime() ); 2233 break; 2234 2235 case RES_EXTUSERFLD: 2236 { 2237 SwExtUserField* pExtUserFld = (SwExtUserField*)pFld; 2238 pExtUserFld->SetExpansion( ((SwExtUserFieldType*)pFld->GetTyp())->Expand( 2239 pExtUserFld->GetSubType(), 2240 pExtUserFld->GetFormat() ) ); 2241 } 2242 break; 2243 2244 case RES_AUTHORFLD: 2245 { 2246 SwAuthorField* pAuthorFld = (SwAuthorField*)pFld; 2247 pAuthorFld->SetExpansion( ((SwAuthorFieldType*)pFld->GetTyp())->Expand( 2248 pAuthorFld->GetFormat() ) ); 2249 } 2250 break; 2251 2252 case RES_FILENAMEFLD: 2253 { 2254 SwFileNameField* pFileNameFld = (SwFileNameField*)pFld; 2255 pFileNameFld->SetExpansion( ((SwFileNameFieldType*)pFld->GetTyp())->Expand( 2256 pFileNameFld->GetFormat() ) ); 2257 } 2258 break; 2259 2260 case RES_DOCINFOFLD: 2261 { 2262 SwDocInfoField* pDocInfFld = (SwDocInfoField*)pFld; 2263 pDocInfFld->SetExpansion( ((SwDocInfoFieldType*)pFld->GetTyp())->Expand( 2264 pDocInfFld->GetSubType(), 2265 pDocInfFld->GetFormat(), 2266 pDocInfFld->GetLanguage(), 2267 pDocInfFld->GetName() ) ); 2268 } 2269 break; 2270 } 2271 // --> FME 2004-10-06 #116480# 2272 // Text formatting has to be triggered. 2273 const_cast<SwFmtFld*>(pFmtFld)->ModifyNotification( 0, 0 ); 2274 // <-- 2275 } 2276 else 2277 m_bCallUpdate = sal_True; 2278 } 2279 2280 OUString SwXTextField::getImplementationName(void) throw( uno::RuntimeException ) 2281 { 2282 return C2U("SwXTextField"); 2283 } 2284 2285 static OUString OldNameToNewName_Impl( const OUString &rOld ) 2286 { 2287 static OUString aOldNamePart1( OUString::createFromAscii(".TextField.DocInfo.") ); 2288 static OUString aOldNamePart2( OUString::createFromAscii(".TextField.") ); 2289 static OUString aNewNamePart1( OUString::createFromAscii(".textfield.docinfo.") ); 2290 static OUString aNewNamePart2( OUString::createFromAscii(".textfield.") ); 2291 OUString sServiceNameCC( rOld ); 2292 sal_Int32 nIdx = sServiceNameCC.indexOf( aOldNamePart1 ); 2293 if (nIdx >= 0) 2294 sServiceNameCC = sServiceNameCC.replaceAt( nIdx, aOldNamePart1.getLength(), aNewNamePart1 ); 2295 nIdx = sServiceNameCC.indexOf( aOldNamePart2 ); 2296 if (nIdx >= 0) 2297 sServiceNameCC = sServiceNameCC.replaceAt( nIdx, aOldNamePart2.getLength(), aNewNamePart2 ); 2298 return sServiceNameCC; 2299 } 2300 2301 sal_Bool SwXTextField::supportsService(const OUString& rServiceName) throw( uno::RuntimeException ) 2302 { 2303 OUString sServiceName = SwXServiceProvider::GetProviderName(m_nServiceId); 2304 2305 // case-corected version of service-name (see #i67811) 2306 // (need to supply both because of compatibility to older versions) 2307 OUString sServiceNameCC( OldNameToNewName_Impl( sServiceName ) ); 2308 2309 return sServiceName == rServiceName || sServiceNameCC == rServiceName || 2310 rServiceName.equalsAsciiL( 2311 RTL_CONSTASCII_STRINGPARAM("com.sun.star.text.TextContent")); 2312 } 2313 2314 uno::Sequence< OUString > SwXTextField::getSupportedServiceNames(void) throw( uno::RuntimeException ) 2315 { 2316 OUString sServiceName = SwXServiceProvider::GetProviderName(m_nServiceId); 2317 2318 // case-corected version of service-name (see #i67811) 2319 // (need to supply both because of compatibility to older versions) 2320 OUString sServiceNameCC( OldNameToNewName_Impl( sServiceName ) ); 2321 sal_Int32 nLen = sServiceName == sServiceNameCC ? 2 : 3; 2322 2323 uno::Sequence< OUString > aRet( nLen ); 2324 OUString* pArray = aRet.getArray(); 2325 *pArray++ = sServiceName; 2326 if (nLen == 3) 2327 *pArray++ = sServiceNameCC; 2328 *pArray++ = C2U("com.sun.star.text.TextContent"); 2329 return aRet; 2330 } 2331 2332 void SwXTextField::Invalidate() 2333 { 2334 if (GetRegisteredIn()) 2335 { 2336 ((SwModify*)GetRegisteredIn())->Remove(this); 2337 aLstnrCntnr.Disposing(); 2338 pFmtFld = 0; 2339 m_pDoc = 0; 2340 } 2341 } 2342 2343 2344 void SwXTextField::Modify( const SfxPoolItem* pOld, const SfxPoolItem *pNew) 2345 { 2346 switch( pOld ? pOld->Which() : 0 ) 2347 { 2348 case RES_REMOVE_UNO_OBJECT: 2349 case RES_OBJECTDYING: 2350 if( (void*)GetRegisteredIn() == ((SwPtrMsgPoolItem *)pOld)->pObject ) 2351 Invalidate(); 2352 break; 2353 2354 case RES_FMT_CHG: 2355 // wurden wir an das neue umgehaengt und wird das alte geloscht? 2356 if( ((SwFmtChg*)pNew)->pChangedFmt == GetRegisteredIn() && 2357 ((SwFmtChg*)pOld)->pChangedFmt->IsFmtInDTOR() ) 2358 Invalidate(); 2359 break; 2360 case RES_FIELD_DELETED: 2361 if( (void*)pFmtFld == ((SwPtrMsgPoolItem *)pOld)->pObject ) 2362 Invalidate(); 2363 break; 2364 } 2365 } 2366 2367 const SwField* SwXTextField::GetField() const 2368 { 2369 if(GetRegisteredIn() && pFmtFld) 2370 return pFmtFld->GetFld(); 2371 return 0; 2372 } 2373 2374 /****************************************************************** 2375 * SwXTextFieldMasters 2376 ******************************************************************/ 2377 OUString SwXTextFieldMasters::getImplementationName(void) throw( uno::RuntimeException ) 2378 { 2379 return C2U("SwXTextFieldMasters"); 2380 } 2381 2382 sal_Bool SwXTextFieldMasters::supportsService(const OUString& rServiceName) throw( uno::RuntimeException ) 2383 { 2384 return rServiceName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( 2385 "com.sun.star.text.TextFieldMasters" )); 2386 } 2387 2388 uno::Sequence< OUString > SwXTextFieldMasters::getSupportedServiceNames(void) throw( uno::RuntimeException ) 2389 { 2390 uno::Sequence< OUString > aRet(1); 2391 OUString* pArray = aRet.getArray(); 2392 pArray[0] = C2U("com.sun.star.text.TextFieldMasters"); 2393 return aRet; 2394 } 2395 2396 SwXTextFieldMasters::SwXTextFieldMasters(SwDoc* _pDoc) : 2397 SwUnoCollection(_pDoc) 2398 { 2399 } 2400 2401 SwXTextFieldMasters::~SwXTextFieldMasters() 2402 { 2403 2404 } 2405 /*----------------------------------------------------------------------- 2406 Iteration ueber nicht-Standard Feldtypen 2407 USER/SETEXP/DDE/DATABASE 2408 Der Name ist demnach: 2409 "com.sun.star.text.fieldmaster.User" + <Feltypname> 2410 "com.sun.star.text.fieldmaster.DDE" + <Feltypname> 2411 "com.sun.star.text.fieldmaster.SetExpression" + <Feltypname> 2412 "com.sun.star.text.fieldmaster.DataBase" + <Feltypname> 2413 2414 Falls wir grosszuegig werden wollen, dann koennte man com.sun.star.text 2415 auch optional weglassen 2416 -----------------------------------------------------------------------*/ 2417 2418 sal_uInt16 lcl_GetIdByName( String& rName, String& rTypeName ) 2419 { 2420 if( rName.EqualsAscii( COM_TEXT_FLDMASTER, 0, RTL_CONSTASCII_LENGTH(COM_TEXT_FLDMASTER )) 2421 || rName.EqualsAscii( COM_TEXT_FLDMASTER_CC, 0, RTL_CONSTASCII_LENGTH(COM_TEXT_FLDMASTER_CC ))) 2422 rName.Erase(0, 30); 2423 2424 sal_uInt16 nResId = USHRT_MAX; 2425 xub_StrLen nFound = 0; 2426 rTypeName = rName.GetToken( 0, '.', nFound ); 2427 if(rTypeName.EqualsAscii("User")) 2428 nResId = RES_USERFLD; 2429 else if(rTypeName.EqualsAscii("DDE")) 2430 nResId = RES_DDEFLD; 2431 else if(rTypeName.EqualsAscii("SetExpression")) 2432 { 2433 nResId = RES_SETEXPFLD; 2434 2435 String sFldTypName( rName.GetToken( 1, '.' )); 2436 String sUIName( SwStyleNameMapper::GetSpecialExtraUIName( sFldTypName ) ); 2437 2438 if( sUIName != sFldTypName ) 2439 rName.SetToken( 1, '.', sUIName ); 2440 } 2441 else if(rTypeName.EqualsAscii("DataBase")) 2442 { 2443 rName.Erase( 0, RTL_CONSTASCII_LENGTH( "DataBase." )); 2444 sal_uInt16 nDotCount = rName.GetTokenCount('.'); 2445 if( 2 <= nDotCount ) 2446 { 2447 // #i51815# 2448 //rName.SearchAndReplace('.', DB_DELIM); 2449 //rName.SetChar( rName.SearchBackward( '.' ), DB_DELIM ); 2450 2451 rName.InsertAscii( "DataBase.", 0 ); 2452 nResId = RES_DBFLD; 2453 } 2454 } 2455 else if( rTypeName.EqualsAscii("Bibliography")) 2456 nResId = RES_AUTHORITY; 2457 return nResId; 2458 } 2459 2460 //----------------------------------------------------------------------------- 2461 uno::Any SwXTextFieldMasters::getByName(const OUString& rName) 2462 throw( container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException ) 2463 { 2464 vos::OGuard aGuard(Application::GetSolarMutex()); 2465 if(!GetDoc()) 2466 throw uno::RuntimeException(); 2467 2468 String sName(rName), sTypeName; 2469 sal_uInt16 nResId = lcl_GetIdByName( sName, sTypeName ); 2470 if( USHRT_MAX == nResId ) 2471 throw container::NoSuchElementException(); 2472 2473 sName.Erase(0, sTypeName.Len()+1); 2474 SwFieldType* pType = GetDoc()->GetFldType(nResId, sName, sal_True); 2475 if(!pType) 2476 throw container::NoSuchElementException(); 2477 SwXFieldMaster* pMaster = SwIterator<SwXFieldMaster,SwFieldType>::FirstElement( *pType ); 2478 if(!pMaster) 2479 pMaster = new SwXFieldMaster(*pType, GetDoc()); 2480 uno::Reference< beans::XPropertySet > aRef = pMaster; 2481 uno::Any aRet(&aRef, ::getCppuType( static_cast<const uno::Reference<beans::XPropertySet>* >(0))); 2482 return aRet; 2483 } 2484 2485 sal_Bool SwXTextFieldMasters::getInstanceName( 2486 const SwFieldType& rFldType, String& rName) 2487 { 2488 sal_Bool bRet = sal_True; 2489 switch( rFldType.Which() ) 2490 { 2491 case RES_USERFLD: 2492 rName.AppendAscii( RTL_CONSTASCII_STRINGPARAM( COM_TEXT_FLDMASTER_CC )); 2493 rName.AppendAscii( RTL_CONSTASCII_STRINGPARAM( "User.")); 2494 rName += rFldType.GetName(); 2495 break; 2496 case RES_DDEFLD: 2497 rName.AppendAscii( RTL_CONSTASCII_STRINGPARAM( COM_TEXT_FLDMASTER_CC )); 2498 rName.AppendAscii( RTL_CONSTASCII_STRINGPARAM( "DDE.")); 2499 rName += rFldType.GetName(); 2500 break; 2501 2502 case RES_SETEXPFLD: 2503 rName.AppendAscii( RTL_CONSTASCII_STRINGPARAM( COM_TEXT_FLDMASTER_CC )); 2504 rName.AppendAscii( RTL_CONSTASCII_STRINGPARAM( "SetExpression.")); 2505 rName += String( SwStyleNameMapper::GetSpecialExtraProgName( rFldType.GetName() ) ); 2506 break; 2507 2508 case RES_DBFLD: 2509 { 2510 rName.AppendAscii( RTL_CONSTASCII_STRINGPARAM( COM_TEXT_FLDMASTER_CC )); 2511 rName.AppendAscii( RTL_CONSTASCII_STRINGPARAM( "DataBase.")); 2512 String sDBName(rFldType.GetName()); 2513 sDBName.SearchAndReplaceAll(DB_DELIM, '.'); 2514 rName += sDBName; 2515 } 2516 break; 2517 2518 case RES_AUTHORITY: 2519 rName.AppendAscii( RTL_CONSTASCII_STRINGPARAM( COM_TEXT_FLDMASTER_CC )); 2520 rName.AppendAscii( RTL_CONSTASCII_STRINGPARAM( "Bibliography")); 2521 break; 2522 2523 default: 2524 bRet = sal_False; 2525 } 2526 2527 return bRet; 2528 } 2529 2530 2531 uno::Sequence< OUString > SwXTextFieldMasters::getElementNames(void) 2532 throw( uno::RuntimeException ) 2533 { 2534 vos::OGuard aGuard(Application::GetSolarMutex()); 2535 if(!GetDoc()) 2536 throw uno::RuntimeException(); 2537 2538 const SwFldTypes* pFldTypes = GetDoc()->GetFldTypes(); 2539 sal_uInt16 nCount = pFldTypes->Count(); 2540 2541 SvStrings aFldNames; 2542 String* pString = new String(); 2543 sal_uInt16 i; 2544 2545 for( i = 0; i < nCount; i++) 2546 { 2547 SwFieldType& rFldType = *((*pFldTypes)[i]); 2548 2549 if (SwXTextFieldMasters::getInstanceName(rFldType, *pString)) 2550 { 2551 aFldNames.Insert(pString, aFldNames.Count()); 2552 pString = new String(); 2553 } 2554 } 2555 delete pString; 2556 2557 uno::Sequence< OUString > aSeq(aFldNames.Count()); 2558 OUString* pArray = aSeq.getArray(); 2559 for(i = 0; i < aFldNames.Count();i++) 2560 { 2561 pArray[i] = *aFldNames.GetObject(i); 2562 } 2563 aFldNames.DeleteAndDestroy(0, aFldNames.Count()); 2564 2565 return aSeq; 2566 2567 } 2568 2569 sal_Bool SwXTextFieldMasters::hasByName(const OUString& rName) throw( uno::RuntimeException ) 2570 { 2571 vos::OGuard aGuard(Application::GetSolarMutex()); 2572 if(!GetDoc()) 2573 throw uno::RuntimeException(); 2574 2575 String sName(rName), sTypeName; 2576 sal_uInt16 nResId = lcl_GetIdByName( sName, sTypeName ); 2577 sal_Bool bRet = sal_False; 2578 if( USHRT_MAX != nResId ) 2579 { 2580 sName.Erase(0, sTypeName.Len()+1); 2581 bRet = USHRT_MAX != nResId && 0 != GetDoc()->GetFldType(nResId, sName, sal_True); 2582 } 2583 return bRet; 2584 } 2585 2586 uno::Type SwXTextFieldMasters::getElementType(void) throw( uno::RuntimeException ) 2587 { 2588 return ::getCppuType(static_cast<const uno::Reference<beans::XPropertySet>*>(0)); 2589 2590 } 2591 2592 sal_Bool SwXTextFieldMasters::hasElements(void) throw( uno::RuntimeException ) 2593 { 2594 vos::OGuard aGuard(Application::GetSolarMutex()); 2595 if(!IsValid()) 2596 throw uno::RuntimeException(); 2597 return sal_True; 2598 } 2599 2600 /****************************************************************** 2601 * 2602 ******************************************************************/ 2603 2604 OUString SwXTextFieldTypes::getImplementationName(void) throw( uno::RuntimeException ) 2605 { 2606 return C2U("SwXTextFieldTypes"); 2607 } 2608 2609 sal_Bool SwXTextFieldTypes::supportsService(const OUString& rServiceName) throw( uno::RuntimeException ) 2610 { 2611 return rServiceName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( 2612 "com.sun.star.text.TextFields" )); 2613 } 2614 2615 uno::Sequence< OUString > SwXTextFieldTypes::getSupportedServiceNames(void) throw( uno::RuntimeException ) 2616 { 2617 uno::Sequence< OUString > aRet(1); 2618 OUString* pArray = aRet.getArray(); 2619 pArray[0] = C2U("com.sun.star.text.TextFields"); 2620 return aRet; 2621 } 2622 2623 SwXTextFieldTypes::SwXTextFieldTypes(SwDoc* _pDoc) : 2624 SwUnoCollection (_pDoc), 2625 aRefreshCont ( static_cast< XEnumerationAccess * >(this) ) 2626 { 2627 } 2628 2629 SwXTextFieldTypes::~SwXTextFieldTypes() 2630 { 2631 } 2632 2633 void SwXTextFieldTypes::Invalidate() 2634 { 2635 SwUnoCollection::Invalidate(); 2636 aRefreshCont.Disposing(); 2637 } 2638 2639 uno::Reference< container::XEnumeration > SwXTextFieldTypes::createEnumeration(void) 2640 throw( uno::RuntimeException ) 2641 { 2642 vos::OGuard aGuard(Application::GetSolarMutex()); 2643 if(!IsValid()) 2644 throw uno::RuntimeException(); 2645 return new SwXFieldEnumeration(GetDoc()); 2646 } 2647 2648 2649 uno::Type SwXTextFieldTypes::getElementType(void) throw( uno::RuntimeException ) 2650 { 2651 return ::getCppuType(static_cast<const uno::Reference<text::XDependentTextField>*>(0)); 2652 } 2653 2654 sal_Bool SwXTextFieldTypes::hasElements(void) throw( uno::RuntimeException ) 2655 { 2656 vos::OGuard aGuard(Application::GetSolarMutex()); 2657 if(!IsValid()) 2658 throw uno::RuntimeException(); 2659 //es gibt sie immer 2660 return sal_True; 2661 } 2662 2663 void SwXTextFieldTypes::refresh(void) throw( uno::RuntimeException ) 2664 { 2665 vos::OGuard aGuard(Application::GetSolarMutex()); 2666 if(!IsValid()) 2667 throw uno::RuntimeException(); 2668 UnoActionContext aContext(GetDoc()); 2669 SwDocStat aDocStat; 2670 GetDoc()->UpdateDocStat(aDocStat); 2671 GetDoc()->UpdateFlds(0, sal_False); 2672 2673 // call refresh listeners 2674 aRefreshCont.Refreshed(); 2675 } 2676 2677 void SwXTextFieldTypes::addRefreshListener(const uno::Reference< util::XRefreshListener > & l) 2678 throw( uno::RuntimeException ) 2679 { 2680 ::vos::OGuard aGuard(Application::GetSolarMutex()); 2681 if ( !IsValid() ) 2682 throw uno::RuntimeException(); 2683 aRefreshCont.AddListener ( reinterpret_cast < const uno::Reference < lang::XEventListener > &> ( l )); 2684 } 2685 2686 void SwXTextFieldTypes::removeRefreshListener(const uno::Reference< util::XRefreshListener > & l) 2687 throw( uno::RuntimeException ) 2688 { 2689 ::vos::OGuard aGuard(Application::GetSolarMutex()); 2690 if ( !IsValid() || !aRefreshCont.RemoveListener ( reinterpret_cast < const uno::Reference < lang::XEventListener > &> ( l ) ) ) 2691 throw uno::RuntimeException(); 2692 } 2693 /****************************************************************** 2694 * SwXFieldEnumeration 2695 ******************************************************************/ 2696 2697 OUString SwXFieldEnumeration::getImplementationName(void) throw( uno::RuntimeException ) 2698 { 2699 return C2U("SwXFieldEnumeration"); 2700 } 2701 2702 sal_Bool SwXFieldEnumeration::supportsService(const OUString& rServiceName) throw( uno::RuntimeException ) 2703 { 2704 return rServiceName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( 2705 "com.sun.star.text.FieldEnumeration" )); 2706 } 2707 2708 uno::Sequence< OUString > SwXFieldEnumeration::getSupportedServiceNames(void) throw( uno::RuntimeException ) 2709 { 2710 uno::Sequence< OUString > aRet(1); 2711 OUString* pArray = aRet.getArray(); 2712 pArray[0] = C2U("com.sun.star.text.FieldEnumeration"); 2713 return aRet; 2714 } 2715 2716 SwXFieldEnumeration::SwXFieldEnumeration(SwDoc* pDc) : 2717 nNextIndex(0), 2718 pDoc(pDc) 2719 { 2720 pDoc->GetPageDescFromPool(RES_POOLPAGE_STANDARD)->Add(this); 2721 2722 // build sequence 2723 sal_Int32 nSize = 32; 2724 aItems.realloc( nSize ); 2725 uno::Reference< text::XTextField > *pItems = aItems.getArray(); 2726 sal_Int32 nFillPos = 0; 2727 // 2728 const SwFldTypes* pFldTypes = pDoc->GetFldTypes(); 2729 sal_uInt16 nCount = pFldTypes->Count(); 2730 for(sal_uInt16 nType = 0; nType < nCount; ++nType) 2731 { 2732 const SwFieldType *pCurType = pFldTypes->GetObject(nType); 2733 SwIterator<SwFmtFld,SwFieldType> aIter( *pCurType ); 2734 const SwFmtFld* pCurFldFmt = aIter.First(); 2735 while (pCurFldFmt) 2736 { 2737 const SwTxtFld *pTxtFld = pCurFldFmt->GetTxtFld(); 2738 // skip fields that are currently not in the document 2739 // e.g. fields in undo or redo array 2740 sal_Bool bSkip = !pTxtFld || 2741 !pTxtFld->GetpTxtNode()->GetNodes().IsDocNodes(); 2742 if (!bSkip) 2743 pItems[ nFillPos++ ] = new SwXTextField(*pCurFldFmt, pDoc); 2744 pCurFldFmt = aIter.Next(); 2745 2746 // enlarge sequence if necessary 2747 if (aItems.getLength() == nFillPos) 2748 { 2749 aItems.realloc( 2 * aItems.getLength() ); 2750 pItems = aItems.getArray(); 2751 } 2752 } 2753 } 2754 // now handle meta-fields, which are not SwFields 2755 const ::std::vector< uno::Reference<text::XTextField> > MetaFields( 2756 pDc->GetMetaFieldManager().getMetaFields() ); 2757 for (size_t i = 0; i < MetaFields.size(); ++i) 2758 { 2759 pItems[ nFillPos ] = MetaFields[i]; 2760 nFillPos++; 2761 2762 //FIXME UGLY 2763 // enlarge sequence if necessary 2764 if (aItems.getLength() == nFillPos) 2765 { 2766 aItems.realloc( 2 * aItems.getLength() ); 2767 pItems = aItems.getArray(); 2768 } 2769 } 2770 // resize sequence to actual used size 2771 aItems.realloc( nFillPos ); 2772 } 2773 2774 SwXFieldEnumeration::~SwXFieldEnumeration() 2775 { 2776 2777 } 2778 2779 sal_Bool SwXFieldEnumeration::hasMoreElements(void) 2780 throw( uno::RuntimeException ) 2781 { 2782 vos::OGuard aGuard(Application::GetSolarMutex()); 2783 return nNextIndex < aItems.getLength(); 2784 } 2785 2786 uno::Any SwXFieldEnumeration::nextElement(void) 2787 throw( container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException ) 2788 { 2789 vos::OGuard aGuard(Application::GetSolarMutex()); 2790 2791 if (!(nNextIndex < aItems.getLength())) 2792 throw container::NoSuchElementException(); 2793 2794 #if OSL_DEBUG_LEVEL > 1 2795 uno::Reference< text::XTextField > *pItems = aItems.getArray(); 2796 (void)pItems; 2797 #endif 2798 uno::Reference< text::XTextField > &rxFld = aItems.getArray()[ nNextIndex++ ]; 2799 uno::Any aRet(&rxFld, ::getCppuType(static_cast<const uno::Reference<text::XTextField>*>(0))); 2800 rxFld = 0; // free memory for item that is not longer used 2801 return aRet; 2802 } 2803 2804 void SwXFieldEnumeration::Modify( const SfxPoolItem* pOld, const SfxPoolItem *pNew) 2805 { 2806 ClientModify(this, pOld, pNew); 2807 if(!GetRegisteredIn()) 2808 pDoc = 0; 2809 } 2810 2811 2812 String& GetString( const uno::Any& rAny, String& rStr ) 2813 { 2814 OUString aStr; 2815 rAny >>= aStr; 2816 rStr = String( aStr ); 2817 return rStr; 2818 } 2819