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