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