xref: /aoo42x/main/sw/source/core/fields/dbfld.cxx (revision cdf0e10c) 
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