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 #include <cmdid.h> 28 #include <hintids.hxx> 29 #include <svl/stritem.hxx> 30 #include <com/sun/star/lang/XMultiServiceFactory.hpp> 31 #include <com/sun/star/container/XNameAccess.hpp> 32 #include <com/sun/star/text/XDefaultNumberingProvider.hpp> 33 #include <com/sun/star/text/XNumberingTypeInfo.hpp> 34 #include <com/sun/star/style/NumberingType.hpp> 35 #include <com/sun/star/beans/XPropertySet.hpp> 36 #include <com/sun/star/sdbc/XConnection.hpp> 37 #include <com/sun/star/sdbc/XDataSource.hpp> 38 #include <com/sun/star/uri/XUriReferenceFactory.hpp> 39 #include <com/sun/star/uri/XVndSunStarScriptUrl.hpp> 40 #include <comphelper/processfactory.hxx> 41 #include <editeng/unolingu.hxx> 42 #include <unotools/localedatawrapper.hxx> 43 #include <sfx2/dispatch.hxx> 44 #include <sfx2/objsh.hxx> 45 #include <sfx2/linkmgr.hxx> 46 #include <sfx2/app.hxx> 47 #include <basic/basmgr.hxx> 48 #include <editeng/langitem.hxx> 49 #include <svl/macitem.hxx> 50 #include <basic/sbmod.hxx> 51 #include <fmtrfmrk.hxx> 52 #include <basic/sbmeth.hxx> 53 #include <basic/sbx.hxx> 54 #include <svl/zforlist.hxx> 55 #include <svl/zformat.hxx> 56 #include <vcl/mnemonic.hxx> 57 #include <view.hxx> 58 #include <wrtsh.hxx> // Actives Fenster 59 #include <doc.hxx> // Actives Fenster 60 #include <docsh.hxx> // Actives Fenster 61 #include <swmodule.hxx> 62 #include <charatr.hxx> 63 #include <fmtinfmt.hxx> 64 #include <cellatr.hxx> 65 #include <dbmgr.hxx> 66 #include <shellres.hxx> 67 #include <fldbas.hxx> 68 #include <docufld.hxx> 69 #include <chpfld.hxx> 70 #include <ddefld.hxx> 71 #include <expfld.hxx> 72 #include <reffld.hxx> 73 #include <usrfld.hxx> 74 #include <dbfld.hxx> 75 #include <authfld.hxx> 76 #include <flddat.hxx> 77 #include <fldmgr.hxx> 78 #include <crsskip.hxx> 79 #include <flddropdown.hxx> 80 #include <fldui.hrc> 81 #include <tox.hxx> 82 83 using rtl::OUString; 84 using namespace com::sun::star::uno; 85 using namespace com::sun::star::container; 86 using namespace com::sun::star::lang; 87 using namespace com::sun::star::beans; 88 using namespace com::sun::star::text; 89 using namespace com::sun::star::style; 90 using namespace com::sun::star::sdbc; 91 using namespace ::com::sun::star; 92 using namespace nsSwDocInfoSubType; 93 94 /*-------------------------------------------------------------------- 95 Beschreibung: Gruppen der Felder 96 --------------------------------------------------------------------*/ 97 enum 98 { 99 GRP_DOC_BEGIN = 0, 100 GRP_DOC_END = GRP_DOC_BEGIN + 11, 101 102 GRP_FKT_BEGIN = GRP_DOC_END, 103 GRP_FKT_END = GRP_FKT_BEGIN + 8, 104 105 GRP_REF_BEGIN = GRP_FKT_END, 106 GRP_REF_END = GRP_REF_BEGIN + 2, 107 108 GRP_REG_BEGIN = GRP_REF_END, 109 GRP_REG_END = GRP_REG_BEGIN + 1, 110 111 GRP_DB_BEGIN = GRP_REG_END, 112 GRP_DB_END = GRP_DB_BEGIN + 5, 113 114 GRP_VAR_BEGIN = GRP_DB_END, 115 GRP_VAR_END = GRP_VAR_BEGIN + 9 116 }; 117 118 enum 119 { 120 GRP_WEB_DOC_BEGIN = 0, 121 GRP_WEB_DOC_END = GRP_WEB_DOC_BEGIN + 9, 122 123 GRP_WEB_FKT_BEGIN = GRP_WEB_DOC_END + 2, 124 GRP_WEB_FKT_END = GRP_WEB_FKT_BEGIN + 0, // Die Gruppe ist leer! 125 126 GRP_WEB_REF_BEGIN = GRP_WEB_FKT_END + 6, // Die Gruppe ist leer! 127 GRP_WEB_REF_END = GRP_WEB_REF_BEGIN + 0, 128 129 GRP_WEB_REG_BEGIN = GRP_WEB_REF_END + 2, 130 GRP_WEB_REG_END = GRP_WEB_REG_BEGIN + 1, 131 132 GRP_WEB_DB_BEGIN = GRP_WEB_REG_END, // Die Gruppe ist leer! 133 GRP_WEB_DB_END = GRP_WEB_DB_BEGIN + 0, 134 135 GRP_WEB_VAR_BEGIN = GRP_WEB_DB_END + 5, 136 GRP_WEB_VAR_END = GRP_WEB_VAR_BEGIN + 1 137 }; 138 139 /*-------------------------------------------------------------------- 140 Beschreibung: Formate in der richtigen Reihenfolge 141 --------------------------------------------------------------------*/ 142 static const sal_uInt16 __FAR_DATA aSetFmt[] = 143 { 144 // die Reihenfolge muss zu Beginn mit den ResourceIds fuer FMT_SETVAR_??? 145 // uebereinstimmen 146 0, 147 0 148 }; 149 150 static const sal_uInt16 __FAR_DATA aGetFmt[] = 151 { 152 // die Reihenfolge muss zu Beginn mit den ResourceIds fuer FMT_GETVAR_??? 153 // uebereinstimmen 154 0 155 }; 156 157 static const sal_uInt16 __FAR_DATA aUsrFmt[] = 158 { 159 // die Reihenfolge muss zu Beginn mit den ResourceIds fuer FMT_SETVAR_??? 160 // uebereinstimmen 161 0, 162 nsSwExtendedSubType::SUB_CMD 163 }; 164 165 static const sal_uInt16 __FAR_DATA aDBFmt[] = 166 { 167 // die Reihenfolge muss zu Beginn mit den ResourceIds fuer FMT_DBFLD_??? 168 // uebereinstimmen 169 nsSwExtendedSubType::SUB_OWN_FMT 170 }; 171 172 static const sal_uInt16 VF_COUNT = sizeof(aGetFmt) / sizeof(sal_uInt16); 173 static const sal_uInt16 VF_USR_COUNT = sizeof(aUsrFmt) / sizeof(sal_uInt16); 174 static const sal_uInt16 VF_DB_COUNT = sizeof(aDBFmt) / sizeof(sal_uInt16); 175 176 /*-------------------------------------------------------------------- 177 Beschreibung: Feldtypen und Subtypes 178 --------------------------------------------------------------------*/ 179 struct SwFldPack 180 { 181 sal_uInt16 nTypeId; 182 183 sal_uInt16 nSubTypeStart; 184 sal_uInt16 nSubTypeEnd; 185 186 sal_uLong nFmtBegin; 187 sal_uLong nFmtEnd; 188 }; 189 190 /*-------------------------------------------------------------------- 191 Beschreibung: Strings und Formate 192 --------------------------------------------------------------------*/ 193 static const SwFldPack __FAR_DATA aSwFlds[] = 194 { 195 // Dokument 196 { TYP_EXTUSERFLD, FLD_EU_BEGIN, FLD_EU_END, 0, 0 }, 197 { TYP_AUTHORFLD, 0, 0, FMT_AUTHOR_BEGIN, FMT_AUTHOR_END }, 198 { TYP_DATEFLD, FLD_DATE_BEGIN, FLD_DATE_END, 0, 0 }, 199 { TYP_TIMEFLD, FLD_TIME_BEGIN, FLD_TIME_END, 0, 0 }, 200 { TYP_PAGENUMBERFLD, 0, 0, FMT_NUM_BEGIN, FMT_NUM_END-1 }, 201 { TYP_NEXTPAGEFLD, 0, 0, FMT_NUM_BEGIN, FMT_NUM_END }, 202 { TYP_PREVPAGEFLD, 0, 0, FMT_NUM_BEGIN, FMT_NUM_END }, 203 { TYP_FILENAMEFLD, 0, 0, FMT_FF_BEGIN, FMT_FF_END }, 204 { TYP_DOCSTATFLD, FLD_STAT_BEGIN, FLD_STAT_END, FMT_NUM_BEGIN, FMT_NUM_END-1 }, 205 206 { TYP_CHAPTERFLD, 0, 0, FMT_CHAPTER_BEGIN, FMT_CHAPTER_END }, 207 { TYP_TEMPLNAMEFLD, 0, 0, FMT_FF_BEGIN, FMT_FF_END }, 208 209 // Funktion 210 { TYP_CONDTXTFLD, 0, 0, 0, 0 }, 211 { TYP_DROPDOWN, 0, 0, 0, 0 }, 212 { TYP_INPUTFLD, FLD_INPUT_BEGIN, FLD_INPUT_END, 0, 0 }, 213 { TYP_MACROFLD, 0, 0, 0, 0 }, 214 { TYP_JUMPEDITFLD, 0, 0, FMT_MARK_BEGIN, FMT_MARK_END }, 215 { TYP_COMBINED_CHARS, 0, 0, 0, 0 }, 216 { TYP_HIDDENTXTFLD, 0, 0, 0, 0 }, 217 { TYP_HIDDENPARAFLD, 0, 0, 0, 0 }, 218 219 // Referenzen 220 { TYP_SETREFFLD, 0, 0, 0, 0 }, 221 { TYP_GETREFFLD, 0, 0, FMT_REF_BEGIN, FMT_REF_END }, 222 223 // Ablage 224 { TYP_DOCINFOFLD, 0, 0, FMT_REG_BEGIN, FMT_REG_END }, 225 226 // Datenbank 227 { TYP_DBFLD, 0, 0, FMT_DBFLD_BEGIN, FMT_DBFLD_END }, 228 { TYP_DBNEXTSETFLD, 0, 0, 0, 0 }, 229 { TYP_DBNUMSETFLD, 0, 0, 0, 0 }, 230 { TYP_DBSETNUMBERFLD, 0, 0, FMT_NUM_BEGIN, FMT_NUM_END-2 }, 231 { TYP_DBNAMEFLD, 0, 0, 0, 0 }, 232 233 // Variablen 234 { TYP_SETFLD, 0, 0, FMT_SETVAR_BEGIN, FMT_SETVAR_END }, 235 236 { TYP_GETFLD, 0, 0, FMT_GETVAR_BEGIN, FMT_GETVAR_END }, 237 { TYP_DDEFLD, 0, 0, FMT_DDE_BEGIN, FMT_DDE_END }, 238 { TYP_FORMELFLD, 0, 0, FMT_GETVAR_BEGIN, FMT_GETVAR_END }, 239 { TYP_INPUTFLD, FLD_INPUT_BEGIN, FLD_INPUT_END, 0, 0 }, 240 { TYP_SEQFLD, 0, 0, FMT_NUM_BEGIN, FMT_NUM_END-2 }, 241 { TYP_SETREFPAGEFLD, FLD_PAGEREF_BEGIN, FLD_PAGEREF_END,0, 0 }, 242 { TYP_GETREFPAGEFLD, 0, 0, FMT_NUM_BEGIN, FMT_NUM_END-1 }, 243 { TYP_USERFLD, 0, 0, FMT_USERVAR_BEGIN, FMT_USERVAR_END } 244 }; 245 246 /*-------------------------------------------------------------------- 247 Beschreibung: Zugriff auf die Shell 248 --------------------------------------------------------------------*/ 249 250 static SwWrtShell* lcl_GetShell() 251 { 252 SwView* pView; 253 if ( 0 != (pView = ::GetActiveView()) ) 254 return pView->GetWrtShellPtr(); 255 DBG_ERROR("no current shell found!"); 256 return 0; 257 } 258 259 inline sal_uInt16 GetPackCount() { return sizeof(aSwFlds) / sizeof(SwFldPack); } 260 261 /*-------------------------------------------------------------------- 262 Beschreibung: FieldManager regelt das Einfuegen und Updaten 263 von Feldern 264 --------------------------------------------------------------------*/ 265 266 SwFldMgr::SwFldMgr(SwWrtShell* pSh ) : 267 pModule(0), 268 pMacroItem(0), 269 pWrtShell(pSh), 270 bEvalExp(sal_True) 271 { 272 // aktuelles Feld ermitteln falls vorhanden 273 GetCurFld(); 274 } 275 276 277 SwFldMgr::~SwFldMgr() 278 { 279 } 280 281 /*-------------------------------------------------------------------- 282 Beschreibung: RefMark ueber Namen organisieren 283 --------------------------------------------------------------------*/ 284 285 sal_Bool SwFldMgr::CanInsertRefMark( const String& rStr ) 286 { 287 sal_Bool bRet = sal_False; 288 SwWrtShell *pSh = pWrtShell ? pWrtShell : lcl_GetShell(); 289 DBG_ASSERT(pSh, "no SwWrtShell found"); 290 if(pSh) 291 { 292 sal_uInt16 nCnt = pSh->GetCrsrCnt(); 293 294 // der letzte Crsr muss keine aufgespannte Selektion 295 if( 1 < nCnt && !pSh->SwCrsrShell::HasSelection() ) 296 --nCnt; 297 298 bRet = 2 > nCnt && 0 == pSh->GetRefMark( rStr ); 299 } 300 return bRet; 301 } 302 303 /*-------------------------------------------------------------------- 304 Beschreibung: Zugriff ueber ResIds 305 --------------------------------------------------------------------*/ 306 307 void SwFldMgr::RemoveFldType(sal_uInt16 nResId, const String& rName ) 308 { 309 SwWrtShell * pSh = pWrtShell ? pWrtShell : lcl_GetShell(); 310 DBG_ASSERT(pSh, "no SwWrtShell found"); 311 if( pSh ) 312 pSh->RemoveFldType(nResId, rName); 313 } 314 315 sal_uInt16 SwFldMgr::GetFldTypeCount(sal_uInt16 nResId) const 316 { 317 SwWrtShell * pSh = pWrtShell ? pWrtShell : lcl_GetShell(); 318 DBG_ASSERT(pSh, "no SwWrtShell found"); 319 return pSh ? pSh->GetFldTypeCount(nResId) : 0; 320 } 321 322 323 SwFieldType* SwFldMgr::GetFldType(sal_uInt16 nResId, sal_uInt16 nId) const 324 { 325 SwWrtShell * pSh = pWrtShell ? pWrtShell : lcl_GetShell(); 326 DBG_ASSERT(pSh, "no SwWrtShell found"); 327 return pSh ? pSh->GetFldType(nId, nResId) : 0; 328 } 329 330 331 SwFieldType* SwFldMgr::GetFldType(sal_uInt16 nResId, const String& rName) const 332 { 333 SwWrtShell * pSh = pWrtShell ? pWrtShell : lcl_GetShell(); 334 DBG_ASSERT(pSh, "no SwWrtShell found"); 335 return pSh ? pSh->GetFldType(nResId, rName) : 0; 336 } 337 338 339 /*-------------------------------------------------------------------- 340 Beschreibung: Aktuelles Feld ermitteln 341 --------------------------------------------------------------------*/ 342 SwField* SwFldMgr::GetCurFld() 343 { 344 SwWrtShell *pSh = pWrtShell ? pWrtShell : ::lcl_GetShell(); 345 if ( pSh ) 346 pCurFld = pSh->GetCurFld( true ); 347 else 348 pCurFld = NULL; 349 350 // Strings und Format initialisieren 351 // 352 aCurPar1.Erase(); 353 aCurPar2.Erase(); 354 sCurFrame.Erase(); 355 nCurFmt = 0; 356 357 if(!pCurFld) 358 return 0; 359 360 // Aktuelle Werte aufbereiten Parameter 1 und Parameter 2 361 // als auch das Format ermitteln 362 // 363 const sal_uInt16 nTypeId = pCurFld->GetTypeId(); 364 365 nCurFmt = pCurFld->GetFormat(); 366 aCurPar1 = pCurFld->GetPar1(); 367 aCurPar2 = pCurFld->GetPar2(); 368 369 switch( nTypeId ) 370 { 371 case TYP_PAGENUMBERFLD: 372 case TYP_NEXTPAGEFLD: 373 case TYP_PREVPAGEFLD: 374 case TYP_GETREFPAGEFLD: 375 if( nCurFmt == SVX_NUM_PAGEDESC ) 376 nCurFmt -= 2; 377 break; 378 } 379 return pCurFld; 380 } 381 382 /*-------------------------------------------------------------------- 383 Beschreibung: Gruppen-Bereich liefern 384 --------------------------------------------------------------------*/ 385 386 387 const SwFldGroupRgn& SwFldMgr::GetGroupRange(sal_Bool bHtmlMode, sal_uInt16 nGrpId) const 388 { 389 static SwFldGroupRgn __READONLY_DATA aRanges[] = 390 { 391 { /* Dokument */ GRP_DOC_BEGIN, GRP_DOC_END }, 392 { /* Funktionen */ GRP_FKT_BEGIN, GRP_FKT_END }, 393 { /* Referenzen */ GRP_REF_BEGIN, GRP_REF_END }, 394 { /* Ablage */ GRP_REG_BEGIN, GRP_REG_END }, 395 { /* DB */ GRP_DB_BEGIN, GRP_DB_END }, 396 { /* User */ GRP_VAR_BEGIN, GRP_VAR_END } 397 }; 398 static SwFldGroupRgn __READONLY_DATA aWebRanges[] = 399 { 400 { /* Dokument */ GRP_WEB_DOC_BEGIN, GRP_WEB_DOC_END }, 401 { /* Funktionen */ GRP_WEB_FKT_BEGIN, GRP_WEB_FKT_END }, 402 { /* Referenzen */ GRP_WEB_REF_BEGIN, GRP_WEB_REF_END }, 403 { /* Ablage */ GRP_WEB_REG_BEGIN, GRP_WEB_REG_END }, 404 { /* DB */ GRP_WEB_DB_BEGIN, GRP_WEB_DB_END }, 405 { /* User */ GRP_WEB_VAR_BEGIN, GRP_WEB_VAR_END } 406 }; 407 408 if (bHtmlMode) 409 return aWebRanges[(sal_uInt16)nGrpId]; 410 else 411 return aRanges[(sal_uInt16)nGrpId]; 412 } 413 414 /*-------------------------------------------------------------------- 415 Beschreibung: GroupId bestimmen 416 --------------------------------------------------------------------*/ 417 418 sal_uInt16 SwFldMgr::GetGroup(sal_Bool bHtmlMode, sal_uInt16 nTypeId, sal_uInt16 nSubType) const 419 { 420 if (nTypeId == TYP_SETINPFLD) 421 nTypeId = TYP_SETFLD; 422 423 if (nTypeId == TYP_INPUTFLD && (nSubType & INP_USR)) 424 nTypeId = TYP_USERFLD; 425 426 if (nTypeId == TYP_FIXDATEFLD) 427 nTypeId = TYP_DATEFLD; 428 429 if (nTypeId == TYP_FIXTIMEFLD) 430 nTypeId = TYP_TIMEFLD; 431 432 for (sal_uInt16 i = GRP_DOC; i <= GRP_VAR; i++) 433 { 434 const SwFldGroupRgn& rRange = GetGroupRange(bHtmlMode, i); 435 for (sal_uInt16 nPos = rRange.nStart; nPos < rRange.nEnd; nPos++) 436 { 437 if (aSwFlds[nPos].nTypeId == nTypeId) 438 return i; 439 } 440 } 441 return USHRT_MAX; 442 } 443 444 /*-------------------------------------------------------------------- 445 Beschreibung: Namen zur TypeId ermitteln 446 ZUGRIFF ueber TYP_.... 447 --------------------------------------------------------------------*/ 448 449 450 sal_uInt16 SwFldMgr::GetTypeId(sal_uInt16 nPos) 451 { 452 ASSERT(nPos < ::GetPackCount(), "unzulaessige Pos"); 453 return aSwFlds[ nPos ].nTypeId; 454 } 455 456 457 const String& SwFldMgr::GetTypeStr(sal_uInt16 nPos) 458 { 459 ASSERT(nPos < ::GetPackCount(), "unzulaessige TypeId"); 460 461 sal_uInt16 nFldWh = aSwFlds[ nPos ].nTypeId; 462 463 // Sonderbehandlung fuer Datum/Zeit Felder (ohne var/fix) 464 if( TYP_DATEFLD == nFldWh ) 465 { 466 static String g_aDate( SW_RES( STR_DATEFLD ) ); 467 return g_aDate; 468 } 469 if( TYP_TIMEFLD == nFldWh ) 470 { 471 static String g_aTime( SW_RES( STR_TIMEFLD ) ); 472 return g_aTime; 473 } 474 475 return SwFieldType::GetTypeStr( nFldWh ); 476 } 477 478 /*-------------------------------------------------------------------- 479 Beschreibung: Pos in der Liste bestimmen 480 --------------------------------------------------------------------*/ 481 482 483 sal_uInt16 SwFldMgr::GetPos(sal_uInt16 nTypeId) 484 { 485 switch( nTypeId ) 486 { 487 case TYP_FIXDATEFLD: nTypeId = TYP_DATEFLD; break; 488 case TYP_FIXTIMEFLD: nTypeId = TYP_TIMEFLD; break; 489 case TYP_SETINPFLD: nTypeId = TYP_SETFLD; break; 490 case TYP_USRINPFLD: nTypeId = TYP_USERFLD; break; 491 } 492 493 for(sal_uInt16 i = 0; i < GetPackCount(); i++) 494 if(aSwFlds[i].nTypeId == nTypeId) 495 return i; 496 497 return USHRT_MAX; 498 } 499 500 /*-------------------------------------------------------------------- 501 Beschreibung: Subtypen eines Feldes lokalisieren 502 --------------------------------------------------------------------*/ 503 504 sal_Bool SwFldMgr::GetSubTypes(sal_uInt16 nTypeId, SvStringsDtor& rToFill) 505 { 506 sal_Bool bRet = sal_False; 507 SwWrtShell *pSh = pWrtShell ? pWrtShell : lcl_GetShell(); 508 DBG_ASSERT(pSh, "no SwWrtShell found"); 509 if(pSh) 510 { 511 const sal_uInt16 nPos = GetPos(nTypeId); 512 513 switch(nTypeId) 514 { 515 case TYP_SETREFFLD: 516 case TYP_GETREFFLD: 517 { 518 // Referenzen sind keine Felder 519 pSh->GetRefMarks( &rToFill ); 520 break; 521 } 522 case TYP_MACROFLD: 523 { 524 break; 525 } 526 case TYP_INPUTFLD: 527 { String* pNew = new SW_RESSTR(aSwFlds[nPos].nSubTypeStart); 528 rToFill.Insert(pNew, rToFill.Count()); 529 // Weiter bei generischen Typen 530 } 531 case TYP_DDEFLD: 532 case TYP_SEQFLD: 533 case TYP_FORMELFLD: 534 case TYP_GETFLD: 535 case TYP_SETFLD: 536 case TYP_USERFLD: 537 { 538 539 const sal_uInt16 nCount = pSh->GetFldTypeCount(); 540 for(sal_uInt16 i = 0; i < nCount; ++i) 541 { 542 SwFieldType* pFldType = pSh->GetFldType( i ); 543 const sal_uInt16 nWhich = pFldType->Which(); 544 545 if((nTypeId == TYP_DDEFLD && pFldType->Which() == RES_DDEFLD) || 546 547 (nTypeId == TYP_USERFLD && nWhich == RES_USERFLD) || 548 549 (nTypeId == TYP_GETFLD && nWhich == RES_SETEXPFLD && 550 !(((SwSetExpFieldType*)pFldType)->GetType() & nsSwGetSetExpType::GSE_SEQ)) || 551 552 (nTypeId == TYP_SETFLD && nWhich == RES_SETEXPFLD && 553 !(((SwSetExpFieldType*)pFldType)->GetType() & nsSwGetSetExpType::GSE_SEQ)) || 554 555 (nTypeId == TYP_SEQFLD && nWhich == RES_SETEXPFLD && 556 (((SwSetExpFieldType*)pFldType)->GetType() & nsSwGetSetExpType::GSE_SEQ)) || 557 558 ((nTypeId == TYP_INPUTFLD || nTypeId == TYP_FORMELFLD) && 559 (nWhich == RES_USERFLD || 560 (nWhich == RES_SETEXPFLD && 561 !(((SwSetExpFieldType*)pFldType)->GetType() & nsSwGetSetExpType::GSE_SEQ))) ) ) 562 { 563 String* pNew = new String(pFldType->GetName()); 564 rToFill.Insert(pNew, rToFill.Count()); 565 } 566 } 567 break; 568 } 569 case TYP_DBNEXTSETFLD: 570 case TYP_DBNUMSETFLD: 571 case TYP_DBNAMEFLD: 572 case TYP_DBSETNUMBERFLD: 573 break; 574 575 default: 576 { 577 // statische SubTypes 578 if(nPos != USHRT_MAX) 579 { 580 sal_uInt16 nCount; 581 if (nTypeId == TYP_DOCINFOFLD) 582 nCount = DI_SUBTYPE_END - DI_SUBTYPE_BEGIN; 583 else 584 nCount = aSwFlds[nPos].nSubTypeEnd - aSwFlds[nPos].nSubTypeStart; 585 586 for(sal_uInt16 i = 0; i < nCount; ++i) 587 { 588 String* pNew; 589 if (nTypeId == TYP_DOCINFOFLD) 590 { 591 if ( i == DI_CUSTOM ) 592 pNew = new String( String(SW_RES( STR_CUSTOM )) ); 593 else 594 pNew = new String(*ViewShell::GetShellRes()->aDocInfoLst[i]); 595 } 596 else 597 pNew = new SW_RESSTR(aSwFlds[nPos].nSubTypeStart + i); 598 599 rToFill.Insert(pNew, rToFill.Count()); 600 } 601 } 602 } 603 } 604 bRet = sal_True; 605 } 606 return bRet; 607 } 608 609 /*-------------------------------------------------------------------- 610 Beschreibung: Format ermitteln 611 ZUGRIFF ueber TYP_.... 612 --------------------------------------------------------------------*/ 613 614 615 sal_uInt16 SwFldMgr::GetFormatCount(sal_uInt16 nTypeId, sal_Bool bIsText, sal_Bool bHtmlMode) const 616 { 617 ASSERT(nTypeId < TYP_END, "unzulaessige TypeId"); 618 619 { 620 const sal_uInt16 nPos = GetPos(nTypeId); 621 622 if(nPos == USHRT_MAX || (bHtmlMode && nTypeId == TYP_SETFLD)) 623 return 0; 624 625 sal_uLong nStart = aSwFlds[nPos].nFmtBegin; 626 sal_uLong nEnd = aSwFlds[nPos].nFmtEnd; 627 628 if (bIsText && nEnd - nStart >= 2) 629 return 2; 630 631 if (nTypeId == TYP_FILENAMEFLD) 632 nEnd -= 2; // Kein Bereich oder Vorlage 633 634 switch(nStart) 635 { 636 case FMT_GETVAR_BEGIN: 637 case FMT_SETVAR_BEGIN: return VF_COUNT; 638 case FMT_USERVAR_BEGIN: return VF_USR_COUNT; 639 case FMT_DBFLD_BEGIN: return VF_DB_COUNT; 640 case FMT_NUM_BEGIN: 641 { 642 sal_uInt16 nCount = (sal_uInt16)(nEnd - nStart); 643 GetNumberingInfo(); 644 if(xNumberingInfo.is()) 645 { 646 Sequence<sal_Int16> aTypes = xNumberingInfo->getSupportedNumberingTypes(); 647 const sal_Int16* pTypes = aTypes.getConstArray(); 648 for(sal_Int32 nType = 0; nType < aTypes.getLength(); nType++) 649 { 650 sal_Int16 nCurrent = pTypes[nType]; 651 //skip all values below or equal to CHARS_LOWER_LETTER_N 652 if(nCurrent > NumberingType::CHARS_LOWER_LETTER_N) 653 { 654 // #i28073# it's not necessarily a sorted sequence 655 ++nCount; 656 } 657 } 658 } 659 return nCount; 660 } 661 662 } 663 return (sal_uInt16)(nEnd - nStart); 664 } 665 } 666 667 /*-------------------------------------------------------------------- 668 Beschreibung: FormatString zu einem Typ ermitteln 669 --------------------------------------------------------------------*/ 670 671 672 String SwFldMgr::GetFormatStr(sal_uInt16 nTypeId, sal_uLong nFormatId) const 673 { 674 String aRet; 675 ASSERT(nTypeId < TYP_END, "unzulaessige TypeId"); 676 677 const sal_uInt16 nPos = GetPos(nTypeId); 678 679 if(nPos == USHRT_MAX) 680 return aRet; 681 682 sal_uLong nStart; 683 684 nStart = aSwFlds[nPos].nFmtBegin; 685 686 if (TYP_AUTHORFLD == nTypeId|| TYP_FILENAMEFLD == nTypeId) 687 nFormatId &= ~FF_FIXED; // Fixed-Flag ausmaskieren 688 689 if((nStart + nFormatId) < aSwFlds[nPos].nFmtEnd) 690 aRet = SW_RESSTR((sal_uInt16)(nStart + nFormatId)); 691 else if( FMT_NUM_BEGIN == nStart) 692 { 693 if(xNumberingInfo.is()) 694 { 695 Sequence<sal_Int16> aTypes = xNumberingInfo->getSupportedNumberingTypes(); 696 const sal_Int16* pTypes = aTypes.getConstArray(); 697 sal_Int32 nOffset = aSwFlds[nPos].nFmtEnd - nStart; 698 sal_Int32 nValidEntry = 0; 699 for(sal_Int32 nType = 0; nType < aTypes.getLength(); nType++) 700 { 701 sal_Int16 nCurrent = pTypes[nType]; 702 if(nCurrent > NumberingType::CHARS_LOWER_LETTER_N) 703 { 704 if(nValidEntry == ((sal_Int32)nFormatId) - nOffset) 705 { 706 aRet = xNumberingInfo->getNumberingIdentifier( pTypes[nType] ); 707 break; 708 } 709 ++nValidEntry; 710 } 711 } 712 } 713 } 714 715 return aRet; 716 } 717 718 /*-------------------------------------------------------------------- 719 Beschreibung: FormatId aus Pseudo-ID ermitteln 720 --------------------------------------------------------------------*/ 721 722 sal_uInt16 SwFldMgr::GetFormatId(sal_uInt16 nTypeId, sal_uLong nFormatId) const 723 { 724 sal_uInt16 nId = (sal_uInt16)nFormatId; 725 726 switch( nTypeId ) 727 { 728 case TYP_DOCINFOFLD: 729 switch( aSwFlds[ GetPos( nTypeId ) ].nFmtBegin + nFormatId ) 730 { 731 case FMT_REG_AUTHOR: nId = DI_SUB_AUTHOR; break; 732 case FMT_REG_TIME: nId = DI_SUB_TIME; break; 733 case FMT_REG_DATE: nId = DI_SUB_DATE; break; 734 } 735 break; 736 737 case TYP_PAGENUMBERFLD: 738 case TYP_NEXTPAGEFLD: 739 case TYP_PREVPAGEFLD: 740 case TYP_DOCSTATFLD: 741 case TYP_DBSETNUMBERFLD: 742 case TYP_SEQFLD: 743 case TYP_GETREFPAGEFLD: 744 { 745 sal_uInt16 nPos = GetPos( nTypeId ); 746 sal_uLong nBegin = aSwFlds[ nPos ].nFmtBegin; 747 sal_uLong nEnd = aSwFlds[nPos].nFmtEnd; 748 if((nBegin + nFormatId) < nEnd) 749 { 750 switch( nBegin + nFormatId ) 751 { 752 case FMT_NUM_ABC: nId = SVX_NUM_CHARS_UPPER_LETTER; break; 753 case FMT_NUM_SABC: nId = SVX_NUM_CHARS_LOWER_LETTER; break; 754 case FMT_NUM_ROMAN: nId = SVX_NUM_ROMAN_UPPER; break; 755 case FMT_NUM_SROMAN: nId = SVX_NUM_ROMAN_LOWER; break; 756 case FMT_NUM_ARABIC: nId = SVX_NUM_ARABIC; break; 757 case FMT_NUM_PAGEDESC: nId = SVX_NUM_PAGEDESC; break; 758 case FMT_NUM_PAGESPECIAL: nId = SVX_NUM_CHAR_SPECIAL; break; 759 case FMT_NUM_ABC_N: nId = SVX_NUM_CHARS_UPPER_LETTER_N; break; 760 case FMT_NUM_SABC_N: nId = SVX_NUM_CHARS_LOWER_LETTER_N; break; 761 } 762 } 763 else if(xNumberingInfo.is()) 764 { 765 Sequence<sal_Int16> aTypes = xNumberingInfo->getSupportedNumberingTypes(); 766 const sal_Int16* pTypes = aTypes.getConstArray(); 767 sal_Int32 nOffset = nEnd - nBegin; 768 sal_Int32 nValidEntry = 0; 769 for(sal_Int32 nType = 0; nType < aTypes.getLength(); nType++) 770 { 771 sal_Int16 nCurrent = pTypes[nType]; 772 if(nCurrent > NumberingType::CHARS_LOWER_LETTER_N) 773 { 774 if(nValidEntry == ((sal_Int32)nFormatId) - nOffset) 775 { 776 nId = pTypes[nType]; 777 break; 778 } 779 ++nValidEntry; 780 } 781 } 782 } 783 } 784 break; 785 case TYP_DDEFLD: 786 switch ( aSwFlds[ GetPos( nTypeId ) ].nFmtBegin + nFormatId ) 787 { 788 case FMT_DDE_NORMAL: nId = sfx2::LINKUPDATE_ONCALL; break; 789 case FMT_DDE_HOT: nId = sfx2::LINKUPDATE_ALWAYS; break; 790 } 791 break; 792 } 793 794 return nId; 795 796 } 797 798 /*-------------------------------------------------------------------- 799 Beschreibung: Traveling 800 --------------------------------------------------------------------*/ 801 802 803 sal_Bool SwFldMgr::GoNextPrev( sal_Bool bNext, SwFieldType* pTyp ) 804 { 805 SwWrtShell* pSh = pWrtShell ? pWrtShell : ::lcl_GetShell(); 806 if(!pSh) 807 return sal_False; 808 809 if( !pTyp && pCurFld ) 810 { 811 const sal_uInt16 nTypeId = pCurFld->GetTypeId(); 812 if( TYP_SETINPFLD == nTypeId || TYP_USRINPFLD == nTypeId ) 813 pTyp = pSh->GetFldType( 0, RES_INPUTFLD ); 814 else 815 pTyp = pCurFld->GetTyp(); 816 } 817 818 if (pTyp && pTyp->Which() == RES_DBFLD) 819 { 820 // Fuer Feldbefehl-bearbeiten (alle DB-Felder anspringen) 821 return pSh->MoveFldType( 0, (bNext ? true : false), RES_DBFLD ); 822 } 823 824 return (pTyp && pSh) 825 ? pSh->MoveFldType( pTyp, (bNext ? true : false) ) 826 : sal_False; 827 } 828 829 /*-------------------------------------------------------------------- 830 Beschreibung: Feldtypen einfuegen 831 --------------------------------------------------------------------*/ 832 833 834 void SwFldMgr::InsertFldType(SwFieldType& rType) 835 { 836 SwWrtShell* pSh = pWrtShell ? pWrtShell : ::lcl_GetShell(); 837 DBG_ASSERT(pSh, "no SwWrtShell found"); 838 if(pSh) 839 pSh->InsertFldType(rType); 840 } 841 842 /*-------------------------------------------------------------------- 843 Beschreibung: Aktuelle TypeId ermitteln 844 --------------------------------------------------------------------*/ 845 846 847 sal_uInt16 SwFldMgr::GetCurTypeId() const 848 { 849 return pCurFld ? pCurFld->GetTypeId() : USHRT_MAX; 850 } 851 852 /*-------------------------------------------------------------------- 853 Beschreibung: Ueber String Feld einfuegen oder Update 854 --------------------------------------------------------------------*/ 855 856 857 sal_Bool SwFldMgr::InsertFld( 858 const SwInsertFld_Data& rData ) 859 { 860 SwField* pFld = 0; 861 sal_Bool bExp = sal_False; 862 sal_Bool bTbl = sal_False; 863 sal_Bool bPageVar = sal_False; 864 sal_uLong nFormatId = rData.nFormatId; 865 sal_uInt16 nSubType = rData.nSubType; 866 sal_Unicode cSeparator = rData.cSeparator; 867 SwWrtShell* pCurShell = rData.pSh; 868 if(!pCurShell) 869 pCurShell = pWrtShell ? pWrtShell : ::lcl_GetShell(); 870 DBG_ASSERT(pCurShell, "no SwWrtShell found"); 871 if(!pCurShell) 872 return sal_False; 873 874 switch(rData.nTypeId) 875 { 876 case TYP_POSTITFLD: 877 { 878 SwPostItFieldType* pType = (SwPostItFieldType*)pCurShell->GetFldType(0, RES_POSTITFLD); 879 SwPostItField* pPostItField = 880 new SwPostItField( 881 pType, 882 rData.sPar2, // content 883 rData.sPar1, // author 884 aEmptyStr, // author's initials 885 aEmptyStr, // name 886 DateTime() ); 887 pFld = pPostItField; 888 } 889 break; 890 891 case TYP_SCRIPTFLD: 892 { 893 SwScriptFieldType* pType = 894 (SwScriptFieldType*)pCurShell->GetFldType(0, RES_SCRIPTFLD); 895 pFld = new SwScriptField(pType, rData.sPar1, rData.sPar2, (sal_Bool)nFormatId); 896 break; 897 } 898 899 case TYP_COMBINED_CHARS: 900 { 901 SwCombinedCharFieldType* pType = (SwCombinedCharFieldType*) 902 pCurShell->GetFldType( 0, RES_COMBINED_CHARS ); 903 pFld = new SwCombinedCharField( pType, rData.sPar1 ); 904 } 905 break; 906 907 case TYP_AUTHORITY: 908 { 909 SwAuthorityFieldType* pType = 910 (SwAuthorityFieldType*)pCurShell->GetFldType(0, RES_AUTHORITY); 911 if(!pType) 912 { 913 pType = 914 (SwAuthorityFieldType*)pCurShell->InsertFldType( 915 SwAuthorityFieldType(pCurShell->GetDoc())); 916 } 917 pFld = new SwAuthorityField(pType, rData.sPar1); 918 } 919 break; 920 921 case TYP_DATEFLD: 922 case TYP_TIMEFLD: 923 { 924 sal_uInt16 nSub = static_cast< sal_uInt16 >(rData.nTypeId == TYP_DATEFLD ? DATEFLD : TIMEFLD); 925 nSub |= nSubType == DATE_VAR ? 0 : FIXEDFLD; 926 927 SwDateTimeFieldType* pTyp = 928 (SwDateTimeFieldType*)pCurShell->GetFldType(0, RES_DATETIMEFLD); 929 pFld = new SwDateTimeField(pTyp, nSub, nFormatId); 930 pFld->SetPar2(rData.sPar2); 931 break; 932 } 933 934 case TYP_FILENAMEFLD: 935 { 936 SwFileNameFieldType* pTyp = 937 (SwFileNameFieldType*)pCurShell->GetFldType(0, RES_FILENAMEFLD); 938 pFld = new SwFileNameField(pTyp, nFormatId); 939 break; 940 } 941 942 case TYP_TEMPLNAMEFLD: 943 { 944 SwTemplNameFieldType* pTyp = 945 (SwTemplNameFieldType*)pCurShell->GetFldType(0, RES_TEMPLNAMEFLD); 946 pFld = new SwTemplNameField(pTyp, nFormatId); 947 break; 948 } 949 950 case TYP_CHAPTERFLD: 951 { 952 sal_uInt16 nByte = (sal_uInt16)rData.sPar2.ToInt32(); 953 SwChapterFieldType* pTyp = 954 (SwChapterFieldType*)pCurShell->GetFldType(0, RES_CHAPTERFLD); 955 pFld = new SwChapterField(pTyp, nFormatId); 956 nByte = Max(sal_uInt16(1), nByte); 957 nByte = Min(nByte, sal_uInt16(MAXLEVEL)); 958 nByte -= 1; 959 ((SwChapterField*)pFld)->SetLevel((sal_uInt8)nByte); 960 break; 961 } 962 963 case TYP_NEXTPAGEFLD: 964 case TYP_PREVPAGEFLD: 965 case TYP_PAGENUMBERFLD: 966 { 967 short nOff = (short)rData.sPar2.ToInt32(); 968 969 if(rData.nTypeId == TYP_NEXTPAGEFLD) 970 { 971 if( SVX_NUM_CHAR_SPECIAL == nFormatId ) 972 nOff = 1; 973 else 974 nOff += 1; 975 nSubType = PG_NEXT; 976 } 977 else if(rData.nTypeId == TYP_PREVPAGEFLD) 978 { 979 if( SVX_NUM_CHAR_SPECIAL == nFormatId ) 980 nOff = -1; 981 else 982 nOff -= 1; 983 nSubType = PG_PREV; 984 } 985 else 986 nSubType = PG_RANDOM; 987 988 SwPageNumberFieldType* pTyp = 989 (SwPageNumberFieldType*)pCurShell->GetFldType(0, RES_PAGENUMBERFLD); 990 pFld = new SwPageNumberField(pTyp, nSubType, nFormatId, nOff); 991 992 if( SVX_NUM_CHAR_SPECIAL == nFormatId && 993 ( PG_PREV == nSubType || PG_NEXT == nSubType ) ) 994 ((SwPageNumberField*)pFld)->SetUserString( rData.sPar2 ); 995 break; 996 } 997 998 case TYP_DOCSTATFLD: 999 { 1000 SwDocStatFieldType* pTyp = 1001 (SwDocStatFieldType*)pCurShell->GetFldType(0, RES_DOCSTATFLD); 1002 pFld = new SwDocStatField(pTyp, nSubType, nFormatId); 1003 break; 1004 } 1005 1006 case TYP_AUTHORFLD: 1007 { 1008 SwAuthorFieldType* pTyp = 1009 (SwAuthorFieldType*)pCurShell->GetFldType(0, RES_AUTHORFLD); 1010 pFld = new SwAuthorField(pTyp, nFormatId); 1011 break; 1012 } 1013 1014 case TYP_CONDTXTFLD: 1015 case TYP_HIDDENTXTFLD: 1016 { 1017 SwHiddenTxtFieldType* pTyp = 1018 (SwHiddenTxtFieldType*)pCurShell->GetFldType(0, RES_HIDDENTXTFLD); 1019 pFld = new SwHiddenTxtField(pTyp, sal_True, rData.sPar1, rData.sPar2, sal_False, rData.nTypeId); 1020 bExp = sal_True; 1021 break; 1022 } 1023 1024 case TYP_HIDDENPARAFLD: 1025 { 1026 SwHiddenParaFieldType* pTyp = 1027 (SwHiddenParaFieldType*)pCurShell->GetFldType(0, RES_HIDDENPARAFLD); 1028 pFld = new SwHiddenParaField(pTyp, rData.sPar1); 1029 bExp = sal_True; 1030 break; 1031 } 1032 1033 case TYP_SETREFFLD: 1034 { 1035 if( rData.sPar1.Len() > 0 && CanInsertRefMark( rData.sPar1 ) ) 1036 { 1037 pCurShell->SetAttrItem( SwFmtRefMark( rData.sPar1 ) ); 1038 return sal_True; 1039 } 1040 return sal_False; 1041 } 1042 1043 case TYP_GETREFFLD: 1044 { 1045 SwGetRefFieldType* pTyp = 1046 (SwGetRefFieldType*)pCurShell->GetFldType(0, RES_GETREFFLD); 1047 sal_uInt16 nSeqNo = (sal_uInt16)rData.sPar2.ToInt32(); 1048 pFld = new SwGetRefField(pTyp, rData.sPar1, nSubType, nSeqNo, nFormatId); 1049 bExp = sal_True; 1050 break; 1051 } 1052 1053 case TYP_DDEFLD: 1054 { 1055 //JP 28.08.95: DDE-Topics/-Items koennen Blanks in ihren 1056 // Namen haben! Wird hier noch nicht beachtet. 1057 String sCmd( rData.sPar2 ); 1058 sal_uInt16 nTmpPos = sCmd.SearchAndReplace( ' ', sfx2::cTokenSeperator ); 1059 sCmd.SearchAndReplace( ' ', sfx2::cTokenSeperator, nTmpPos ); 1060 1061 SwDDEFieldType aType( rData.sPar1, sCmd, (sal_uInt16) nFormatId ); 1062 SwDDEFieldType* pTyp = (SwDDEFieldType*) pCurShell->InsertFldType( aType ); 1063 pFld = new SwDDEField( pTyp ); 1064 break; 1065 } 1066 1067 case TYP_MACROFLD: 1068 { 1069 SwMacroFieldType* pTyp = 1070 (SwMacroFieldType*)pCurShell->GetFldType(0, RES_MACROFLD); 1071 1072 pFld = new SwMacroField(pTyp, rData.sPar1, rData.sPar2); 1073 1074 break; 1075 } 1076 1077 case TYP_INTERNETFLD: 1078 { 1079 SwFmtINetFmt aFmt( rData.sPar1, sCurFrame ); 1080 if( pMacroItem ) 1081 aFmt.SetMacroTbl( &pMacroItem->GetMacroTable() ); 1082 return pCurShell->InsertURL( aFmt, rData.sPar2 ); 1083 } 1084 1085 case TYP_JUMPEDITFLD: 1086 { 1087 SwJumpEditFieldType* pTyp = 1088 (SwJumpEditFieldType*)pCurShell->GetFldType(0, RES_JUMPEDITFLD); 1089 1090 pFld = new SwJumpEditField(pTyp, nFormatId, rData.sPar1, rData.sPar2 ); 1091 break; 1092 } 1093 1094 case TYP_DOCINFOFLD: 1095 { 1096 SwDocInfoFieldType* pTyp = (SwDocInfoFieldType*)pCurShell->GetFldType( 1097 0, RES_DOCINFOFLD ); 1098 pFld = new SwDocInfoField(pTyp, nSubType, rData.sPar1, nFormatId); 1099 break; 1100 } 1101 1102 case TYP_EXTUSERFLD: 1103 { 1104 SwExtUserFieldType* pTyp = (SwExtUserFieldType*)pCurShell->GetFldType( 1105 0, RES_EXTUSERFLD); 1106 pFld = new SwExtUserField(pTyp, nSubType, nFormatId); 1107 break; 1108 } 1109 1110 case TYP_DBFLD: 1111 { 1112 SwDBData aDBData; 1113 String sPar1; 1114 1115 if (rData.sPar1.Search(DB_DELIM) == STRING_NOTFOUND) 1116 { 1117 aDBData = pCurShell->GetDBData(); 1118 sPar1 = rData.sPar1; 1119 } 1120 else 1121 { 1122 aDBData.sDataSource = rData.sPar1.GetToken(0, DB_DELIM); 1123 aDBData.sCommand = rData.sPar1.GetToken(1, DB_DELIM); 1124 aDBData.nCommandType = rData.sPar1.GetToken(2, DB_DELIM).ToInt32(); 1125 sPar1 = rData.sPar1.GetToken(3, DB_DELIM); 1126 } 1127 1128 if(aDBData.sDataSource.getLength() && pCurShell->GetDBData() != aDBData) 1129 pCurShell->ChgDBData(aDBData); 1130 1131 SwDBFieldType* pTyp = (SwDBFieldType*)pCurShell->InsertFldType( 1132 SwDBFieldType(pCurShell->GetDoc(), sPar1, aDBData) ); 1133 pFld = new SwDBField(pTyp); 1134 pFld->SetSubType(nSubType); 1135 1136 if( !(nSubType & nsSwExtendedSubType::SUB_OWN_FMT) ) // Datenbankformat ermitteln 1137 { 1138 Reference< XDataSource> xSource; 1139 rData.aDBDataSource >>= xSource; 1140 Reference<XConnection> xConnection; 1141 rData.aDBConnection >>= xConnection; 1142 Reference<XPropertySet> xColumn; 1143 rData.aDBColumn >>= xColumn; 1144 if(xColumn.is()) 1145 { 1146 nFormatId = pCurShell->GetNewDBMgr()->GetColumnFmt(xSource, xConnection, xColumn, 1147 pCurShell->GetNumberFormatter(), GetCurrLanguage() ); 1148 } 1149 else 1150 nFormatId = pCurShell->GetNewDBMgr()->GetColumnFmt( 1151 aDBData.sDataSource, aDBData.sCommand, sPar1, 1152 pCurShell->GetNumberFormatter(), GetCurrLanguage() ); 1153 } 1154 pFld->ChangeFormat( nFormatId ); 1155 1156 bExp = sal_True; 1157 break; 1158 } 1159 1160 case TYP_DBSETNUMBERFLD: 1161 case TYP_DBNUMSETFLD: 1162 case TYP_DBNEXTSETFLD: 1163 case TYP_DBNAMEFLD: 1164 { 1165 sal_uInt16 nPos, nTablePos, nCmdTypePos, nExpPos; 1166 String sPar1; 1167 SwDBData aDBData; 1168 1169 // DBName aus rData.sPar1 extrahieren. Format: DBName.TableName.CommandType.ExpStrg 1170 if ((nTablePos = rData.sPar1.Search(DB_DELIM)) != STRING_NOTFOUND) 1171 aDBData.sDataSource = rData.sPar1.Copy(0, nTablePos++); 1172 if ((nCmdTypePos = rData.sPar1.Search(DB_DELIM, nTablePos)) != STRING_NOTFOUND) 1173 { 1174 aDBData.sCommand = rData.sPar1.Copy(nTablePos, nCmdTypePos++ - nTablePos); 1175 } 1176 if ((nExpPos = rData.sPar1.Search(DB_DELIM, nCmdTypePos)) != STRING_NOTFOUND) 1177 { 1178 aDBData.nCommandType = rData.sPar1.Copy(nCmdTypePos, nExpPos++ - nCmdTypePos).ToInt32(); 1179 } 1180 if (nExpPos != STRING_NOTFOUND) 1181 nPos = nExpPos; 1182 else if (nTablePos != STRING_NOTFOUND) 1183 nPos = nTablePos; 1184 else 1185 nPos = 0; 1186 sPar1 = rData.sPar1.Copy(nPos); 1187 1188 if (aDBData.sDataSource.getLength() && pCurShell->GetDBData() != aDBData) 1189 pCurShell->ChgDBData(aDBData); 1190 1191 switch(rData.nTypeId) 1192 { 1193 case TYP_DBNAMEFLD: 1194 { 1195 SwDBNameFieldType* pTyp = 1196 (SwDBNameFieldType*)pCurShell->GetFldType(0, RES_DBNAMEFLD); 1197 pFld = new SwDBNameField(pTyp, aDBData); 1198 1199 break; 1200 } 1201 case TYP_DBNEXTSETFLD: 1202 { 1203 SwDBNextSetFieldType* pTyp = (SwDBNextSetFieldType*)pCurShell->GetFldType( 1204 0, RES_DBNEXTSETFLD); 1205 pFld = new SwDBNextSetField(pTyp, sPar1, rData.sPar2, aDBData); 1206 bExp = sal_True; 1207 break; 1208 } 1209 case TYP_DBNUMSETFLD: 1210 { 1211 SwDBNumSetFieldType* pTyp = (SwDBNumSetFieldType*)pCurShell->GetFldType( 1212 0, RES_DBNUMSETFLD); 1213 pFld = new SwDBNumSetField( pTyp, sPar1, rData.sPar2, aDBData); 1214 bExp = sal_True; 1215 break; 1216 } 1217 case TYP_DBSETNUMBERFLD: 1218 { 1219 SwDBSetNumberFieldType* pTyp = (SwDBSetNumberFieldType*) 1220 pCurShell->GetFldType(0, RES_DBSETNUMBERFLD); 1221 pFld = new SwDBSetNumberField( pTyp, aDBData, nFormatId); 1222 bExp = sal_True; 1223 break; 1224 } 1225 } 1226 break; 1227 } 1228 1229 case TYP_USERFLD: 1230 { 1231 SwUserFieldType* pTyp = 1232 (SwUserFieldType*)pCurShell->GetFldType(RES_USERFLD, rData.sPar1); 1233 1234 // nur wenn vorhanden 1235 if(!pTyp) 1236 { 1237 pTyp = (SwUserFieldType*)pCurShell->InsertFldType( 1238 SwUserFieldType(pCurShell->GetDoc(), rData.sPar1)); 1239 } 1240 if (pTyp->GetContent(nFormatId) != rData.sPar2) 1241 pTyp->SetContent(rData.sPar2, nFormatId); 1242 pFld = new SwUserField(pTyp, 0, nFormatId); 1243 if (pFld->GetSubType() != nSubType) 1244 pFld->SetSubType(nSubType); 1245 bTbl = sal_True; 1246 break; 1247 } 1248 1249 case TYP_INPUTFLD: 1250 { 1251 if ((nSubType & 0x00ff) == INP_VAR) 1252 { 1253 SwSetExpFieldType* pTyp = (SwSetExpFieldType*) 1254 pCurShell->GetFldType(RES_SETEXPFLD, rData.sPar1); 1255 1256 // kein Experssion Type mit dem Namen vorhanden -> anlegen 1257 if(pTyp) 1258 { 1259 SwSetExpField* pExpFld = 1260 new SwSetExpField(pTyp, aEmptyStr, nFormatId); 1261 1262 // Typ vom SwSetExpFieldType nicht veraendern: 1263 sal_uInt16 nOldSubType = pExpFld->GetSubType(); 1264 pExpFld->SetSubType(nOldSubType | (nSubType & 0xff00)); 1265 1266 pExpFld->SetPromptText(rData.sPar2); 1267 pExpFld->SetInputFlag(sal_True) ; 1268 bExp = sal_True; 1269 pFld = pExpFld; 1270 } 1271 else 1272 return sal_False; 1273 } 1274 else 1275 { 1276 SwInputFieldType* pTyp = 1277 (SwInputFieldType*)pCurShell->GetFldType(0, RES_INPUTFLD); 1278 1279 SwInputField* pInpFld = 1280 new SwInputField( pTyp, rData.sPar1, rData.sPar2, nSubType|nsSwExtendedSubType::SUB_INVISIBLE, nFormatId); 1281 pFld = pInpFld; 1282 } 1283 1284 // Dialog starten 1285 // 1286 pCurShell->StartInputFldDlg(pFld, sal_False, rData.pParent); 1287 break; 1288 } 1289 1290 case TYP_SETFLD: 1291 { 1292 if (!rData.sPar2.Len()) // Leere Variablen sind nicht erlaubt 1293 return sal_False; 1294 1295 SwSetExpFieldType* pTyp = (SwSetExpFieldType*)pCurShell->InsertFldType( 1296 SwSetExpFieldType(pCurShell->GetDoc(), rData.sPar1) ); 1297 1298 SwSetExpField* pExpFld = new SwSetExpField( pTyp, rData.sPar2, nFormatId); 1299 pExpFld->SetSubType(nSubType); 1300 pExpFld->SetPar2(rData.sPar2); 1301 bExp = sal_True; 1302 pFld = pExpFld; 1303 break; 1304 } 1305 1306 case TYP_SEQFLD: 1307 { 1308 SwSetExpFieldType* pTyp = (SwSetExpFieldType*)pCurShell->InsertFldType( 1309 SwSetExpFieldType(pCurShell->GetDoc(), rData.sPar1, nsSwGetSetExpType::GSE_SEQ)); 1310 1311 sal_uInt8 nLevel = static_cast< sal_uInt8 >(nSubType & 0xff); 1312 1313 pTyp->SetOutlineLvl(nLevel); 1314 if (nLevel != 0x7f && cSeparator == 0) 1315 cSeparator = '.'; 1316 1317 pTyp->SetDelimiter(cSeparator); 1318 SwSetExpField* pExpFld = new SwSetExpField(pTyp, rData.sPar2, nFormatId); 1319 bExp = sal_True; 1320 pFld = pExpFld; 1321 nSubType = nsSwGetSetExpType::GSE_SEQ; 1322 break; 1323 } 1324 1325 case TYP_GETFLD: 1326 { 1327 // gibt es ein entprechendes SetField 1328 SwSetExpFieldType* pSetTyp = (SwSetExpFieldType*) 1329 pCurShell->GetFldType(RES_SETEXPFLD, rData.sPar1); 1330 1331 if(pSetTyp) 1332 { 1333 SwGetExpFieldType* pTyp = (SwGetExpFieldType*)pCurShell->GetFldType( 1334 0, RES_GETEXPFLD); 1335 pFld = new SwGetExpField(pTyp, rData.sPar1, pSetTyp->GetType(), nFormatId); 1336 pFld->SetSubType(nSubType | pSetTyp->GetType()); 1337 bExp = sal_True; 1338 } 1339 else 1340 return sal_False; 1341 break; 1342 } 1343 1344 case TYP_FORMELFLD: 1345 { 1346 if(pCurShell->GetFrmType(0,sal_False) & FRMTYPE_TABLE) 1347 { 1348 pCurShell->StartAllAction(); 1349 1350 SvNumberFormatter* pFormatter = pCurShell->GetDoc()->GetNumberFormatter(); 1351 const SvNumberformat* pEntry = pFormatter->GetEntry(nFormatId); 1352 1353 if (pEntry) 1354 { 1355 SfxStringItem aFormat(FN_NUMBER_FORMAT, pEntry->GetFormatstring()); 1356 pCurShell->GetView().GetViewFrame()->GetDispatcher()-> 1357 Execute(FN_NUMBER_FORMAT, SFX_CALLMODE_SYNCHRON, &aFormat, 0L); 1358 } 1359 1360 SfxItemSet aBoxSet( pCurShell->GetAttrPool(), 1361 RES_BOXATR_FORMULA, RES_BOXATR_FORMULA ); 1362 1363 String sFml( rData.sPar2 ); 1364 if( sFml.EraseLeadingChars().Len() && 1365 '=' == sFml.GetChar( 0 ) ) 1366 sFml.Erase( 0, 1 ); 1367 1368 aBoxSet.Put( SwTblBoxFormula( sFml )); 1369 pCurShell->SetTblBoxFormulaAttrs( aBoxSet ); 1370 pCurShell->UpdateTable(); 1371 1372 pCurShell->EndAllAction(); 1373 return sal_True; 1374 1375 /* // In der Tabelle Tabellenformeln einfuegen 1376 SwTblFieldType* pTyp = (SwTblFieldType*)pCurShell->GetFldType( 1377 0, RES_TABLEFLD); 1378 pFld = new SwTblField(pTyp, rData.sPar2, nsSwGetSetExpType::GSE_EXPR, nFormatId); 1379 bTbl = sal_True;*/ 1380 } 1381 else 1382 { 1383 SwGetExpFieldType* pTyp = (SwGetExpFieldType*) 1384 pCurShell->GetFldType(0, RES_GETEXPFLD); 1385 pFld = new SwGetExpField(pTyp, rData.sPar2, nsSwGetSetExpType::GSE_FORMULA, nFormatId); 1386 pFld->SetSubType(nSubType); 1387 bExp = sal_True; 1388 } 1389 break; 1390 } 1391 1392 case TYP_SETREFPAGEFLD: 1393 pFld = new SwRefPageSetField( (SwRefPageSetFieldType*) 1394 pCurShell->GetFldType( 0, RES_REFPAGESETFLD ), 1395 (short)rData.sPar2.ToInt32(), 0 != nSubType ); 1396 bPageVar = sal_True; 1397 break; 1398 1399 case TYP_GETREFPAGEFLD: 1400 pFld = new SwRefPageGetField( (SwRefPageGetFieldType*) 1401 pCurShell->GetFldType( 0, RES_REFPAGEGETFLD ), nFormatId ); 1402 bPageVar = sal_True; 1403 break; 1404 1405 case TYP_DROPDOWN : 1406 { 1407 pFld = new SwDropDownField(pCurShell->GetFldType( 0, RES_DROPDOWN )); 1408 xub_StrLen nTokenCount = rData.sPar2.Len() ? rData.sPar2.GetTokenCount(DB_DELIM) : 0; 1409 Sequence<OUString> aEntries(nTokenCount); 1410 OUString* pArray = aEntries.getArray(); 1411 for(xub_StrLen nToken = 0; nToken < nTokenCount; nToken++) 1412 pArray[nToken] = rData.sPar2.GetToken(nToken, DB_DELIM); 1413 ((SwDropDownField*)pFld)->SetItems(aEntries); 1414 ((SwDropDownField*)pFld)->SetName(rData.sPar1); 1415 } 1416 break; 1417 1418 default: 1419 { 1420 ASSERT(!this, "Falscher Feldtyp"); 1421 return sal_False; 1422 } 1423 } 1424 ASSERT(pFld, "Feld nicht vorhanden"); 1425 1426 1427 //the auto language flag has to be set prior to the language! 1428 pFld->SetAutomaticLanguage(rData.bIsAutomaticLanguage); 1429 sal_uInt16 nLang = GetCurrLanguage(); 1430 pFld->SetLanguage(nLang); 1431 1432 // Einfuegen 1433 pCurShell->StartAllAction(); 1434 1435 pCurShell->Insert( *pFld ); 1436 1437 if(bExp && bEvalExp) 1438 pCurShell->UpdateExpFlds(sal_True); 1439 1440 if(bTbl) 1441 { 1442 pCurShell->Left(CRSR_SKIP_CHARS, sal_False, 1, sal_False ); 1443 pCurShell->UpdateFlds(*pFld); 1444 pCurShell->Right(CRSR_SKIP_CHARS, sal_False, 1, sal_False ); 1445 } 1446 else if( bPageVar ) 1447 ((SwRefPageGetFieldType*)pCurShell->GetFldType( 0, RES_REFPAGEGETFLD ))->UpdateFlds(); 1448 else if( TYP_GETREFFLD == rData.nTypeId ) 1449 pFld->GetTyp()->ModifyNotification( 0, 0 ); 1450 1451 // temporaeres Feld loeschen 1452 delete pFld; 1453 1454 pCurShell->EndAllAction(); 1455 return sal_True; 1456 } 1457 1458 /*-------------------------------------------------------------------- 1459 Beschreibung: Felder Update 1460 --------------------------------------------------------------------*/ 1461 1462 1463 void SwFldMgr::UpdateCurFld(sal_uLong nFormat, 1464 const String& rPar1, 1465 const String& rPar2, 1466 SwField * _pTmpFld) // #111840# 1467 { 1468 // Format aendern 1469 ASSERT(pCurFld, "kein Feld an der CursorPos"); 1470 1471 bool bDelete = false; 1472 SwField *pTmpFld; // mb: fixed memory leak 1473 if (NULL != _pTmpFld) 1474 { 1475 pTmpFld = _pTmpFld; 1476 } 1477 else 1478 { 1479 pTmpFld = pCurFld->CopyField(); 1480 bDelete = true; 1481 } 1482 1483 SwFieldType* pType = pTmpFld->GetTyp(); 1484 const sal_uInt16 nTypeId = pTmpFld->GetTypeId(); 1485 1486 SwWrtShell* pSh = pWrtShell ? pWrtShell : ::lcl_GetShell(); 1487 DBG_ASSERT(pSh, "no SwWrtShell found"); 1488 if(!pSh) 1489 return; 1490 pSh->StartAllAction(); 1491 1492 sal_Bool bSetPar2 = sal_True; 1493 sal_Bool bSetPar1 = sal_True; 1494 String sPar1( rPar1 ); 1495 String sPar2( rPar2 ); 1496 1497 // Order to Format 1498 switch( nTypeId ) 1499 { 1500 case TYP_DDEFLD: 1501 { 1502 //JP 28.08.95: DDE-Topics/-Items koennen Blanks in ihren 1503 // Namen haben! Wird hier noch nicht beachtet. 1504 sal_uInt16 nTmpPos = sPar2.SearchAndReplace( ' ', sfx2::cTokenSeperator ); 1505 sPar2.SearchAndReplace( ' ', sfx2::cTokenSeperator, nTmpPos ); 1506 break; 1507 } 1508 1509 case TYP_CHAPTERFLD: 1510 { 1511 sal_uInt16 nByte = (sal_uInt16)rPar2.ToInt32(); 1512 nByte = Max(sal_uInt16(1), nByte); 1513 nByte = Min(nByte, sal_uInt16(MAXLEVEL)); 1514 nByte -= 1; 1515 ((SwChapterField*)pTmpFld)->SetLevel((sal_uInt8)nByte); 1516 bSetPar2 = sal_False; 1517 break; 1518 } 1519 1520 case TYP_SCRIPTFLD: 1521 ((SwScriptField*)pTmpFld)->SetCodeURL((sal_Bool)nFormat); 1522 break; 1523 1524 case TYP_NEXTPAGEFLD: 1525 if( SVX_NUM_CHAR_SPECIAL == nFormat ) 1526 { 1527 ((SwPageNumberField*)pCurFld)->SetUserString( sPar2 ); 1528 sPar2 = '1'; 1529 } 1530 else 1531 { 1532 if( nFormat + 2 == SVX_NUM_PAGEDESC ) 1533 nFormat = SVX_NUM_PAGEDESC; 1534 short nOff = (short)sPar2.ToInt32(); 1535 nOff += 1; 1536 sPar2 = String::CreateFromInt32(nOff); 1537 } 1538 break; 1539 1540 case TYP_PREVPAGEFLD: 1541 if( SVX_NUM_CHAR_SPECIAL == nFormat ) 1542 { 1543 ((SwPageNumberField*)pCurFld)->SetUserString( sPar2 ); 1544 sPar2 = String::CreateFromAscii( 1545 RTL_CONSTASCII_STRINGPARAM("-1")); 1546 } 1547 else 1548 { 1549 if( nFormat + 2 == SVX_NUM_PAGEDESC ) 1550 nFormat = SVX_NUM_PAGEDESC; 1551 short nOff = (short)sPar2.ToInt32(); 1552 nOff -= 1; 1553 sPar2 = String::CreateFromInt32(nOff); 1554 } 1555 break; 1556 1557 case TYP_PAGENUMBERFLD: 1558 case TYP_GETREFPAGEFLD: 1559 if( nFormat + 2 == SVX_NUM_PAGEDESC ) 1560 nFormat = SVX_NUM_PAGEDESC; 1561 break; 1562 1563 case TYP_GETREFFLD: 1564 { 1565 bSetPar2 = sal_False; 1566 ((SwGetRefField*)pTmpFld)->SetSubType( (sal_uInt16)rPar2.ToInt32() ); 1567 sal_uInt16 nPos = rPar2.Search( '|' ); 1568 if( STRING_NOTFOUND != nPos ) 1569 ((SwGetRefField*)pTmpFld)->SetSeqNo( (sal_uInt16)rPar2.Copy( nPos + 1 ).ToInt32()); 1570 } 1571 break; 1572 case TYP_DROPDOWN: 1573 { 1574 xub_StrLen nTokenCount = sPar2.Len() ? sPar2.GetTokenCount(DB_DELIM) : 0; 1575 Sequence<OUString> aEntries(nTokenCount); 1576 OUString* pArray = aEntries.getArray(); 1577 for(xub_StrLen nToken = 0; nToken < nTokenCount; nToken++) 1578 pArray[nToken] = sPar2.GetToken(nToken, DB_DELIM); 1579 ((SwDropDownField*)pTmpFld)->SetItems(aEntries); 1580 ((SwDropDownField*)pTmpFld)->SetName(sPar1); 1581 bSetPar1 = bSetPar2 = sal_False; 1582 } 1583 break; 1584 case TYP_AUTHORITY : 1585 { 1586 //#i99069# changes to a bibliography field should change the field type 1587 SwAuthorityField* pAuthorityField = static_cast<SwAuthorityField*>(pTmpFld); 1588 SwAuthorityFieldType* pAuthorityType = static_cast<SwAuthorityFieldType*>(pType); 1589 SwAuthEntry aTempEntry; 1590 for( sal_uInt16 i = 0; i < AUTH_FIELD_END; ++i ) 1591 aTempEntry.SetAuthorField( (ToxAuthorityField)i, 1592 rPar1.GetToken( i, TOX_STYLE_DELIMITER )); 1593 if( pAuthorityType->ChangeEntryContent( &aTempEntry ) ) 1594 { 1595 pType->UpdateFlds(); 1596 pSh->SetModified(); 1597 } 1598 1599 if( aTempEntry.GetAuthorField( AUTH_FIELD_IDENTIFIER ) == 1600 pAuthorityField->GetFieldText( AUTH_FIELD_IDENTIFIER ) ) 1601 bSetPar1 = sal_False; //otherwise it's a new or changed entry, the field needs to be updated 1602 bSetPar2 = sal_False; 1603 } 1604 break; 1605 } 1606 1607 // Format setzen 1608 // Format wegen NumberFormatter vor SetPar2 einstellen! 1609 pTmpFld->ChangeFormat(nFormat); 1610 1611 if(bSetPar1) 1612 pTmpFld->SetPar1( sPar1 ); 1613 if( bSetPar2 ) 1614 pTmpFld->SetPar2( sPar2 ); 1615 1616 // Update anschmeissen 1617 if(nTypeId == TYP_DDEFLD || 1618 nTypeId == TYP_USERFLD || 1619 nTypeId == TYP_USRINPFLD) 1620 { 1621 pType->UpdateFlds(); 1622 pSh->SetModified(); 1623 } 1624 else { 1625 // mb: #32157 1626 pSh->SwEditShell::UpdateFlds(*pTmpFld); 1627 GetCurFld(); 1628 } 1629 1630 if (bDelete) 1631 delete pTmpFld; 1632 1633 pSh->EndAllAction(); 1634 } 1635 1636 /*-------------------------------------------------------------------- 1637 Beschreibung: ExpressionFields explizit evaluieren 1638 --------------------------------------------------------------------*/ 1639 void SwFldMgr::EvalExpFlds(SwWrtShell* pSh) 1640 { 1641 if (pSh == NULL) 1642 pSh = pWrtShell ? pWrtShell : ::lcl_GetShell(); 1643 1644 if(pSh) 1645 { 1646 pSh->StartAllAction(); 1647 pSh->UpdateExpFlds(sal_True); 1648 pSh->EndAllAction(); 1649 } 1650 } 1651 sal_uInt16 SwFldMgr::GetCurrLanguage() const 1652 { 1653 SwWrtShell* pSh = pWrtShell ? pWrtShell : ::lcl_GetShell(); 1654 if( pSh ) 1655 return pSh->GetCurLang(); 1656 return SvxLocaleToLanguage( SvtSysLocale().GetLocaleData().getLocale() ); 1657 } 1658 1659 void SwFieldType::_GetFldName() 1660 { 1661 // mba: this is an awful mess; a fix is available, but too much for 3.4 -> applay plaster 1662 static const sal_uInt16 coFldCnt = 43; 1663 1664 static sal_uInt16 __READONLY_DATA coFldNms[ coFldCnt ] = { 1665 FLD_DATE_STD, 1666 FLD_TIME_STD, 1667 STR_FILENAMEFLD, 1668 STR_DBNAMEFLD, 1669 STR_CHAPTERFLD, 1670 STR_PAGENUMBERFLD, 1671 STR_DOCSTATFLD, 1672 STR_AUTHORFLD, 1673 STR_SETFLD, 1674 STR_GETFLD, 1675 STR_FORMELFLD, 1676 STR_HIDDENTXTFLD, 1677 STR_SETREFFLD, 1678 STR_GETREFFLD, 1679 STR_DDEFLD, 1680 STR_MACROFLD, 1681 STR_INPUTFLD, 1682 STR_HIDDENPARAFLD, 1683 STR_DOCINFOFLD, 1684 STR_DBFLD, 1685 STR_USERFLD, 1686 STR_POSTITFLD, 1687 STR_TEMPLNAMEFLD, 1688 STR_SEQFLD, 1689 STR_DBNEXTSETFLD, 1690 STR_DBNUMSETFLD, 1691 STR_DBSETNUMBERFLD, 1692 STR_CONDTXTFLD, 1693 STR_NEXTPAGEFLD, 1694 STR_PREVPAGEFLD, 1695 STR_EXTUSERFLD, 1696 FLD_DATE_FIX, 1697 FLD_TIME_FIX, 1698 STR_SETINPUTFLD, 1699 STR_USRINPUTFLD, 1700 STR_SETREFPAGEFLD, 1701 STR_GETREFPAGEFLD, 1702 STR_INTERNETFLD, 1703 STR_JUMPEDITFLD, 1704 STR_SCRIPTFLD, 1705 STR_AUTHORITY, 1706 STR_COMBINED_CHARS, 1707 STR_DROPDOWN 1708 }; 1709 1710 // Infos fuer Felder einfuegen 1711 SwFieldType::pFldNames = new SvStringsDtor( (sal_uInt8)coFldCnt, 2 ); 1712 for( sal_uInt16 nIdx = 0; nIdx < coFldCnt; ++nIdx ) 1713 { 1714 String* pTmp = new SW_RESSTR( coFldNms[ nIdx ] ); 1715 pTmp->Assign( MnemonicGenerator::EraseAllMnemonicChars( *pTmp ) ); 1716 SwFieldType::pFldNames->Insert(pTmp, nIdx ); 1717 } 1718 } 1719 1720 /*-------------------------------------------------------------------- 1721 Beschreibung: 1722 --------------------------------------------------------------------*/ 1723 1724 sal_Bool SwFldMgr::ChooseMacro(const String&) 1725 { 1726 sal_Bool bRet = sal_False; 1727 1728 // choose script dialog 1729 ::rtl::OUString aScriptURL = SfxApplication::ChooseScript(); 1730 1731 // the script selector dialog returns a valid script URL 1732 if ( aScriptURL.getLength() != 0 ) 1733 { 1734 SetMacroPath( aScriptURL ); 1735 bRet = sal_True; 1736 } 1737 1738 return bRet; 1739 } 1740 1741 void SwFldMgr::SetMacroPath(const String& rPath) 1742 { 1743 sMacroPath = rPath; 1744 sMacroName = rPath; 1745 1746 // try to set sMacroName member variable by parsing the macro path 1747 // using the new URI parsing services 1748 1749 Reference< XMultiServiceFactory > xSMgr = 1750 ::comphelper::getProcessServiceFactory(); 1751 1752 Reference< uri::XUriReferenceFactory > 1753 xFactory( xSMgr->createInstance( 1754 ::rtl::OUString::createFromAscii( 1755 "com.sun.star.uri.UriReferenceFactory" ) ), UNO_QUERY ); 1756 1757 if ( xFactory.is() ) 1758 { 1759 Reference< uri::XVndSunStarScriptUrl > 1760 xUrl( xFactory->parse( sMacroPath ), UNO_QUERY ); 1761 1762 if ( xUrl.is() ) 1763 { 1764 sMacroName = xUrl->getName(); 1765 } 1766 } 1767 } 1768 1769 /*-------------------------------------------------------------------- 1770 Beschreibung: 1771 --------------------------------------------------------------------*/ 1772 1773 sal_uLong SwFldMgr::GetDefaultFormat(sal_uInt16 nTypeId, sal_Bool bIsText, SvNumberFormatter* pFormatter, double* pVal) 1774 { 1775 double fValue; 1776 short nDefFormat; 1777 1778 switch (nTypeId) 1779 { 1780 case TYP_TIMEFLD: 1781 case TYP_DATEFLD: 1782 { 1783 Date aDate; 1784 Date* pNullDate = pFormatter->GetNullDate(); 1785 1786 fValue = aDate - *pNullDate; 1787 1788 Time aTime; 1789 1790 sal_uLong nNumFmtTime = (sal_uLong)aTime.GetSec() + (sal_uLong)aTime.GetMin() * 60L + 1791 (sal_uLong)aTime.GetHour() * 3600L; 1792 1793 fValue += (double)nNumFmtTime / 86400.0; 1794 1795 nDefFormat = (nTypeId == TYP_DATEFLD) ? NUMBERFORMAT_DATE : NUMBERFORMAT_TIME; 1796 } 1797 break; 1798 1799 default: 1800 if (bIsText) 1801 { 1802 fValue = 0.0; 1803 nDefFormat = NUMBERFORMAT_TEXT; 1804 } 1805 else 1806 { 1807 fValue = 0.0; 1808 nDefFormat = NUMBERFORMAT_ALL; 1809 } 1810 break; 1811 } 1812 1813 if (pVal) 1814 *pVal = fValue; 1815 1816 return pFormatter->GetStandardFormat(nDefFormat, GetCurrLanguage()); 1817 } 1818 1819 /* -----------------------------01.03.01 16:46-------------------------------- 1820 1821 ---------------------------------------------------------------------------*/ 1822 Reference<XNumberingTypeInfo> SwFldMgr::GetNumberingInfo() const 1823 { 1824 if(!xNumberingInfo.is()) 1825 { 1826 Reference< XMultiServiceFactory > xMSF = ::comphelper::getProcessServiceFactory(); 1827 Reference < XInterface > xI = xMSF->createInstance( 1828 ::rtl::OUString::createFromAscii( 1829 "com.sun.star.text.DefaultNumberingProvider" )); 1830 Reference<XDefaultNumberingProvider> xDefNum(xI, UNO_QUERY); 1831 DBG_ASSERT(xDefNum.is(), "service missing: \"com.sun.star.text.DefaultNumberingProvider\""); 1832 ((SwFldMgr*)this)->xNumberingInfo = Reference<XNumberingTypeInfo>(xDefNum, UNO_QUERY); 1833 } 1834 return xNumberingInfo; 1835 } 1836