sw/source/core/fields/fldbas.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: fldbas.cxx,v $
  10  * $Revision: 1.27 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sw.hxx"
  33
  34
  35 // #include <math.h>
  36 #include <float.h>
  37 #include <rtl/math.hxx>
  38 #include <svtools/zforlist.hxx>
  39 #include <svtools/zformat.hxx>
  40 #include <svx/unolingu.hxx>
  41 #ifndef _UNOFLDMID_H
  42 #include <unofldmid.h>
  43 #endif
  44 #include <doc.hxx>
  45 #include <editsh.hxx>
  46 #include <frame.hxx>
  47 #include <fldbas.hxx>
  48 #include <flddat.hxx>
  49 #include <ndtxt.hxx>
  50 #include <fmtfld.hxx>
  51 #include <txtfld.hxx>
  52 #include <pam.hxx>
  53 #include <docfld.hxx>
  54 #include <swtable.hxx>
  55 #include <docufld.hxx>
  56 #include <expfld.hxx>
  57 #include <shellres.hxx>
  58 #include <calc.hxx>
  59 #ifndef _COMCORE_HRC
  60 #include <comcore.hrc>
  61 #endif
  62
  63 #include <math.h>
  64 #ifdef MAC
  65 #include <stdlib.h>
  66 #endif
  67 #include <float.h>
  68
  69 using namespace ::com::sun::star;
  70 using namespace nsSwDocInfoSubType;
  71
  72 USHORT lcl_GetLanguageOfFormat( USHORT nLng, ULONG nFmt,
  73                                 const SvNumberFormatter& rFormatter )
  74 {
  75     if( nLng == LANGUAGE_NONE ) // wegen Bug #60010
  76         nLng = LANGUAGE_SYSTEM;
  77     else if( nLng == ::GetAppLanguage() )
  78         switch( rFormatter.GetIndexTableOffset( nFmt ))
  79         {
  80         case NF_NUMBER_SYSTEM:
  81         case NF_DATE_SYSTEM_SHORT:
  82         case NF_DATE_SYSTEM_LONG:
  83         case NF_DATETIME_SYSTEM_SHORT_HHMM:
  84             nLng = LANGUAGE_SYSTEM;
  85             break;
  86         default: break;
  87         }
  88     return nLng;
  89 }
  90
  91 /*--------------------------------------------------------------------
  92     Beschreibung: Globals
  93  --------------------------------------------------------------------*/
  94 // Array der Feldname
  95
  96 SvStringsDtor* SwFieldType::pFldNames = 0;
  97
  98 DBG_NAME(SwFieldType)
  99
 100     USHORT __FAR_DATA aTypeTab[] = {
 101     /* RES_DBFLD                        */              TYP_DBFLD,
 102     /* RES_USERFLD                      */              TYP_USERFLD,
 103     /* RES_FILENAMEFLD          */              TYP_FILENAMEFLD,
 104     /* RES_DBNAMEFLD            */              TYP_DBNAMEFLD,
 105     /* RES_DATEFLD                      */              TYP_DATEFLD,
 106     /* RES_TIMEFLD                      */              TYP_TIMEFLD,
 107     /* RES_PAGENUMBERFLD        */              TYP_PAGENUMBERFLD,      // dynamisch
 108     /* RES_AUTHORFLD            */              TYP_AUTHORFLD,
 109     /* RES_CHAPTERFLD           */              TYP_CHAPTERFLD,
 110     /* RES_DOCSTATFLD           */              TYP_DOCSTATFLD,
 111     /* RES_GETEXPFLD            */              TYP_GETFLD,                     // dynamisch
 112     /* RES_SETEXPFLD            */              TYP_SETFLD,                     // dynamisch
 113     /* RES_GETREFFLD            */              TYP_GETREFFLD,
 114     /* RES_HIDDENTXTFLD         */              TYP_HIDDENTXTFLD,
 115     /* RES_POSTITFLD            */              TYP_POSTITFLD,
 116     /* RES_FIXDATEFLD           */              TYP_FIXDATEFLD,
 117     /* RES_FIXTIMEFLD           */              TYP_FIXTIMEFLD,
 118     /* RES_REGFLD                       */              0,                                      // alt
 119     /* RES_VARREGFLD            */              0,                                      // alt
 120     /* RES_SETREFFLD            */              TYP_SETREFFLD,
 121     /* RES_INPUTFLD                     */              TYP_INPUTFLD,
 122     /* RES_MACROFLD                     */              TYP_MACROFLD,
 123     /* RES_DDEFLD                       */              TYP_DDEFLD,
 124     /* RES_TABLEFLD                     */              TYP_FORMELFLD,
 125     /* RES_HIDDENPARAFLD        */              TYP_HIDDENPARAFLD,
 126     /* RES_DOCINFOFLD           */              TYP_DOCINFOFLD,
 127     /* RES_TEMPLNAMEFLD         */              TYP_TEMPLNAMEFLD,
 128     /* RES_DBNEXTSETFLD         */              TYP_DBNEXTSETFLD,
 129     /* RES_DBNUMSETFLD          */              TYP_DBNUMSETFLD,
 130     /* RES_DBSETNUMBERFLD       */              TYP_DBSETNUMBERFLD,
 131     /* RES_EXTUSERFLD           */              TYP_EXTUSERFLD,
 132     /* RES_REFPAGESETFLD        */              TYP_SETREFPAGEFLD,
 133     /* RES_REFPAGEGETFLD    */          TYP_GETREFPAGEFLD,
 134     /* RES_INTERNETFLD          */              TYP_INTERNETFLD,
 135     /* RES_JUMPEDITFLD          */              TYP_JUMPEDITFLD,
 136     /* RES_SCRIPTFLD            */              TYP_SCRIPTFLD,
 137     /* RES_DATETIMEFLD          */              0,                                      // dynamisch
 138     /* RES_AUTHORITY            */              TYP_AUTHORITY,
 139     /* RES_COMBINED_CHARS       */              TYP_COMBINED_CHARS,
 140     /* RES_DROPDOWN         */      TYP_DROPDOWN
 141     };
 142         // ????? TYP_USRINPFLD,
 143
 144
 145
 146 const String& SwFieldType::GetTypeStr(USHORT nTypeId)
 147 {
 148     if( !pFldNames )
 149         _GetFldName();
 150
 151     if( nTypeId < SwFieldType::pFldNames->Count() )
 152         return *SwFieldType::pFldNames->GetObject( nTypeId );
 153     else
 154         return aEmptyStr;
 155 }
 156
 157
 158 /*---------------------------------------------------
 159  Jedes Feld referenziert einen Feldtypen, der fuer
 160  jedes Dokument einmalig ist.
 161  --------------------------------------------------*/
 162
 163 SwFieldType::SwFieldType( USHORT nWhichId )
 164     : SwModify(0),
 165     nWhich( nWhichId )
 166 {
 167     DBG_CTOR( SwFieldType, 0 );
 168 }
 169
 170 #ifndef PRODUCT
 171
 172 SwFieldType::~SwFieldType()
 173 {
 174     DBG_DTOR( SwFieldType, 0 );
 175 }
 176
 177 #endif
 178
 179 const String& SwFieldType::GetName() const
 180 {
 181     return aEmptyStr;
 182 }
 183
 184 BOOL SwFieldType::QueryValue( uno::Any&, USHORT ) const
 185 {
 186     return FALSE;
 187 }
 188 BOOL SwFieldType::PutValue( const uno::Any& , USHORT )
 189 {
 190     return FALSE;
 191 }
 192
 193 /*--------------------------------------------------------------------
 194     Beschreibung:       Basisklasse aller Felder
 195                     Felder referenzieren einen Feldtyp
 196                     Felder sind n-mal vorhanden, Feldtypen nur einmal
 197  --------------------------------------------------------------------*/
 198
 199 SwField::SwField(SwFieldType* pTyp, sal_uInt32 nFmt, USHORT nLng) :
 200     nLang(nLng),
 201     bIsAutomaticLanguage(TRUE),
 202     nFormat(nFmt)
 203 {
 204     ASSERT( pTyp, "SwField: ungueltiger SwFieldType" );
 205     pType = pTyp;
 206 }
 207
 208 SwField::~SwField()
 209 {
 210 }
 211
 212 /*--------------------------------------------------------------------
 213     Beschreibung: Statt Umweg ueber den Typ
 214  --------------------------------------------------------------------*/
 215
 216 #ifndef PRODUCT
 217 USHORT SwField::Which() const
 218 {
 219     ASSERT(pType, "Kein Typ vorhanden");
 220     return pType->Which();
 221 }
 222 #endif
 223
 224 /*--------------------------------------------------------------------
 225     Beschreibung:
 226  --------------------------------------------------------------------*/
 227
 228 USHORT SwField::GetTypeId() const
 229 {
 230
 231     USHORT nRet;
 232     switch( pType->Which() )
 233     {
 234     case RES_DATETIMEFLD:
 235         if (GetSubType() & FIXEDFLD)
 236             nRet = static_cast<USHORT>(GetSubType() & DATEFLD ? TYP_FIXDATEFLD : TYP_FIXTIMEFLD);
 237         else
 238             nRet = static_cast<USHORT>(GetSubType() & DATEFLD ? TYP_DATEFLD : TYP_TIMEFLD);
 239         break;
 240     case RES_GETEXPFLD:
 241         nRet = static_cast<USHORT>(nsSwGetSetExpType::GSE_FORMULA & GetSubType() ? TYP_FORMELFLD : TYP_GETFLD);
 242         break;
 243
 244     case RES_HIDDENTXTFLD:
 245         nRet = GetSubType();
 246         break;
 247
 248     case RES_SETEXPFLD:
 249         if( nsSwGetSetExpType::GSE_SEQ & GetSubType() )
 250             nRet = TYP_SEQFLD;
 251         else if( ((SwSetExpField*)this)->GetInputFlag() )
 252             nRet = TYP_SETINPFLD;
 253         else
 254             nRet = TYP_SETFLD;
 255         break;
 256
 257     case RES_PAGENUMBERFLD:
 258         nRet = GetSubType();
 259         if( PG_NEXT == nRet )
 260             nRet = TYP_NEXTPAGEFLD;
 261         else if( PG_PREV == nRet )
 262             nRet = TYP_PREVPAGEFLD;
 263         else
 264             nRet = TYP_PAGENUMBERFLD;
 265         break;
 266
 267     default:
 268         nRet = aTypeTab[ pType->Which() ];
 269     }
 270     return nRet;
 271 }
 272
 273
 274 /*--------------------------------------------------------------------
 275     Beschreibung: liefert den Namen oder den Inhalt
 276  --------------------------------------------------------------------*/
 277
 278 String SwField::GetCntnt( BOOL bName ) const
 279 {
 280     String sRet;
 281     if( bName )
 282     {
 283         USHORT nTypeId = GetTypeId();
 284         if( RES_DATETIMEFLD == GetTyp()->Which() )
 285             nTypeId = static_cast<USHORT>(GetSubType() & DATEFLD ? TYP_DATEFLD : TYP_TIMEFLD);
 286
 287         sRet = SwFieldType::GetTypeStr( nTypeId );
 288         if( IsFixed() )
 289             ( sRet += ' ' ) += ViewShell::GetShellRes()->aFixedStr;
 290     }
 291     else
 292         sRet = Expand();
 293     return sRet;
 294 }
 295
 296 /*--------------------------------------------------------------------
 297     Beschreibung: Parameter setzen auslesen
 298  --------------------------------------------------------------------*/
 299
 300 const String& SwField::GetPar1() const
 301 {
 302     return aEmptyStr;
 303 }
 304
 305 String SwField::GetPar2() const
 306 {
 307     return aEmptyStr;
 308 }
 309
 310 String SwField::GetFormula() const
 311 {
 312     return GetPar2();
 313 }
 314
 315 void SwField::SetPar1(const String& )
 316 {}
 317
 318 void SwField::SetPar2(const String& )
 319 {}
 320
 321 USHORT SwField::GetSubType() const
 322 {
 323 //      ASSERT(0, "Sorry Not implemented");
 324     return 0;
 325 }
 326
 327 void SwField::SetSubType(USHORT )
 328 {
 329 //      ASSERT(0, "Sorry Not implemented");
 330 }
 331
 332 BOOL  SwField::QueryValue( uno::Any& rVal, USHORT nWhichId ) const
 333 {
 334     switch( nWhichId )
 335     {
 336         case FIELD_PROP_BOOL4:
 337         {
 338             BOOL bFixed = !bIsAutomaticLanguage;
 339             rVal.setValue(&bFixed, ::getCppuBooleanType());
 340         }
 341         break;
 342         default:
 343             DBG_ERROR("illegal property");
 344     }
 345     return TRUE;
 346 }
 347 BOOL SwField::PutValue( const uno::Any& rVal, USHORT nWhichId )
 348 {
 349     switch( nWhichId )
 350     {
 351         case FIELD_PROP_BOOL4:
 352         {
 353             BOOL bFixed = FALSE;
 354             if(rVal >>= bFixed)
 355                 bIsAutomaticLanguage = !bFixed;
 356         }
 357         break;
 358         default:
 359             DBG_ERROR("illegal property");
 360     }
 361     return TRUE;
 362 }
 363
 364
 365 /*--------------------------------------------------------------------
 366     Beschreibung:       neuen Typ setzen
 367                     (wird fuer das Kopieren zwischen Dokumenten benutzt)
 368                     muss immer vom gleichen Typ sein.
 369  --------------------------------------------------------------------*/
 370
 371 SwFieldType* SwField::ChgTyp( SwFieldType* pNewType )
 372 {
 373     ASSERT( pNewType && pNewType->Which() == pType->Which(),
 374             "kein Typ oder ungleiche Typen" );
 375
 376     SwFieldType* pOld = pType;
 377     pType = pNewType;
 378     return pOld;
 379 }
 380
 381     // hat das Feld eine Action auf dem ClickHandler ? (z.B. INetFelder,..)
 382 BOOL SwField::HasClickHdl() const
 383 {
 384     BOOL bRet = FALSE;
 385     switch( pType->Which() )
 386     {
 387     case RES_INTERNETFLD:
 388     case RES_JUMPEDITFLD:
 389     case RES_GETREFFLD:
 390     case RES_MACROFLD:
 391     case RES_INPUTFLD:
 392     case RES_DROPDOWN :
 393         bRet = TRUE;
 394         break;
 395
 396     case RES_SETEXPFLD:
 397         bRet = ((SwSetExpField*)this)->GetInputFlag();
 398         break;
 399     }
 400     return bRet;
 401 }
 402
 403 void SwField::SetLanguage(USHORT nLng)
 404 {
 405     nLang = nLng;
 406 }
 407
 408 void SwField::ChangeFormat(sal_uInt32 n)
 409 {
 410     nFormat = n;
 411 }
 412
 413 BOOL SwField::IsFixed() const
 414 {
 415     BOOL bRet = FALSE;
 416     switch( pType->Which() )
 417     {
 418     case RES_FIXDATEFLD:
 419     case RES_FIXTIMEFLD:
 420         bRet = TRUE;
 421         break;
 422
 423     case RES_DATETIMEFLD:
 424         bRet = 0 != (GetSubType() & FIXEDFLD);
 425         break;
 426
 427     case RES_EXTUSERFLD:
 428     case RES_AUTHORFLD:
 429         bRet = 0 != (GetFormat() & AF_FIXED);
 430         break;
 431
 432     case RES_FILENAMEFLD:
 433         bRet = 0 != (GetFormat() & FF_FIXED);
 434         break;
 435
 436     case RES_DOCINFOFLD:
 437         bRet = 0 != (GetSubType() & DI_SUB_FIXED);
 438         break;
 439     }
 440     return bRet;
 441 }
 442
 443 /*--------------------------------------------------------------------
 444     Beschreibung: Numerierung expandieren
 445  --------------------------------------------------------------------*/
 446
 447 String FormatNumber(USHORT nNum, sal_uInt32 nFormat)
 448 {
 449     if(SVX_NUM_PAGEDESC == nFormat)
 450         return  String::CreateFromInt32( nNum );
 451     SvxNumberType aNumber;
 452
 453     ASSERT(nFormat != SVX_NUM_NUMBER_NONE, "Falsches Nummern-Format" );
 454
 455     aNumber.SetNumberingType((sal_Int16)nFormat);
 456     return aNumber.GetNumStr(nNum);
 457 }
 458
 459 /*--------------------------------------------------------------------
 460     Beschreibung: CTOR SwValueFieldType
 461  --------------------------------------------------------------------*/
 462
 463 SwValueFieldType::SwValueFieldType( SwDoc* pDocPtr, USHORT nWhichId )
 464     : SwFieldType(nWhichId),
 465     pDoc(pDocPtr),
 466     bUseFormat(TRUE)
 467 {
 468 }
 469
 470 SwValueFieldType::SwValueFieldType( const SwValueFieldType& rTyp )
 471     : SwFieldType(rTyp.Which()),
 472     pDoc(rTyp.GetDoc()),
 473     bUseFormat(rTyp.UseFormat())
 474 {
 475 }
 476
 477 /*--------------------------------------------------------------------
 478     Beschreibung: Wert formatiert als String zurueckgeben
 479  --------------------------------------------------------------------*/
 480
 481 String SwValueFieldType::ExpandValue( const double& rVal,
 482                                         sal_uInt32 nFmt, USHORT nLng) const
 483 {
 484     if (rVal >= DBL_MAX)                // FehlerString fuer Calculator
 485         return ViewShell::GetShellRes()->aCalc_Error;
 486
 487     String sExpand;
 488     SvNumberFormatter* pFormatter = pDoc->GetNumberFormatter();
 489     Color* pCol = 0;
 490
 491     // wegen Bug #60010
 492     USHORT nFmtLng = ::lcl_GetLanguageOfFormat( nLng, nFmt, *pFormatter );
 493
 494     if( nFmt < SV_COUNTRY_LANGUAGE_OFFSET && LANGUAGE_SYSTEM != nFmtLng )
 495     {
 496         short nType = NUMBERFORMAT_DEFINED;
 497         xub_StrLen nDummy;
 498
 499         const SvNumberformat* pEntry = pFormatter->GetEntry(nFmt);
 500
 501         if (pEntry && nLng != pEntry->GetLanguage())
 502         {
 503             sal_uInt32 nNewFormat = pFormatter->GetFormatForLanguageIfBuiltIn(nFmt,
 504                                                     (LanguageType)nFmtLng);
 505
 506             if (nNewFormat == nFmt)
 507             {
 508                 // Warscheinlich benutzerdefiniertes Format
 509                 String sFmt(pEntry->GetFormatstring());
 510
 511                 pFormatter->PutandConvertEntry(sFmt, nDummy, nType, nFmt,
 512                                         pEntry->GetLanguage(), nFmtLng );
 513             }
 514             else
 515                 nFmt = nNewFormat;
 516         }
 517         ASSERT(pEntry, "Unbekanntes Zahlenformat!");
 518     }
 519
 520     if( pFormatter->IsTextFormat( nFmt ) )
 521     {
 522         String sValue;
 523         DoubleToString(sValue, rVal, nFmtLng);
 524         pFormatter->GetOutputString(sValue, nFmt, sExpand, &pCol);
 525     }
 526     else
 527         pFormatter->GetOutputString(rVal, nFmt, sExpand, &pCol);
 528
 529     return sExpand;
 530 }
 531
 532 /*--------------------------------------------------------------------
 533     Beschreibung:
 534  --------------------------------------------------------------------*/
 535
 536 void SwValueFieldType::DoubleToString( String &rValue, const double &rVal,
 537                                         sal_uInt32 nFmt) const
 538 {
 539     SvNumberFormatter* pFormatter = pDoc->GetNumberFormatter();
 540     const SvNumberformat* pEntry = pFormatter->GetEntry(nFmt);
 541
 542     if (pEntry)
 543         DoubleToString(rValue, rVal, pEntry->GetLanguage());
 544 }
 545
 546 /*--------------------------------------------------------------------
 547     Beschreibung:
 548  --------------------------------------------------------------------*/
 549
 550 void SwValueFieldType::DoubleToString( String &rValue, const double &rVal,
 551                                         USHORT nLng ) const
 552 {
 553     SvNumberFormatter* pFormatter = pDoc->GetNumberFormatter();
 554
 555     // wegen Bug #60010
 556     if( nLng == LANGUAGE_NONE ) // wegen Bug #60010
 557         nLng = LANGUAGE_SYSTEM;
 558
 559     pFormatter->ChangeIntl( nLng );     // Separator in der richtigen Sprache besorgen
 560     rValue = ::rtl::math::doubleToUString( rVal, rtl_math_StringFormat_F, 12,
 561                                     pFormatter->GetDecSep(), true );
 562 }
 563
 564 /*--------------------------------------------------------------------
 565     Beschreibung: CTOR SwValueField
 566  --------------------------------------------------------------------*/
 567
 568 SwValueField::SwValueField( SwValueFieldType* pFldType, sal_uInt32 nFmt,
 569                             USHORT nLng, const double fVal )
 570     : SwField(pFldType, nFmt, nLng),
 571     fValue(fVal)
 572 {
 573 }
 574
 575 SwValueField::SwValueField( const SwValueField& rFld )
 576     : SwField(rFld),
 577     fValue(rFld.GetValue())
 578 {
 579 }
 580
 581 SwValueField::~SwValueField()
 582 {
 583 }
 584 /*--------------------------------------------------------------------
 585     Beschreibung:       neuen Typ setzen
 586                     (wird fuer das Kopieren zwischen Dokumenten benutzt)
 587                     muss immer vom gleichen Typ sein.
 588  --------------------------------------------------------------------*/
 589
 590 SwFieldType* SwValueField::ChgTyp( SwFieldType* pNewType )
 591 {
 592     SwDoc* pNewDoc = ((SwValueFieldType *)pNewType)->GetDoc();
 593     SwDoc* pDoc    = GetDoc();
 594
 595     if( pNewDoc && pDoc && pDoc != pNewDoc)
 596     {
 597         SvNumberFormatter* pFormatter = pNewDoc->GetNumberFormatter();
 598
 599         if( pFormatter && pFormatter->HasMergeFmtTbl() &&
 600             ((SwValueFieldType *)GetTyp())->UseFormat() )
 601             SetFormat(pFormatter->GetMergeFmtIndex( GetFormat() ));
 602     }
 603
 604     return SwField::ChgTyp(pNewType);
 605 }
 606
 607 /*--------------------------------------------------------------------
 608     Beschreibung: Format in Office-Sprache ermitteln
 609  --------------------------------------------------------------------*/
 610
 611 sal_uInt32 SwValueField::GetSystemFormat(SvNumberFormatter* pFormatter, sal_uInt32 nFmt)
 612 {
 613     const SvNumberformat* pEntry = pFormatter->GetEntry(nFmt);
 614     USHORT nLng = SvxLocaleToLanguage( SvtSysLocale().GetLocaleData().getLocale() );
 615
 616     if (pEntry && nLng != pEntry->GetLanguage())
 617     {
 618         sal_uInt32 nNewFormat = pFormatter->GetFormatForLanguageIfBuiltIn(nFmt,
 619                                                         (LanguageType)nLng);
 620
 621         if (nNewFormat == nFmt)
 622         {
 623             // Warscheinlich benutzerdefiniertes Format
 624             short nType = NUMBERFORMAT_DEFINED;
 625             xub_StrLen nDummy;
 626
 627             String sFmt(pEntry->GetFormatstring());
 628
 629             sal_uInt32 nFormat = nFmt;
 630             pFormatter->PutandConvertEntry(sFmt, nDummy, nType,
 631                                 nFormat, pEntry->GetLanguage(), nLng);
 632             nFmt = nFormat;
 633         }
 634         else
 635             nFmt = nNewFormat;
 636     }
 637
 638     return nFmt;
 639 }
 640
 641 /*--------------------------------------------------------------------
 642     Beschreibung: Sprache im Format anpassen
 643  --------------------------------------------------------------------*/
 644
 645 void SwValueField::SetLanguage( USHORT nLng )
 646 {
 647     if( IsAutomaticLanguage() &&
 648             ((SwValueFieldType *)GetTyp())->UseFormat() &&
 649         GetFormat() != SAL_MAX_UINT32 )
 650     {
 651         // wegen Bug #60010
 652         SvNumberFormatter* pFormatter = GetDoc()->GetNumberFormatter();
 653         USHORT nFmtLng = ::lcl_GetLanguageOfFormat( nLng, GetFormat(),
 654                                                     *pFormatter );
 655
 656         if( (GetFormat() >= SV_COUNTRY_LANGUAGE_OFFSET ||
 657              LANGUAGE_SYSTEM != nFmtLng ) &&
 658             !(Which() == RES_USERFLD && (GetSubType()&nsSwExtendedSubType::SUB_CMD) ) )
 659         {
 660             const SvNumberformat* pEntry = pFormatter->GetEntry(GetFormat());
 661
 662             if( pEntry && nFmtLng != pEntry->GetLanguage() )
 663             {
 664                 sal_uInt32 nNewFormat = pFormatter->GetFormatForLanguageIfBuiltIn(
 665                                         GetFormat(), (LanguageType)nFmtLng );
 666
 667                 if( nNewFormat == GetFormat() )
 668                 {
 669                     // Warscheinlich benutzerdefiniertes Format
 670                     short nType = NUMBERFORMAT_DEFINED;
 671                     xub_StrLen nDummy;
 672                     String sFmt( pEntry->GetFormatstring() );
 673                     pFormatter->PutandConvertEntry( sFmt, nDummy, nType,
 674                                                     nNewFormat,
 675                                                     pEntry->GetLanguage(),
 676                                                     nFmtLng );
 677                 }
 678                 SetFormat( nNewFormat );
 679             }
 680             ASSERT(pEntry, "Unbekanntes Zahlenformat!");
 681         }
 682     }
 683
 684     SwField::SetLanguage(nLng);
 685 }
 686
 687 /*--------------------------------------------------------------------
 688     Beschreibung:
 689  --------------------------------------------------------------------*/
 690
 691 double SwValueField::GetValue() const
 692 {
 693     return fValue;
 694 }
 695
 696 void SwValueField::SetValue( const double& rVal )
 697 {
 698     fValue = rVal;
 699 }
 700
 701 /*--------------------------------------------------------------------
 702     Beschreibung: SwFormulaField
 703  --------------------------------------------------------------------*/
 704
 705 SwFormulaField::SwFormulaField( SwValueFieldType* pFldType, sal_uInt32 nFmt, const double fVal)
 706     : SwValueField(pFldType, nFmt, LANGUAGE_SYSTEM, fVal)
 707 {
 708 }
 709
 710 SwFormulaField::SwFormulaField( const SwFormulaField& rFld )
 711     : SwValueField((SwValueFieldType *)rFld.GetTyp(), rFld.GetFormat(),
 712                     rFld.GetLanguage(), rFld.GetValue())
 713 {
 714 }
 715
 716 /*--------------------------------------------------------------------
 717     Beschreibung:
 718  --------------------------------------------------------------------*/
 719
 720 String SwFormulaField::GetFormula() const
 721 {
 722     return sFormula;
 723 }
 724
 725 /*--------------------------------------------------------------------
 726     Beschreibung:
 727  --------------------------------------------------------------------*/
 728
 729 void SwFormulaField::SetFormula(const String& rStr)
 730 {
 731     sFormula = rStr;
 732
 733     ULONG nFmt(GetFormat());
 734
 735     if( nFmt && SAL_MAX_UINT32 != nFmt )
 736     {
 737         xub_StrLen nPos = 0;
 738         double fTmpValue;
 739         if( SwCalc::Str2Double( rStr, nPos, fTmpValue, GetDoc() ) )
 740             SwValueField::SetValue( fTmpValue );
 741     }
 742 }
 743
 744 /*--------------------------------------------------------------------
 745     Beschreibung:
 746  --------------------------------------------------------------------*/
 747
 748 void SwFormulaField::SetExpandedFormula( const String& rStr )
 749 {
 750     sal_uInt32 nFmt(GetFormat());
 751
 752     if (nFmt && nFmt != SAL_MAX_UINT32 && ((SwValueFieldType *)GetTyp())->UseFormat())
 753     {
 754         double fTmpValue;
 755
 756         SvNumberFormatter* pFormatter = GetDoc()->GetNumberFormatter();
 757
 758         if (pFormatter->IsNumberFormat(rStr, nFmt, fTmpValue))
 759         {
 760             SwValueField::SetValue(fTmpValue);
 761             sFormula.Erase();
 762
 763             ((SwValueFieldType *)GetTyp())->DoubleToString(sFormula, fTmpValue, nFmt);
 764             return;
 765         }
 766     }
 767     sFormula = rStr;
 768 }
 769
 770 /*--------------------------------------------------------------------
 771     Beschreibung:
 772  --------------------------------------------------------------------*/
 773
 774 String SwFormulaField::GetExpandedFormula() const
 775 {
 776     sal_uInt32 nFmt(GetFormat());
 777
 778     if (nFmt && nFmt != SAL_MAX_UINT32 && ((SwValueFieldType *)GetTyp())->UseFormat())
 779     {
 780         String sFormattedValue;
 781         Color* pCol = 0;
 782
 783         SvNumberFormatter* pFormatter = GetDoc()->GetNumberFormatter();
 784
 785         if (pFormatter->IsTextFormat(nFmt))
 786         {
 787             String sValue;
 788             ((SwValueFieldType *)GetTyp())->DoubleToString(sValue, GetValue(), nFmt);
 789             pFormatter->GetOutputString(sValue, nFmt, sFormattedValue, &pCol);
 790         }
 791         else
 792             pFormatter->GetOutputString(GetValue(), nFmt, sFormattedValue, &pCol);
 793
 794         return sFormattedValue;
 795     }
 796     else
 797         return GetFormula();
 798 }
 799
 800 String SwField::GetDescription() const
 801 {
 802     return SW_RES(STR_FIELD);
 803 }