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