sw/source/core/fields/dbfld.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: dbfld.cxx,v $
  10  * $Revision: 1.31 $
  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 <float.h>
  36 #include <sfx2/app.hxx>
  37 #include <svtools/zforlist.hxx>
  38 #include <svx/pageitem.hxx>
  39 #include <svx/dataaccessdescriptor.hxx>
  40 #include <com/sun/star/sdbc/DataType.hpp>
  41 #include <fmtfld.hxx>
  42 #include <txtfld.hxx>
  43 #include <doc.hxx>
  44 #include <docary.hxx>
  45 #include <frame.hxx>
  46 #include <fldbas.hxx>
  47 #include <pam.hxx>
  48 #include <ndtxt.hxx>
  49 #include <dbfld.hxx>
  50 #ifndef _DBMGR_HXX
  51 #include <dbmgr.hxx>
  52 #endif
  53 #include <docfld.hxx>
  54 #include <expfld.hxx>
  55 #include <txtatr.hxx>
  56 #ifndef _UNOFLDMID_H
  57 #include <unofldmid.h>
  58 #endif
  59
  60
  61 using namespace ::com::sun::star::sdbc;
  62 using namespace ::com::sun::star;
  63 using ::rtl::OUString;
  64
  65 /*--------------------------------------------------------------------
  66     Beschreibung: Datenbanktrenner durch Punkte fuer Anzeige ersetzen
  67  --------------------------------------------------------------------*/
  68
  69 String lcl_DBTrennConv(const String& aContent)
  70 {
  71     String sTmp(aContent);
  72     sal_Unicode* pStr = sTmp.GetBufferAccess();
  73     for( USHORT i = sTmp.Len(); i; --i, ++pStr )
  74         if( DB_DELIM == *pStr )
  75             *pStr = '.';
  76     return sTmp;
  77 }
  78
  79 /*--------------------------------------------------------------------
  80     Beschreibung: DatenbankFeldTyp
  81  --------------------------------------------------------------------*/
  82
  83 SwDBFieldType::SwDBFieldType(SwDoc* pDocPtr, const String& rNam, const SwDBData& rDBData ) :
  84     SwValueFieldType( pDocPtr, RES_DBFLD ),
  85     aDBData(rDBData),
  86     sColumn(rNam),
  87     nRefCnt(0)
  88 {
  89     if(aDBData.sDataSource.getLength() || aDBData.sCommand.getLength())
  90     {
  91         sName =  aDBData.sDataSource;
  92         sName += DB_DELIM;
  93         sName += (String)aDBData.sCommand;
  94         sName += DB_DELIM;
  95     }
  96     sName += GetColumnName();
  97 }
  98 //------------------------------------------------------------------------------
  99
 100 SwFieldType* SwDBFieldType::Copy() const
 101 {
 102     SwDBFieldType* pTmp = new SwDBFieldType(GetDoc(), sColumn, aDBData);
 103     return pTmp;
 104 }
 105
 106 //------------------------------------------------------------------------------
 107 const String& SwDBFieldType::GetName() const
 108 {
 109     return sName;
 110 }
 111
 112 //------------------------------------------------------------------------------
 113
 114 void SwDBFieldType::ReleaseRef()
 115 {
 116     ASSERT(nRefCnt > 0, "RefCount kleiner 0!");
 117
 118     if (--nRefCnt <= 0)
 119     {
 120         USHORT nPos = GetDoc()->GetFldTypes()->GetPos(this);
 121
 122         if (nPos != USHRT_MAX)
 123         {
 124             GetDoc()->RemoveFldType(nPos);
 125             delete this;
 126         }
 127     }
 128 }
 129
 130 /* -----------------24.02.99 14:51-------------------
 131  *
 132  * --------------------------------------------------*/
 133 BOOL SwDBFieldType::QueryValue( uno::Any& rAny, USHORT nWhichId ) const
 134 {
 135     switch( nWhichId )
 136     {
 137     case FIELD_PROP_PAR1:
 138         rAny <<= aDBData.sDataSource;
 139         break;
 140     case FIELD_PROP_PAR2:
 141         rAny <<= aDBData.sCommand;
 142         break;
 143     case FIELD_PROP_PAR3:
 144         rAny <<= OUString(sColumn);
 145         break;
 146     case FIELD_PROP_SHORT1:
 147         rAny <<= aDBData.nCommandType;
 148         break;
 149     default:
 150         DBG_ERROR("illegal property");
 151     }
 152     return TRUE;
 153 }
 154 /* -----------------24.02.99 14:51-------------------
 155  *
 156  * --------------------------------------------------*/
 157 BOOL SwDBFieldType::PutValue( const uno::Any& rAny, USHORT nWhichId )
 158 {
 159     switch( nWhichId )
 160     {
 161     case FIELD_PROP_PAR1:
 162         rAny >>= aDBData.sDataSource;
 163         break;
 164     case FIELD_PROP_PAR2:
 165         rAny >>= aDBData.sCommand;
 166         break;
 167     case FIELD_PROP_PAR3:
 168         {
 169             String sTmp;
 170             ::GetString( rAny, sTmp );
 171             if( sTmp != sColumn )
 172             {
 173                 sColumn = sTmp;
 174                 SwClientIter aIter( *this );
 175                 SwFmtFld* pFld = (SwFmtFld*)aIter.First( TYPE( SwFmtFld ));
 176                 while(pFld)
 177                 {
 178                     // Feld im Undo?
 179                     SwTxtFld *pTxtFld = pFld->GetTxtFld();
 180                     if(pTxtFld && pTxtFld->GetTxtNode().GetNodes().IsDocNodes() )
 181                     {
 182                         SwDBField* pDBField = (SwDBField*)pFld->GetFld();
 183                         pDBField->ClearInitialized();
 184                         pDBField->InitContent();
 185                      }
 186                     pFld = (SwFmtFld*)aIter.Next();
 187                 }
 188             }
 189         }
 190         break;
 191     case FIELD_PROP_SHORT1:
 192         rAny >>= aDBData.nCommandType;
 193         break;
 194     default:
 195         DBG_ERROR("illegal property");
 196     }
 197     return TRUE;
 198 }
 199 /*--------------------------------------------------------------------
 200     Beschreibung: SwDBField
 201  --------------------------------------------------------------------*/
 202
 203 SwDBField::SwDBField(SwDBFieldType* pTyp, ULONG nFmt)
 204     :   SwValueField(pTyp, nFmt),
 205         nSubType(0),
 206         bIsInBodyTxt(TRUE),
 207         bValidValue(FALSE),
 208         bInitialized(FALSE)
 209 {
 210     if (GetTyp())
 211         ((SwDBFieldType*)GetTyp())->AddRef();
 212     InitContent();
 213 }
 214
 215 //------------------------------------------------------------------------------
 216
 217 SwDBField::~SwDBField()
 218 {
 219     if (GetTyp())
 220         ((SwDBFieldType*)GetTyp())->ReleaseRef();
 221 }
 222
 223 //------------------------------------------------------------------------------
 224
 225 void SwDBField::InitContent()
 226 {
 227     if (!IsInitialized())
 228     {
 229         aContent = '<';
 230         aContent += ((SwDBFieldType*)GetTyp())->GetColumnName();
 231         aContent += '>';
 232     }
 233 }
 234
 235 //------------------------------------------------------------------------------
 236
 237 void SwDBField::InitContent(const String& rExpansion)
 238 {
 239     if (rExpansion.Len() > 2)
 240     {
 241         if (rExpansion.GetChar(0) == '<' &&
 242             rExpansion.GetChar(rExpansion.Len() - 1) == '>')
 243         {
 244             String sColumn( rExpansion.Copy( 1, rExpansion.Len() - 2 ) );
 245             if( ::GetAppCmpStrIgnore().isEqual( sColumn,
 246                             ((SwDBFieldType *)GetTyp())->GetColumnName() ))
 247             {
 248                 InitContent();
 249                 return;
 250             }
 251         }
 252     }
 253     SetExpansion( rExpansion );
 254 }
 255
 256 //------------------------------------------------------------------------------
 257
 258 String SwDBField::Expand() const
 259 {
 260     String sRet;
 261
 262     if(0 ==(GetSubType() & nsSwExtendedSubType::SUB_INVISIBLE))
 263         sRet = lcl_DBTrennConv(aContent);
 264     return sRet;
 265 }
 266
 267 //------------------------------------------------------------------------------
 268
 269 SwField* SwDBField::Copy() const
 270 {
 271     SwDBField *pTmp = new SwDBField((SwDBFieldType*)GetTyp(), GetFormat());
 272     pTmp->aContent              = aContent;
 273     pTmp->bIsInBodyTxt  = bIsInBodyTxt;
 274     pTmp->bValidValue   = bValidValue;
 275     pTmp->bInitialized  = bInitialized;
 276     pTmp->nSubType              = nSubType;
 277     pTmp->SetValue(GetValue());
 278     pTmp->sFieldCode = sFieldCode;
 279
 280     return pTmp;
 281 }
 282
 283 String SwDBField::GetCntnt(BOOL bName) const
 284 {
 285     if(bName)
 286     {
 287         const String& rDBName = ((SwDBFieldType*)GetTyp())->GetName();
 288         //TODO/CLEANUP
 289         //Funktion tut nichts!
 290         //String sContent( SFX_APP()->LocalizeDBName(INI2NATIONAL,
 291         //                                    rDBName.GetToken(0, DB_DELIM)));
 292         String sContent( rDBName.GetToken(0, DB_DELIM) );
 293
 294         if (sContent.Len() > 1)
 295         {
 296             sContent += DB_DELIM;
 297             sContent += rDBName.GetToken(1, DB_DELIM);
 298             sContent += DB_DELIM;
 299             sContent += rDBName.GetToken(2, DB_DELIM);
 300         }
 301         return lcl_DBTrennConv(sContent);
 302     }
 303     return Expand();
 304 }
 305
 306 //------------------------------------------------------------------------------
 307
 308 void SwDBField::ChgValue( double d, BOOL bVal )
 309 {
 310     bValidValue = bVal;
 311     SetValue(d);
 312
 313     if( bValidValue )
 314         aContent = ((SwValueFieldType*)GetTyp())->ExpandValue(d, GetFormat(), GetLanguage());
 315 }
 316
 317 /*--------------------------------------------------------------------
 318     Beschreibung:
 319  --------------------------------------------------------------------*/
 320
 321 SwFieldType* SwDBField::ChgTyp( SwFieldType* pNewType )
 322 {
 323     SwFieldType* pOld = SwValueField::ChgTyp( pNewType );
 324
 325     ((SwDBFieldType*)pNewType)->AddRef();
 326     ((SwDBFieldType*)pOld)->ReleaseRef();
 327
 328     return pOld;
 329 }
 330
 331 /*--------------------------------------------------------------------
 332     Beschreibung: Aktuellen Field-Value holen und chachen
 333  --------------------------------------------------------------------*/
 334
 335 void SwDBField::Evaluate()
 336 {
 337     SwNewDBMgr* pMgr = GetDoc()->GetNewDBMgr();
 338
 339     // erstmal loeschen
 340     bValidValue = FALSE;
 341     double nValue = DBL_MAX;
 342     const SwDBData& aTmpData = GetDBData();
 343
 344     if(!pMgr || !pMgr->IsDataSourceOpen(aTmpData.sDataSource, aTmpData.sCommand, sal_True))
 345         return ;
 346
 347     sal_uInt32 nFmt;
 348
 349     // Passenden Spaltennamen suchen
 350     String aColNm( ((SwDBFieldType*)GetTyp())->GetColumnName() );
 351
 352     SvNumberFormatter* pDocFormatter = GetDoc()->GetNumberFormatter();
 353     pMgr->GetMergeColumnCnt(aColNm, GetLanguage(), aContent, &nValue, &nFmt);
 354     if( !( nSubType & nsSwExtendedSubType::SUB_OWN_FMT ) )
 355         SetFormat( nFmt = pMgr->GetColumnFmt( aTmpData.sDataSource, aTmpData.sCommand,
 356                                         aColNm, pDocFormatter, GetLanguage() ));
 357
 358     if( DBL_MAX != nValue )
 359     {
 360         sal_Int32 nColumnType = pMgr->GetColumnType(aTmpData.sDataSource, aTmpData.sCommand, aColNm);
 361         if(     DataType::DATE == nColumnType  || DataType::TIME == nColumnType  ||
 362                  DataType::TIMESTAMP  == nColumnType)
 363
 364         {
 365             Date aStandard(1,1,1900);
 366             if (*pDocFormatter->GetNullDate() != aStandard)
 367                 nValue += (aStandard - *pDocFormatter->GetNullDate());
 368         }
 369         bValidValue = TRUE;
 370         SetValue(nValue);
 371         aContent = ((SwValueFieldType*)GetTyp())->ExpandValue(nValue, GetFormat(), GetLanguage());
 372     }
 373     else
 374     {
 375         SwSbxValue aVal;
 376         aVal.PutString( aContent );
 377
 378         if (aVal.IsNumeric())
 379         {
 380             SetValue(aVal.GetDouble());
 381
 382             SvNumberFormatter* pFormatter = GetDoc()->GetNumberFormatter();
 383             if (nFmt && nFmt != SAL_MAX_UINT32 && !pFormatter->IsTextFormat(nFmt))
 384                 bValidValue = TRUE;     // Wegen Bug #60339 nicht mehr bei allen Strings
 385         }
 386         else
 387         {
 388             // Bei Strings TRUE wenn Laenge > 0 sonst FALSE
 389             SetValue(aContent.Len() ? 1 : 0);
 390         }
 391     }
 392     bInitialized = TRUE;
 393 }
 394
 395 /*--------------------------------------------------------------------
 396     Beschreibung: Namen erfragen
 397  --------------------------------------------------------------------*/
 398
 399 const String& SwDBField::GetPar1() const
 400 {
 401     return ((SwDBFieldType*)GetTyp())->GetName();
 402 }
 403
 404 /*--------------------------------------------------------------------
 405     Beschreibung:
 406  --------------------------------------------------------------------*/
 407
 408 USHORT SwDBField::GetSubType() const
 409 {
 410     return nSubType;
 411 }
 412
 413 /*--------------------------------------------------------------------
 414     Beschreibung:
 415  --------------------------------------------------------------------*/
 416
 417 void SwDBField::SetSubType(USHORT nType)
 418 {
 419     nSubType = nType;
 420 }
 421
 422 /*-----------------06.03.98 16:15-------------------
 423
 424 --------------------------------------------------*/
 425 BOOL SwDBField::QueryValue( uno::Any& rAny, USHORT nWhichId ) const
 426 {
 427     switch( nWhichId )
 428     {
 429     case FIELD_PROP_BOOL1:
 430         {
 431             BOOL bTemp = 0 == (GetSubType()&nsSwExtendedSubType::SUB_OWN_FMT);
 432             rAny.setValue(&bTemp, ::getBooleanCppuType());
 433         }
 434         break;
 435     case FIELD_PROP_BOOL2:
 436     {
 437         sal_Bool bVal = 0 == (GetSubType() & nsSwExtendedSubType::SUB_INVISIBLE);
 438         rAny.setValue(&bVal, ::getBooleanCppuType());
 439     }
 440     break;
 441     case FIELD_PROP_FORMAT:
 442         rAny <<= (sal_Int32)GetFormat();
 443         break;
 444     case FIELD_PROP_PAR1:
 445         rAny <<= OUString(aContent);
 446         break;
 447     case FIELD_PROP_PAR2:
 448         rAny <<= OUString(sFieldCode);
 449         break;
 450     default:
 451         DBG_ERROR("illegal property");
 452     }
 453     return TRUE;
 454
 455 }
 456 /*-----------------06.03.98 16:15-------------------
 457
 458 --------------------------------------------------*/
 459 BOOL SwDBField::PutValue( const uno::Any& rAny, USHORT nWhichId )
 460 {
 461     switch( nWhichId )
 462     {
 463     case FIELD_PROP_BOOL1:
 464         if( *(sal_Bool*)rAny.getValue() )
 465             SetSubType(GetSubType()&~nsSwExtendedSubType::SUB_OWN_FMT);
 466         else
 467             SetSubType(GetSubType()|nsSwExtendedSubType::SUB_OWN_FMT);
 468         break;
 469     case FIELD_PROP_BOOL2:
 470     {
 471         USHORT nSubTyp = GetSubType();
 472         sal_Bool bVisible = sal_False;
 473         if(!(rAny >>= bVisible))
 474             return FALSE;
 475         if(bVisible)
 476             nSubTyp &= ~nsSwExtendedSubType::SUB_INVISIBLE;
 477         else
 478             nSubTyp |= nsSwExtendedSubType::SUB_INVISIBLE;
 479         SetSubType(nSubTyp);
 480         //invalidate text node
 481         if(GetTyp())
 482         {
 483             SwClientIter aIter( *GetTyp() );
 484             SwFmtFld* pFld = (SwFmtFld*)aIter.First( TYPE( SwFmtFld ));
 485             while(pFld)
 486             {
 487                 SwTxtFld *pTxtFld = pFld->GetTxtFld();
 488                 if(pTxtFld && (SwDBField*)pFld->GetFld() == this )
 489                 {
 490                     //notify the change
 491                     pTxtFld->NotifyContentChange(*pFld);
 492                     break;
 493                 }
 494                 pFld = (SwFmtFld*)aIter.Next();
 495             }
 496         }
 497     }
 498     break;
 499     case FIELD_PROP_FORMAT:
 500         {
 501             sal_Int32 nTemp = 0;
 502             rAny >>= nTemp;
 503             SetFormat(nTemp);
 504         }
 505         break;
 506     case FIELD_PROP_PAR1:
 507         ::GetString( rAny, aContent );
 508         break;
 509     case FIELD_PROP_PAR2:
 510         ::GetString( rAny, sFieldCode );
 511     break;
 512     default:
 513         DBG_ERROR("illegal property");
 514     }
 515     return TRUE;
 516 }
 517
 518 /*--------------------------------------------------------------------
 519     Beschreibung: Basisklasse fuer alle weiteren Datenbankfelder
 520  --------------------------------------------------------------------*/
 521
 522 SwDBNameInfField::SwDBNameInfField(SwFieldType* pTyp, const SwDBData& rDBData, ULONG nFmt) :
 523     SwField(pTyp, nFmt),
 524     aDBData(rDBData),
 525     nSubType(0)
 526 {
 527 }
 528
 529 //------------------------------------------------------------------------------
 530
 531 SwDBData SwDBNameInfField::GetDBData(SwDoc* pDoc)
 532 {
 533     SwDBData aRet;
 534     if(aDBData.sDataSource.getLength())
 535         aRet = aDBData;
 536     else
 537         aRet = pDoc->GetDBData();
 538     return aRet;
 539 }
 540
 541 // #111840#
 542 void SwDBNameInfField::SetDBData(const SwDBData & rDBData)
 543 {
 544     aDBData = rDBData;
 545 }
 546
 547 //------------------------------------------------------------------------------
 548
 549 String SwDBNameInfField::GetCntnt(BOOL bName) const
 550 {
 551     String sStr(SwField::GetCntnt(bName));
 552
 553     if(bName)
 554     {
 555         if (aDBData.sDataSource.getLength())
 556         {
 557             sStr += ':';
 558             sStr += String(aDBData.sDataSource);
 559             sStr += DB_DELIM;
 560             sStr += String(aDBData.sCommand);
 561         }
 562     }
 563     return lcl_DBTrennConv(sStr);
 564 }
 565
 566 /*-----------------06.03.98 16:55-------------------
 567
 568 --------------------------------------------------*/
 569 BOOL SwDBNameInfField::QueryValue( uno::Any& rAny, USHORT nWhichId ) const
 570 {
 571     switch( nWhichId )
 572     {
 573     case FIELD_PROP_PAR1:
 574         rAny <<= aDBData.sDataSource;
 575         break;
 576     case FIELD_PROP_PAR2:
 577         rAny <<= aDBData.sCommand;
 578         break;
 579     case FIELD_PROP_SHORT1:
 580         rAny <<= aDBData.nCommandType;
 581         break;
 582     case FIELD_PROP_BOOL2:
 583     {
 584         sal_Bool bVal = 0 == (GetSubType() & nsSwExtendedSubType::SUB_INVISIBLE);
 585         rAny.setValue(&bVal, ::getBooleanCppuType());
 586     }
 587     break;
 588     default:
 589         DBG_ERROR("illegal property");
 590     }
 591     return TRUE;
 592 }
 593 /*-----------------06.03.98 16:55-------------------
 594
 595 --------------------------------------------------*/
 596 BOOL SwDBNameInfField::PutValue( const uno::Any& rAny, USHORT nWhichId )
 597 {
 598     switch( nWhichId )
 599     {
 600     case FIELD_PROP_PAR1:
 601         rAny >>= aDBData.sDataSource;
 602         break;
 603     case FIELD_PROP_PAR2:
 604         rAny >>= aDBData.sCommand;
 605         break;
 606     case FIELD_PROP_SHORT1:
 607         rAny >>= aDBData.nCommandType;
 608         break;
 609     case FIELD_PROP_BOOL2:
 610     {
 611         USHORT nSubTyp = GetSubType();
 612         sal_Bool bVisible = sal_False;
 613         if(!(rAny >>= bVisible))
 614             return FALSE;
 615         if(bVisible)
 616             nSubTyp &= ~nsSwExtendedSubType::SUB_INVISIBLE;
 617         else
 618             nSubTyp |= nsSwExtendedSubType::SUB_INVISIBLE;
 619         SetSubType(nSubTyp);
 620     }
 621     break;
 622     default:
 623         DBG_ERROR("illegal property");
 624     }
 625     return TRUE;
 626 }
 627 /* -----------------4/10/2003 15:03------------------
 628
 629  --------------------------------------------------*/
 630 USHORT SwDBNameInfField::GetSubType() const
 631 {
 632     return nSubType;
 633 }
 634 /* -----------------4/10/2003 15:03------------------
 635
 636  --------------------------------------------------*/
 637 void SwDBNameInfField::SetSubType(USHORT nType)
 638 {
 639     nSubType = nType;
 640 }
 641
 642 /*--------------------------------------------------------------------
 643     Beschreibung: NaechsterDatensatz
 644  --------------------------------------------------------------------*/
 645
 646 SwDBNextSetFieldType::SwDBNextSetFieldType()
 647     : SwFieldType( RES_DBNEXTSETFLD )
 648 {
 649 }
 650
 651 //------------------------------------------------------------------------------
 652
 653 SwFieldType* SwDBNextSetFieldType::Copy() const
 654 {
 655     SwDBNextSetFieldType* pTmp = new SwDBNextSetFieldType();
 656     return pTmp;
 657 }
 658 /*--------------------------------------------------------------------
 659     Beschreibung: SwDBSetField
 660  --------------------------------------------------------------------*/
 661
 662 SwDBNextSetField::SwDBNextSetField(SwDBNextSetFieldType* pTyp,
 663                                    const String& rCond,
 664                                    const String& ,
 665                                    const SwDBData& rDBData) :
 666     SwDBNameInfField(pTyp, rDBData), aCond(rCond), bCondValid(TRUE)
 667 {}
 668
 669 //------------------------------------------------------------------------------
 670
 671 String SwDBNextSetField::Expand() const
 672 {
 673     return aEmptyStr;
 674 }
 675
 676 //------------------------------------------------------------------------------
 677
 678 SwField* SwDBNextSetField::Copy() const
 679 {
 680     SwDBNextSetField *pTmp = new SwDBNextSetField((SwDBNextSetFieldType*)GetTyp(),
 681                                          aCond, aEmptyStr, GetDBData());
 682     pTmp->SetSubType(GetSubType());
 683     pTmp->bCondValid = bCondValid;
 684     return pTmp;
 685 }
 686 //------------------------------------------------------------------------------
 687
 688 void SwDBNextSetField::Evaluate(SwDoc* pDoc)
 689 {
 690     SwNewDBMgr* pMgr = pDoc->GetNewDBMgr();
 691     const SwDBData& rData = GetDBData();
 692     if( !bCondValid ||
 693             !pMgr || !pMgr->IsDataSourceOpen(rData.sDataSource, rData.sCommand, sal_False))
 694         return ;
 695     pMgr->ToNextRecord(rData.sDataSource, rData.sCommand);
 696 }
 697
 698 /*--------------------------------------------------------------------
 699     Beschreibung: Bedingung
 700  --------------------------------------------------------------------*/
 701
 702 const String& SwDBNextSetField::GetPar1() const
 703 {
 704     return aCond;
 705 }
 706
 707 void SwDBNextSetField::SetPar1(const String& rStr)
 708 {
 709     aCond = rStr;
 710 }
 711 /*-----------------06.03.98 16:16-------------------
 712
 713 --------------------------------------------------*/
 714 BOOL SwDBNextSetField::QueryValue( uno::Any& rAny, USHORT nWhichId ) const
 715 {
 716     BOOL bRet = TRUE;
 717     switch( nWhichId )
 718     {
 719     case FIELD_PROP_PAR3:
 720         rAny <<= OUString(aCond);
 721         break;
 722     default:
 723         bRet = SwDBNameInfField::QueryValue( rAny, nWhichId );
 724     }
 725     return bRet;
 726 }
 727 /*-----------------06.03.98 16:16-------------------
 728
 729 --------------------------------------------------*/
 730 BOOL SwDBNextSetField::PutValue( const uno::Any& rAny, USHORT nWhichId )
 731 {
 732     BOOL bRet = TRUE;
 733     switch( nWhichId )
 734     {
 735     case FIELD_PROP_PAR3:
 736         ::GetString( rAny, aCond );
 737         break;
 738     default:
 739         bRet = SwDBNameInfField::PutValue( rAny, nWhichId );
 740     }
 741     return bRet;
 742 }
 743
 744 /*--------------------------------------------------------------------
 745     Beschreibung:
 746  --------------------------------------------------------------------*/
 747 /*
 748 String SwDBNextSetField::GetPar2() const
 749 {
 750     return GetDBName();
 751 }
 752
 753 void SwDBNextSetField::SetPar2(const String& rStr)
 754 {
 755     GetDBName() = rStr;
 756 }
 757 */
 758
 759 /*--------------------------------------------------------------------
 760     Beschreibung: Datensatz mit bestimmter ID
 761  --------------------------------------------------------------------*/
 762
 763 SwDBNumSetFieldType::SwDBNumSetFieldType() :
 764     SwFieldType( RES_DBNUMSETFLD )
 765 {
 766 }
 767
 768 //------------------------------------------------------------------------------
 769
 770 SwFieldType* SwDBNumSetFieldType::Copy() const
 771 {
 772     SwDBNumSetFieldType* pTmp = new SwDBNumSetFieldType();
 773     return pTmp;
 774 }
 775
 776 /*--------------------------------------------------------------------
 777     Beschreibung: SwDBSetField
 778  --------------------------------------------------------------------*/
 779
 780 SwDBNumSetField::SwDBNumSetField(SwDBNumSetFieldType* pTyp,
 781                                  const String& rCond,
 782                                  const String& rDBNum,
 783                                  const SwDBData& rDBData) :
 784     SwDBNameInfField(pTyp, rDBData),
 785     aCond(rCond),
 786     aPar2(rDBNum),
 787     bCondValid(TRUE)
 788 {}
 789
 790 //------------------------------------------------------------------------------
 791
 792 String SwDBNumSetField::Expand() const
 793 {
 794     return aEmptyStr;
 795 }
 796
 797 //------------------------------------------------------------------------------
 798
 799 SwField* SwDBNumSetField::Copy() const
 800 {
 801     SwDBNumSetField *pTmp = new SwDBNumSetField((SwDBNumSetFieldType*)GetTyp(),
 802                                          aCond, aPar2, GetDBData());
 803     pTmp->bCondValid = bCondValid;
 804     pTmp->SetSubType(GetSubType());
 805     return pTmp;
 806 }
 807
 808 void SwDBNumSetField::Evaluate(SwDoc* pDoc)
 809 {
 810     SwNewDBMgr* pMgr = pDoc->GetNewDBMgr();
 811     const SwDBData& aTmpData = GetDBData();
 812
 813     if( bCondValid && pMgr && pMgr->IsInMerge() &&
 814                         pMgr->IsDataSourceOpen(aTmpData.sDataSource, aTmpData.sCommand, sal_True))
 815     {   // Bedingug OK -> aktuellen Set einstellen
 816         pMgr->ToRecordId(Max((USHORT)aPar2.ToInt32(), USHORT(1))-1);
 817     }
 818 }
 819
 820 /*--------------------------------------------------------------------
 821     Beschreibung: LogDBName
 822  --------------------------------------------------------------------*/
 823
 824 const String& SwDBNumSetField::GetPar1() const
 825 {
 826     return aCond;
 827 }
 828
 829 void SwDBNumSetField::SetPar1(const String& rStr)
 830 {
 831     aCond = rStr;
 832 }
 833
 834 /*--------------------------------------------------------------------
 835     Beschreibung: Bedingung
 836  --------------------------------------------------------------------*/
 837
 838 String SwDBNumSetField::GetPar2() const
 839 {
 840     return aPar2;
 841 }
 842
 843 void SwDBNumSetField::SetPar2(const String& rStr)
 844 {
 845     aPar2 = rStr;
 846 }
 847 /*-----------------06.03.98 16:16-------------------
 848
 849 --------------------------------------------------*/
 850 BOOL SwDBNumSetField::QueryValue( uno::Any& rAny, USHORT nWhichId ) const
 851 {
 852     BOOL bRet = TRUE;
 853     switch( nWhichId )
 854     {
 855     case FIELD_PROP_PAR3:
 856         rAny <<= OUString(aCond);
 857         break;
 858     case FIELD_PROP_FORMAT:
 859         rAny <<= (sal_Int32)aPar2.ToInt32();
 860         break;
 861     default:
 862         bRet = SwDBNameInfField::QueryValue(rAny, nWhichId );
 863     }
 864     return bRet;
 865 }
 866 /*-----------------06.03.98 16:16-------------------
 867
 868 --------------------------------------------------*/
 869 BOOL    SwDBNumSetField::PutValue( const uno::Any& rAny, USHORT nWhichId )
 870 {
 871     BOOL bRet = TRUE;
 872     switch( nWhichId )
 873     {
 874     case FIELD_PROP_PAR3:
 875         ::GetString( rAny, aCond );
 876         break;
 877     case FIELD_PROP_FORMAT:
 878         {
 879             sal_Int32 nVal = 0;
 880             rAny >>= nVal;
 881             aPar2 = String::CreateFromInt32(nVal);
 882         }
 883         break;
 884     default:
 885         bRet = SwDBNameInfField::PutValue(rAny, nWhichId );
 886     }
 887     return bRet;
 888 }
 889
 890 /*--------------------------------------------------------------------
 891     Beschreibung: SwDBNameFieldType
 892  --------------------------------------------------------------------*/
 893
 894 SwDBNameFieldType::SwDBNameFieldType(SwDoc* pDocument)
 895     : SwFieldType( RES_DBNAMEFLD )
 896 {
 897     pDoc = pDocument;
 898 }
 899 //------------------------------------------------------------------------------
 900
 901 String SwDBNameFieldType::Expand(ULONG ) const
 902 {
 903     const SwDBData aData = pDoc->GetDBData();
 904     String sRet(aData.sDataSource);
 905     sRet += '.';
 906     sRet += (String)aData.sCommand;
 907     return sRet;
 908 }
 909 //------------------------------------------------------------------------------
 910
 911 SwFieldType* SwDBNameFieldType::Copy() const
 912 {
 913     SwDBNameFieldType *pTmp = new SwDBNameFieldType(pDoc);
 914     return pTmp;
 915 }
 916
 917 //------------------------------------------------------------------------------
 918
 919 /*--------------------------------------------------------------------
 920     Beschreibung: Name der angedockten DB
 921  --------------------------------------------------------------------*/
 922
 923 SwDBNameField::SwDBNameField(SwDBNameFieldType* pTyp, const SwDBData& rDBData, ULONG nFmt)
 924     : SwDBNameInfField(pTyp, rDBData, nFmt)
 925 {}
 926
 927 //------------------------------------------------------------------------------
 928
 929 String SwDBNameField::Expand() const
 930 {
 931     String sRet;
 932     if(0 ==(GetSubType() & nsSwExtendedSubType::SUB_INVISIBLE))
 933         sRet = ((SwDBNameFieldType*)GetTyp())->Expand(GetFormat());
 934     return sRet;
 935 }
 936
 937 //------------------------------------------------------------------------------
 938
 939 SwField* SwDBNameField::Copy() const
 940 {
 941     SwDBNameField *pTmp = new SwDBNameField((SwDBNameFieldType*)GetTyp(), GetDBData());
 942     pTmp->ChangeFormat(GetFormat());
 943     pTmp->SetLanguage(GetLanguage());
 944     pTmp->SetSubType(GetSubType());
 945     return pTmp;
 946 }
 947
 948 /*-----------------06.03.98 16:16-------------------
 949
 950 --------------------------------------------------*/
 951 BOOL SwDBNameField::QueryValue( uno::Any& rAny, USHORT nWhichId ) const
 952 {
 953     return SwDBNameInfField::QueryValue(rAny, nWhichId );
 954 }
 955 /*-----------------06.03.98 16:16-------------------
 956
 957 --------------------------------------------------*/
 958 BOOL SwDBNameField::PutValue( const uno::Any& rAny, USHORT nWhichId )
 959 {
 960     return SwDBNameInfField::PutValue(rAny, nWhichId );
 961 }
 962 /*--------------------------------------------------------------------
 963     Beschreibung: SwDBNameFieldType
 964  --------------------------------------------------------------------*/
 965
 966 SwDBSetNumberFieldType::SwDBSetNumberFieldType()
 967     : SwFieldType( RES_DBSETNUMBERFLD )
 968 {
 969 }
 970
 971 //------------------------------------------------------------------------------
 972
 973 SwFieldType* SwDBSetNumberFieldType::Copy() const
 974 {
 975     SwDBSetNumberFieldType *pTmp = new SwDBSetNumberFieldType;
 976     return pTmp;
 977 }
 978
 979 //------------------------------------------------------------------------------
 980
 981 /*--------------------------------------------------------------------
 982     Beschreibung: SetNumber der angedockten DB
 983  --------------------------------------------------------------------*/
 984
 985 SwDBSetNumberField::SwDBSetNumberField(SwDBSetNumberFieldType* pTyp,
 986                                        const SwDBData& rDBData,
 987                                        ULONG nFmt)
 988     : SwDBNameInfField(pTyp, rDBData, nFmt), nNumber(0)
 989 {}
 990
 991 //------------------------------------------------------------------------------
 992
 993 String SwDBSetNumberField::Expand() const
 994 {
 995     if(0 !=(GetSubType() & nsSwExtendedSubType::SUB_INVISIBLE) || nNumber == 0)
 996         return aEmptyStr;
 997     else
 998         return FormatNumber((USHORT)nNumber, GetFormat());
 999     //return(nNumber == 0 ? aEmptyStr : FormatNumber(nNumber, GetFormat()));
1000 }
1001
1002 //------------------------------------------------------------------------------
1003
1004 void SwDBSetNumberField::Evaluate(SwDoc* pDoc)
1005 {
1006     SwNewDBMgr* pMgr = pDoc->GetNewDBMgr();
1007
1008     const SwDBData& aTmpData = GetDBData();
1009     if (!pMgr || !pMgr->IsInMerge() ||
1010         !pMgr->IsDataSourceOpen(aTmpData.sDataSource, aTmpData.sCommand, sal_False))
1011         return;
1012     nNumber = pMgr->GetSelectedRecordId();
1013 }
1014
1015
1016 //------------------------------------------------------------------------------
1017
1018 SwField* SwDBSetNumberField::Copy() const
1019 {
1020     SwDBSetNumberField *pTmp =
1021         new SwDBSetNumberField((SwDBSetNumberFieldType*)GetTyp(), GetDBData(), GetFormat());
1022     pTmp->SetLanguage(GetLanguage());
1023     pTmp->SetSetNumber(nNumber);
1024     pTmp->SetSubType(GetSubType());
1025     return pTmp;
1026 }
1027 /*-----------------06.03.98 16:15-------------------
1028
1029 --------------------------------------------------*/
1030 BOOL SwDBSetNumberField::QueryValue( uno::Any& rAny, USHORT nWhichId ) const
1031 {
1032     BOOL bRet = TRUE;
1033     switch( nWhichId )
1034     {
1035     case FIELD_PROP_USHORT1:
1036         rAny <<= (sal_Int16)GetFormat();
1037         break;
1038     case FIELD_PROP_FORMAT:
1039         rAny <<= nNumber;
1040         break;
1041     default:
1042         bRet = SwDBNameInfField::QueryValue( rAny, nWhichId );
1043     }
1044     return bRet;
1045 }
1046 /*-----------------06.03.98 16:15-------------------
1047
1048 --------------------------------------------------*/
1049 BOOL SwDBSetNumberField::PutValue( const uno::Any& rAny, USHORT nWhichId )
1050 {
1051     BOOL bRet = TRUE;
1052     switch( nWhichId )
1053     {
1054     case FIELD_PROP_USHORT1:
1055         {
1056             sal_Int16 nSet = 0;
1057             rAny >>= nSet;
1058             if(nSet < (INT16) SVX_NUMBER_NONE )
1059                 SetFormat(nSet);
1060             else {
1061                 //exception(wrong_value)
1062                 ;
1063             }
1064         }
1065         break;
1066     case FIELD_PROP_FORMAT:
1067         rAny >>= nNumber;
1068         break;
1069     default:
1070         bRet = SwDBNameInfField::PutValue( rAny, nWhichId );
1071     }
1072     return bRet;
1073 }
1074
1075