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