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 : #include <config_features.h>
21 :
22 : #include <textapi.hxx>
23 :
24 : #include <hintids.hxx>
25 : #include <com/sun/star/text/XText.hpp>
26 : #include <com/sun/star/script/Converter.hpp>
27 : #include <com/sun/star/text/SetVariableType.hpp>
28 : #include <com/sun/star/text/XTextFieldsSupplier.hpp>
29 : #include <com/sun/star/text/UserDataPart.hpp>
30 : #include <com/sun/star/text/ChapterFormat.hpp>
31 : #include <com/sun/star/text/XTextField.hpp>
32 : #include <com/sun/star/text/PlaceholderType.hpp>
33 : #include <com/sun/star/text/TemplateDisplayFormat.hpp>
34 : #include <com/sun/star/text/UserFieldFormat.hpp>
35 : #include <com/sun/star/text/PageNumberType.hpp>
36 : #include <com/sun/star/text/ReferenceFieldPart.hpp>
37 : #include <com/sun/star/text/FilenameDisplayFormat.hpp>
38 : #include <com/sun/star/text/XDependentTextField.hpp>
39 : #include <com/sun/star/text/DocumentStatistic.hpp>
40 : #include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
41 : #include <com/sun/star/document/XDocumentProperties.hpp>
42 : #include <com/sun/star/util/Date.hpp>
43 : #include <com/sun/star/util/Duration.hpp>
44 : #include <unotools/localedatawrapper.hxx>
45 : #include <editeng/unolingu.hxx>
46 : #include <comphelper/processfactory.hxx>
47 : #include <comphelper/types.hxx>
48 : #include <comphelper/string.hxx>
49 : #include <tools/urlobj.hxx>
50 : #include <vcl/svapp.hxx>
51 : #include <svl/urihelper.hxx>
52 : #include <unotools/useroptions.hxx>
53 : #include <unotools/syslocale.hxx>
54 : #include <svl/zforlist.hxx>
55 :
56 : #include <tools/time.hxx>
57 : #include <tools/datetime.hxx>
58 :
59 : #include <com/sun/star/beans/PropertyAttribute.hpp>
60 : #include <com/sun/star/util/DateTime.hpp>
61 : #include <com/sun/star/util/Time.hpp>
62 :
63 : #include <swmodule.hxx>
64 : #include <sfx2/app.hxx>
65 : #include <sfx2/docfile.hxx>
66 : #include <sfx2/doctempl.hxx>
67 : #include <fmtfld.hxx>
68 : #include <txtfld.hxx>
69 : #include <charfmt.hxx>
70 : #include <docstat.hxx>
71 : #include <pagedesc.hxx>
72 : #include <fmtpdsc.hxx>
73 : #include <doc.hxx>
74 : #include <IDocumentFieldsAccess.hxx>
75 : #include <IDocumentStatistics.hxx>
76 : #include <IDocumentStylePoolAccess.hxx>
77 : #include <IDocumentLayoutAccess.hxx>
78 : #include <rootfrm.hxx>
79 : #include <pagefrm.hxx>
80 : #include <cntfrm.hxx>
81 : #include <pam.hxx>
82 : #include <viewsh.hxx>
83 : #include <dbmgr.hxx>
84 : #include <shellres.hxx>
85 : #include <docufld.hxx>
86 : #include <flddat.hxx>
87 : #include <docfld.hxx>
88 : #include <ndtxt.hxx>
89 : #include <expfld.hxx>
90 : #include <poolfmt.hxx>
91 : #include <docsh.hxx>
92 : #include <unofldmid.h>
93 : #include <swunohelper.hxx>
94 : #include <comcore.hrc>
95 :
96 : #include <editeng/outliner.hxx>
97 : #include <editeng/outlobj.hxx>
98 : #include <switerator.hxx>
99 : #include <docary.hxx>
100 :
101 : #define URL_DECODE INetURLObject::DECODE_UNAMBIGUOUS
102 :
103 : using namespace ::com::sun::star;
104 : using namespace ::com::sun::star::uno;
105 : using namespace nsSwDocInfoSubType;
106 :
107 5052 : SwPageNumberFieldType::SwPageNumberFieldType()
108 : : SwFieldType( RES_PAGENUMBERFLD ),
109 : nNumberingType( SVX_NUM_ARABIC ),
110 5052 : bVirtuell( false )
111 : {
112 5052 : }
113 :
114 4830 : OUString SwPageNumberFieldType::Expand( sal_uInt32 nFmt, short nOff,
115 : sal_uInt16 const nPageNumber, sal_uInt16 const nMaxPage,
116 : const OUString& rUserStr ) const
117 : {
118 4830 : sal_uInt32 nTmpFmt = (SVX_NUM_PAGEDESC == nFmt) ? (sal_uInt32)nNumberingType : nFmt;
119 4830 : int const nTmp = nPageNumber + nOff;
120 :
121 4830 : if (0 > nTmp || SVX_NUM_NUMBER_NONE == nTmpFmt || (!bVirtuell && nTmp > nMaxPage))
122 0 : return OUString();
123 :
124 4830 : if( SVX_NUM_CHAR_SPECIAL == nTmpFmt )
125 0 : return rUserStr;
126 :
127 4830 : return FormatNumber( (sal_uInt16)nTmp, nTmpFmt );
128 : }
129 :
130 0 : SwFieldType* SwPageNumberFieldType::Copy() const
131 : {
132 0 : SwPageNumberFieldType *pTmp = new SwPageNumberFieldType();
133 :
134 0 : pTmp->nNumberingType = nNumberingType;
135 0 : pTmp->bVirtuell = bVirtuell;
136 :
137 0 : return pTmp;
138 : }
139 :
140 2076 : void SwPageNumberFieldType::ChangeExpansion( SwDoc* pDoc,
141 : bool bVirt,
142 : const sal_Int16* pNumFmt )
143 : {
144 2076 : if( pNumFmt )
145 1978 : nNumberingType = *pNumFmt;
146 :
147 2076 : bVirtuell = false;
148 2076 : if (bVirt && pDoc)
149 : {
150 : // check the flag since the layout NEVER sets it back
151 312 : const SfxItemPool &rPool = pDoc->GetAttrPool();
152 : const SwFmtPageDesc *pDesc;
153 312 : sal_uInt32 nMaxItems = rPool.GetItemCount2( RES_PAGEDESC );
154 2282 : for( sal_uInt32 n = 0; n < nMaxItems; ++n )
155 4878 : if( 0 != (pDesc = (SwFmtPageDesc*)rPool.GetItem2( RES_PAGEDESC, n ) )
156 5032 : && pDesc->GetNumOffset() && pDesc->GetDefinedIn() )
157 : {
158 446 : const SwCntntNode* pNd = PTR_CAST( SwCntntNode, pDesc->GetDefinedIn() );
159 446 : if( pNd )
160 : {
161 434 : if ( SwIterator<SwFrm,SwCntntNode>::FirstElement(*pNd) )
162 256 : bVirtuell = true;
163 : }
164 12 : else if( pDesc->GetDefinedIn()->ISA( SwFmt ))
165 : {
166 12 : SwAutoFmtGetDocNode aGetHt( &pDoc->GetNodes() );
167 12 : bVirtuell = !pDesc->GetDefinedIn()->GetInfo( aGetHt );
168 12 : break;
169 : }
170 : }
171 : }
172 2076 : }
173 :
174 8098 : SwPageNumberField::SwPageNumberField(SwPageNumberFieldType* pTyp,
175 : sal_uInt16 nSub, sal_uInt32 nFmt, short nOff,
176 : sal_uInt16 const nPageNumber, sal_uInt16 const nMaxPage)
177 : : SwField(pTyp, nFmt), nSubType(nSub), nOffset(nOff)
178 : , m_nPageNumber(nPageNumber)
179 8098 : , m_nMaxPage(nMaxPage)
180 : {
181 8098 : }
182 :
183 2076 : void SwPageNumberField::ChangeExpansion(sal_uInt16 const nPageNumber,
184 : sal_uInt16 const nMaxPage)
185 : {
186 2076 : m_nPageNumber = nPageNumber;
187 2076 : m_nMaxPage = nMaxPage;
188 2076 : }
189 :
190 4830 : OUString SwPageNumberField::Expand() const
191 : {
192 4830 : OUString sRet;
193 4830 : SwPageNumberFieldType* pFldType = (SwPageNumberFieldType*)GetTyp();
194 :
195 4830 : if( PG_NEXT == nSubType && 1 != nOffset )
196 : {
197 0 : sRet = pFldType->Expand(GetFormat(), 1, m_nPageNumber, m_nMaxPage, sUserStr);
198 0 : if (!sRet.isEmpty())
199 : {
200 0 : sRet = pFldType->Expand(GetFormat(), nOffset, m_nPageNumber, m_nMaxPage, sUserStr);
201 : }
202 : }
203 4830 : else if( PG_PREV == nSubType && -1 != nOffset )
204 : {
205 0 : sRet = pFldType->Expand(GetFormat(), -1, m_nPageNumber, m_nMaxPage, sUserStr);
206 0 : if (!sRet.isEmpty())
207 : {
208 0 : sRet = pFldType->Expand(GetFormat(), nOffset, m_nPageNumber, m_nMaxPage, sUserStr);
209 : }
210 : }
211 : else
212 4830 : sRet = pFldType->Expand(GetFormat(), nOffset, m_nPageNumber, m_nMaxPage, sUserStr);
213 4830 : return sRet;
214 : }
215 :
216 6710 : SwField* SwPageNumberField::Copy() const
217 : {
218 : SwPageNumberField *pTmp = new SwPageNumberField(
219 6710 : static_cast<SwPageNumberFieldType*>(GetTyp()), nSubType,
220 6710 : GetFormat(), nOffset, m_nPageNumber, m_nMaxPage);
221 6710 : pTmp->SetLanguage( GetLanguage() );
222 6710 : pTmp->SetUserString( sUserStr );
223 6710 : return pTmp;
224 : }
225 :
226 0 : OUString SwPageNumberField::GetPar2() const
227 : {
228 0 : return OUString::number(nOffset);
229 : }
230 :
231 0 : void SwPageNumberField::SetPar2(const OUString& rStr)
232 : {
233 0 : nOffset = (short)rStr.toInt32();
234 0 : }
235 :
236 5264 : sal_uInt16 SwPageNumberField::GetSubType() const
237 : {
238 5264 : return nSubType;
239 : }
240 :
241 12 : bool SwPageNumberField::QueryValue( uno::Any& rAny, sal_uInt16 nWhichId ) const
242 : {
243 12 : switch( nWhichId )
244 : {
245 : case FIELD_PROP_FORMAT:
246 8 : rAny <<= (sal_Int16)GetFormat();
247 8 : break;
248 : case FIELD_PROP_USHORT1:
249 2 : rAny <<= nOffset;
250 2 : break;
251 : case FIELD_PROP_SUBTYPE:
252 : {
253 : text::PageNumberType eType;
254 2 : eType = text::PageNumberType_CURRENT;
255 2 : if(nSubType == PG_PREV)
256 0 : eType = text::PageNumberType_PREV;
257 2 : else if(nSubType == PG_NEXT)
258 0 : eType = text::PageNumberType_NEXT;
259 2 : rAny.setValue(&eType, cppu::UnoType<text::PageNumberType>::get());
260 : }
261 2 : break;
262 : case FIELD_PROP_PAR1:
263 0 : rAny <<= sUserStr;
264 0 : break;
265 :
266 : default:
267 : OSL_FAIL("illegal property");
268 : }
269 12 : return true;
270 : }
271 :
272 434 : bool SwPageNumberField::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId )
273 : {
274 434 : bool bRet = true;
275 434 : sal_Int16 nSet = 0;
276 434 : switch( nWhichId )
277 : {
278 : case FIELD_PROP_FORMAT:
279 0 : rAny >>= nSet;
280 :
281 : // TODO: woher kommen die defines?
282 0 : if(nSet <= SVX_NUM_PAGEDESC )
283 0 : SetFormat(nSet);
284 : else {
285 : }
286 0 : break;
287 : case FIELD_PROP_USHORT1:
288 0 : rAny >>= nSet;
289 0 : nOffset = nSet;
290 0 : break;
291 : case FIELD_PROP_SUBTYPE:
292 434 : switch( SWUnoHelper::GetEnumAsInt32( rAny ) )
293 : {
294 : case text::PageNumberType_CURRENT:
295 434 : nSubType = PG_RANDOM;
296 434 : break;
297 : case text::PageNumberType_PREV:
298 0 : nSubType = PG_PREV;
299 0 : break;
300 : case text::PageNumberType_NEXT:
301 0 : nSubType = PG_NEXT;
302 0 : break;
303 : default:
304 0 : bRet = false;
305 : }
306 434 : break;
307 : case FIELD_PROP_PAR1:
308 0 : rAny >>= sUserStr;
309 0 : break;
310 :
311 : default:
312 : OSL_FAIL("illegal property");
313 : }
314 434 : return bRet;
315 : }
316 :
317 5052 : SwAuthorFieldType::SwAuthorFieldType()
318 5052 : : SwFieldType( RES_AUTHORFLD )
319 : {
320 5052 : }
321 :
322 268 : OUString SwAuthorFieldType::Expand(sal_uLong nFmt) const
323 : {
324 268 : SvtUserOptions& rOpt = SW_MOD()->GetUserOptions();
325 268 : if((nFmt & 0xff) == AF_NAME)
326 0 : return rOpt.GetFullName();
327 :
328 268 : return rOpt.GetID();
329 : }
330 :
331 0 : SwFieldType* SwAuthorFieldType::Copy() const
332 : {
333 0 : return new SwAuthorFieldType;
334 : }
335 :
336 268 : SwAuthorField::SwAuthorField(SwAuthorFieldType* pTyp, sal_uInt32 nFmt)
337 268 : : SwField(pTyp, nFmt)
338 : {
339 268 : aContent = ((SwAuthorFieldType*)GetTyp())->Expand(GetFormat());
340 268 : }
341 :
342 116 : OUString SwAuthorField::Expand() const
343 : {
344 116 : if (!IsFixed())
345 0 : ((SwAuthorField*)this)->aContent =
346 0 : ((SwAuthorFieldType*)GetTyp())->Expand(GetFormat());
347 :
348 116 : return aContent;
349 : }
350 :
351 230 : SwField* SwAuthorField::Copy() const
352 : {
353 230 : SwAuthorField *pTmp = new SwAuthorField( (SwAuthorFieldType*)GetTyp(),
354 230 : GetFormat());
355 230 : pTmp->SetExpansion(aContent);
356 230 : return pTmp;
357 : }
358 :
359 80 : bool SwAuthorField::QueryValue( uno::Any& rAny, sal_uInt16 nWhichId ) const
360 : {
361 : bool bVal;
362 80 : switch( nWhichId )
363 : {
364 : case FIELD_PROP_BOOL1:
365 0 : bVal = (GetFormat() & 0xff) == AF_NAME;
366 0 : rAny.setValue(&bVal, ::getBooleanCppuType());
367 0 : break;
368 :
369 : case FIELD_PROP_BOOL2:
370 40 : bVal = IsFixed();
371 40 : rAny.setValue(&bVal, ::getBooleanCppuType());
372 40 : break;
373 :
374 : case FIELD_PROP_PAR1:
375 40 : rAny <<= GetContent();
376 40 : break;
377 :
378 : default:
379 : OSL_FAIL("illegal property");
380 : }
381 80 : return true;
382 : }
383 :
384 0 : bool SwAuthorField::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId )
385 : {
386 0 : switch( nWhichId )
387 : {
388 : case FIELD_PROP_BOOL1:
389 0 : SetFormat( *(sal_Bool*)rAny.getValue() ? AF_NAME : AF_SHORTCUT );
390 0 : break;
391 :
392 : case FIELD_PROP_BOOL2:
393 0 : if( *(sal_Bool*)rAny.getValue() )
394 0 : SetFormat( GetFormat() | AF_FIXED);
395 : else
396 0 : SetFormat( GetFormat() & ~AF_FIXED);
397 0 : break;
398 :
399 : case FIELD_PROP_PAR1:
400 0 : rAny >>= aContent;
401 0 : break;
402 :
403 : default:
404 : OSL_FAIL("illegal property");
405 : }
406 0 : return true;
407 : }
408 :
409 5054 : SwFileNameFieldType::SwFileNameFieldType(SwDoc *pDocument)
410 5054 : : SwFieldType( RES_FILENAMEFLD )
411 : {
412 5054 : pDoc = pDocument;
413 5054 : }
414 :
415 304 : OUString SwFileNameFieldType::Expand(sal_uLong nFmt) const
416 : {
417 304 : OUString aRet;
418 304 : const SwDocShell* pDShell = pDoc->GetDocShell();
419 304 : if( pDShell && pDShell->HasName() )
420 : {
421 224 : const INetURLObject& rURLObj = pDShell->GetMedium()->GetURLObject();
422 224 : switch( nFmt & ~FF_FIXED )
423 : {
424 : case FF_PATH:
425 : {
426 2 : if( INET_PROT_FILE == rURLObj.GetProtocol() )
427 : {
428 2 : INetURLObject aTemp(rURLObj);
429 2 : aTemp.removeSegment();
430 : // last slash should belong to the pathname
431 2 : aRet = aTemp.PathToFileName();
432 : }
433 : else
434 : {
435 0 : aRet = URIHelper::removePassword(
436 : rURLObj.GetMainURL( INetURLObject::NO_DECODE ),
437 0 : INetURLObject::WAS_ENCODED, URL_DECODE );
438 0 : const sal_Int32 nPos = aRet.indexOf(rURLObj.GetLastName( URL_DECODE ));
439 0 : if (nPos>=0)
440 : {
441 0 : aRet = aRet.copy(0, nPos);
442 : }
443 : }
444 : }
445 2 : break;
446 :
447 : case FF_NAME:
448 14 : aRet = rURLObj.GetLastName( INetURLObject::DECODE_WITH_CHARSET );
449 14 : break;
450 :
451 : case FF_NAME_NOEXT:
452 10 : aRet = rURLObj.GetBase();
453 10 : break;
454 :
455 : default:
456 198 : if( INET_PROT_FILE == rURLObj.GetProtocol() )
457 198 : aRet = rURLObj.GetFull();
458 : else
459 0 : aRet = URIHelper::removePassword(
460 : rURLObj.GetMainURL( INetURLObject::NO_DECODE ),
461 0 : INetURLObject::WAS_ENCODED, URL_DECODE );
462 : }
463 : }
464 304 : return aRet;
465 : }
466 :
467 0 : SwFieldType* SwFileNameFieldType::Copy() const
468 : {
469 0 : SwFieldType *pTmp = new SwFileNameFieldType(pDoc);
470 0 : return pTmp;
471 : }
472 :
473 144 : SwFileNameField::SwFileNameField(SwFileNameFieldType* pTyp, sal_uInt32 nFmt)
474 144 : : SwField(pTyp, nFmt)
475 : {
476 144 : aContent = ((SwFileNameFieldType*)GetTyp())->Expand(GetFormat());
477 144 : }
478 :
479 152 : OUString SwFileNameField::Expand() const
480 : {
481 152 : if (!IsFixed())
482 152 : ((SwFileNameField*)this)->aContent = ((SwFileNameFieldType*)GetTyp())->Expand(GetFormat());
483 :
484 152 : return aContent;
485 : }
486 :
487 124 : SwField* SwFileNameField::Copy() const
488 : {
489 : SwFileNameField *pTmp =
490 124 : new SwFileNameField((SwFileNameFieldType*)GetTyp(), GetFormat());
491 124 : pTmp->SetExpansion(aContent);
492 :
493 124 : return pTmp;
494 : }
495 :
496 0 : bool SwFileNameField::QueryValue( uno::Any& rAny, sal_uInt16 nWhichId ) const
497 : {
498 0 : switch( nWhichId )
499 : {
500 : case FIELD_PROP_FORMAT:
501 : {
502 : sal_Int16 nRet;
503 0 : switch( GetFormat() &(~FF_FIXED) )
504 : {
505 : case FF_PATH:
506 0 : nRet = text::FilenameDisplayFormat::PATH;
507 0 : break;
508 : case FF_NAME_NOEXT:
509 0 : nRet = text::FilenameDisplayFormat::NAME;
510 0 : break;
511 : case FF_NAME:
512 0 : nRet = text::FilenameDisplayFormat::NAME_AND_EXT;
513 0 : break;
514 0 : default: nRet = text::FilenameDisplayFormat::FULL;
515 : }
516 0 : rAny <<= nRet;
517 : }
518 0 : break;
519 :
520 : case FIELD_PROP_BOOL2:
521 : {
522 0 : sal_Bool bVal = IsFixed();
523 0 : rAny.setValue(&bVal, ::getBooleanCppuType());
524 : }
525 0 : break;
526 :
527 : case FIELD_PROP_PAR3:
528 0 : rAny <<= GetContent();
529 0 : break;
530 : default:
531 : OSL_FAIL("illegal property");
532 : }
533 0 : return true;
534 : }
535 :
536 20 : bool SwFileNameField::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId )
537 : {
538 20 : switch( nWhichId )
539 : {
540 : case FIELD_PROP_FORMAT:
541 : {
542 : //JP 24.10.2001: int32 because in UnoField.cxx a putvalue is
543 : // called with a int32 value! But normally we need
544 : // here only a int16
545 20 : sal_Int32 nType = 0;
546 20 : rAny >>= nType;
547 20 : bool bFixed = IsFixed();
548 20 : switch( nType )
549 : {
550 : case text::FilenameDisplayFormat::PATH:
551 0 : nType = FF_PATH;
552 0 : break;
553 : case text::FilenameDisplayFormat::NAME:
554 8 : nType = FF_NAME_NOEXT;
555 8 : break;
556 : case text::FilenameDisplayFormat::NAME_AND_EXT:
557 0 : nType = FF_NAME;
558 0 : break;
559 12 : default: nType = FF_PATHNAME;
560 : }
561 20 : if(bFixed)
562 0 : nType |= FF_FIXED;
563 20 : SetFormat(nType);
564 : }
565 20 : break;
566 :
567 : case FIELD_PROP_BOOL2:
568 0 : if( *(sal_Bool*)rAny.getValue() )
569 0 : SetFormat( GetFormat() | FF_FIXED);
570 : else
571 0 : SetFormat( GetFormat() & ~FF_FIXED);
572 0 : break;
573 :
574 : case FIELD_PROP_PAR3:
575 0 : rAny >>= aContent;
576 0 : break;
577 :
578 : default:
579 : OSL_FAIL("illegal property");
580 : }
581 20 : return true;
582 : }
583 :
584 10104 : SwTemplNameFieldType::SwTemplNameFieldType(SwDoc *pDocument)
585 10104 : : SwFieldType( RES_TEMPLNAMEFLD )
586 : {
587 10104 : pDoc = pDocument;
588 10104 : }
589 :
590 0 : OUString SwTemplNameFieldType::Expand(sal_uLong nFmt) const
591 : {
592 : OSL_ENSURE( nFmt < FF_END, "Expand: no valid Fmt!" );
593 :
594 0 : OUString aRet;
595 0 : SwDocShell *pDocShell(pDoc->GetDocShell());
596 : OSL_ENSURE(pDocShell, "no SwDocShell");
597 0 : if (pDocShell) {
598 : uno::Reference<document::XDocumentPropertiesSupplier> xDPS(
599 0 : pDocShell->GetModel(), uno::UNO_QUERY_THROW);
600 : uno::Reference<document::XDocumentProperties> xDocProps(
601 0 : xDPS->getDocumentProperties());
602 : OSL_ENSURE(xDocProps.is(), "Doc has no DocumentProperties");
603 :
604 0 : if( FF_UI_NAME == nFmt )
605 0 : aRet = xDocProps->getTemplateName();
606 0 : else if( !xDocProps->getTemplateURL().isEmpty() )
607 : {
608 0 : if( FF_UI_RANGE == nFmt )
609 : {
610 : // for getting region names!
611 0 : SfxDocumentTemplates aFac;
612 0 : aFac.Construct();
613 0 : OUString sTmp;
614 0 : OUString sRegion;
615 0 : aFac.GetLogicNames( xDocProps->getTemplateURL(), sRegion, sTmp );
616 0 : aRet = sRegion;
617 : }
618 : else
619 : {
620 0 : INetURLObject aPathName( xDocProps->getTemplateURL() );
621 0 : if( FF_NAME == nFmt )
622 0 : aRet = aPathName.GetName(URL_DECODE);
623 0 : else if( FF_NAME_NOEXT == nFmt )
624 0 : aRet = aPathName.GetBase();
625 : else
626 : {
627 0 : if( FF_PATH == nFmt )
628 : {
629 0 : aPathName.removeSegment();
630 0 : aRet = aPathName.GetFull();
631 : }
632 : else
633 0 : aRet = aPathName.GetFull();
634 0 : }
635 : }
636 0 : }
637 : }
638 0 : return aRet;
639 : }
640 :
641 0 : SwFieldType* SwTemplNameFieldType::Copy() const
642 : {
643 0 : SwFieldType *pTmp = new SwTemplNameFieldType(pDoc);
644 0 : return pTmp;
645 : }
646 :
647 0 : SwTemplNameField::SwTemplNameField(SwTemplNameFieldType* pTyp, sal_uInt32 nFmt)
648 0 : : SwField(pTyp, nFmt)
649 0 : {}
650 :
651 0 : OUString SwTemplNameField::Expand() const
652 : {
653 0 : return((SwTemplNameFieldType*)GetTyp())->Expand(GetFormat());
654 : }
655 :
656 0 : SwField* SwTemplNameField::Copy() const
657 : {
658 : SwTemplNameField *pTmp =
659 0 : new SwTemplNameField((SwTemplNameFieldType*)GetTyp(), GetFormat());
660 0 : return pTmp;
661 : }
662 :
663 0 : bool SwTemplNameField::QueryValue( uno::Any& rAny, sal_uInt16 nWhichId ) const
664 : {
665 0 : switch ( nWhichId )
666 : {
667 : case FIELD_PROP_FORMAT:
668 : {
669 : sal_Int16 nRet;
670 0 : switch( GetFormat() )
671 : {
672 0 : case FF_PATH: nRet = text::FilenameDisplayFormat::PATH; break;
673 0 : case FF_NAME_NOEXT: nRet = text::FilenameDisplayFormat::NAME; break;
674 0 : case FF_NAME: nRet = text::FilenameDisplayFormat::NAME_AND_EXT; break;
675 0 : case FF_UI_RANGE: nRet = text::TemplateDisplayFormat::AREA; break;
676 0 : case FF_UI_NAME: nRet = text::TemplateDisplayFormat::TITLE; break;
677 0 : default: nRet = text::FilenameDisplayFormat::FULL;
678 :
679 : }
680 0 : rAny <<= nRet;
681 : }
682 0 : break;
683 : default:
684 : OSL_FAIL("illegal property");
685 : }
686 0 : return true;
687 : }
688 :
689 0 : bool SwTemplNameField::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId )
690 : {
691 0 : switch ( nWhichId )
692 : {
693 : case FIELD_PROP_FORMAT:
694 : {
695 : //JP 24.10.2001: int32 because in UnoField.cxx a putvalue is
696 : // called with a int32 value! But normally we need
697 : // here only a int16
698 0 : sal_Int32 nType = 0;
699 0 : rAny >>= nType;
700 0 : switch( nType )
701 : {
702 : case text::FilenameDisplayFormat::PATH:
703 0 : SetFormat(FF_PATH);
704 0 : break;
705 : case text::FilenameDisplayFormat::NAME:
706 0 : SetFormat(FF_NAME_NOEXT);
707 0 : break;
708 : case text::FilenameDisplayFormat::NAME_AND_EXT:
709 0 : SetFormat(FF_NAME);
710 0 : break;
711 : case text::TemplateDisplayFormat::AREA :
712 0 : SetFormat(FF_UI_RANGE);
713 0 : break;
714 : case text::TemplateDisplayFormat::TITLE :
715 0 : SetFormat(FF_UI_NAME);
716 0 : break;
717 0 : default: SetFormat(FF_PATHNAME);
718 : }
719 : }
720 0 : break;
721 : default:
722 : OSL_FAIL("illegal property");
723 : }
724 0 : return true;
725 : }
726 :
727 5052 : SwDocStatFieldType::SwDocStatFieldType(SwDoc* pDocument)
728 5052 : : SwFieldType( RES_DOCSTATFLD ), nNumberingType( SVX_NUM_ARABIC )
729 : {
730 5052 : pDoc = pDocument;
731 5052 : }
732 :
733 674 : OUString SwDocStatFieldType::Expand(sal_uInt16 nSubType, sal_uInt32 nFmt) const
734 : {
735 674 : sal_uInt32 nVal = 0;
736 674 : const SwDocStat& rDStat = pDoc->getIDocumentStatistics().GetDocStat();
737 674 : switch( nSubType )
738 : {
739 0 : case DS_TBL: nVal = rDStat.nTbl; break;
740 0 : case DS_GRF: nVal = rDStat.nGrf; break;
741 0 : case DS_OLE: nVal = rDStat.nOLE; break;
742 0 : case DS_PARA: nVal = rDStat.nPara; break;
743 0 : case DS_WORD: nVal = rDStat.nWord; break;
744 0 : case DS_CHAR: nVal = rDStat.nChar; break;
745 : case DS_PAGE:
746 674 : if( pDoc->getIDocumentLayoutAccess().GetCurrentLayout() )
747 556 : ((SwDocStat &)rDStat).nPage = pDoc->getIDocumentLayoutAccess().GetCurrentLayout()->GetPageNum();
748 674 : nVal = rDStat.nPage;
749 674 : if( SVX_NUM_PAGEDESC == nFmt )
750 524 : nFmt = (sal_uInt32)nNumberingType;
751 674 : break;
752 : default:
753 : OSL_FAIL( "SwDocStatFieldType::Expand: unknown SubType" );
754 : }
755 :
756 674 : if( nVal <= SHRT_MAX )
757 674 : return FormatNumber( (sal_uInt16)nVal, nFmt );
758 :
759 0 : return OUString::number( nVal );
760 : }
761 :
762 0 : SwFieldType* SwDocStatFieldType::Copy() const
763 : {
764 0 : SwDocStatFieldType *pTmp = new SwDocStatFieldType(pDoc);
765 0 : return pTmp;
766 : }
767 :
768 : /**
769 : * @param pTyp
770 : * @param nSub SubType
771 : * @param nFmt
772 : */
773 398 : SwDocStatField::SwDocStatField(SwDocStatFieldType* pTyp, sal_uInt16 nSub, sal_uInt32 nFmt)
774 : : SwField(pTyp, nFmt),
775 398 : nSubType(nSub)
776 398 : {}
777 :
778 674 : OUString SwDocStatField::Expand() const
779 : {
780 674 : return((SwDocStatFieldType*)GetTyp())->Expand(nSubType, GetFormat());
781 : }
782 :
783 338 : SwField* SwDocStatField::Copy() const
784 : {
785 : SwDocStatField *pTmp = new SwDocStatField(
786 338 : (SwDocStatFieldType*)GetTyp(), nSubType, GetFormat() );
787 338 : return pTmp;
788 : }
789 :
790 210 : sal_uInt16 SwDocStatField::GetSubType() const
791 : {
792 210 : return nSubType;
793 : }
794 :
795 0 : void SwDocStatField::SetSubType(sal_uInt16 nSub)
796 : {
797 0 : nSubType = nSub;
798 0 : }
799 :
800 278 : void SwDocStatField::ChangeExpansion( const SwFrm* pFrm )
801 : {
802 278 : if( DS_PAGE == nSubType && SVX_NUM_PAGEDESC == GetFormat() )
803 230 : ((SwDocStatFieldType*)GetTyp())->SetNumFormat(
804 460 : pFrm->FindPageFrm()->GetPageDesc()->GetNumType().GetNumberingType() );
805 278 : }
806 :
807 2 : bool SwDocStatField::QueryValue( uno::Any& rAny, sal_uInt16 nWhichId ) const
808 : {
809 2 : switch ( nWhichId )
810 : {
811 : case FIELD_PROP_USHORT2:
812 2 : rAny <<= (sal_Int16)GetFormat();
813 2 : break;
814 : default:
815 : OSL_FAIL("illegal property");
816 : }
817 2 : return true;
818 : }
819 :
820 0 : bool SwDocStatField::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId )
821 : {
822 0 : bool bRet = false;
823 0 : switch ( nWhichId )
824 : {
825 : case FIELD_PROP_USHORT2:
826 : {
827 0 : sal_Int16 nSet = 0;
828 0 : rAny >>= nSet;
829 0 : if(nSet <= SVX_NUM_CHARS_LOWER_LETTER_N &&
830 0 : nSet != SVX_NUM_CHAR_SPECIAL &&
831 0 : nSet != SVX_NUM_BITMAP)
832 : {
833 0 : SetFormat(nSet);
834 0 : bRet = true;
835 : }
836 : }
837 0 : break;
838 :
839 : default:
840 : OSL_FAIL("illegal property");
841 : }
842 0 : return bRet;
843 : }
844 :
845 : // Document info field type
846 :
847 5052 : SwDocInfoFieldType::SwDocInfoFieldType(SwDoc* pDc)
848 5052 : : SwValueFieldType( pDc, RES_DOCINFOFLD )
849 : {
850 5052 : }
851 :
852 0 : SwFieldType* SwDocInfoFieldType::Copy() const
853 : {
854 0 : SwDocInfoFieldType* pTyp = new SwDocInfoFieldType(GetDoc());
855 0 : return pTyp;
856 : }
857 :
858 56 : static void lcl_GetLocalDataWrapper( sal_uLong nLang,
859 : const LocaleDataWrapper **ppAppLocalData,
860 : const LocaleDataWrapper **ppLocalData )
861 : {
862 56 : SvtSysLocale aLocale;
863 56 : *ppAppLocalData = &aLocale.GetLocaleData();
864 56 : *ppLocalData = *ppAppLocalData;
865 56 : if( nLang != (*ppLocalData)->getLanguageTag().getLanguageType() )
866 : *ppLocalData = new LocaleDataWrapper(
867 56 : LanguageTag( static_cast<LanguageType>(nLang) ));
868 56 : }
869 :
870 404 : OUString SwDocInfoFieldType::Expand( sal_uInt16 nSub, sal_uInt32 nFormat,
871 : sal_uInt16 nLang, const OUString& rName ) const
872 : {
873 404 : const LocaleDataWrapper *pAppLocalData = 0, *pLocalData = 0;
874 404 : SwDocShell *pDocShell(GetDoc()->GetDocShell());
875 : OSL_ENSURE(pDocShell, "no SwDocShell");
876 404 : if (!pDocShell) { return OUString(); }
877 :
878 : uno::Reference<document::XDocumentPropertiesSupplier> xDPS(
879 404 : pDocShell->GetModel(), uno::UNO_QUERY_THROW);
880 : uno::Reference<document::XDocumentProperties> xDocProps(
881 808 : xDPS->getDocumentProperties());
882 : OSL_ENSURE(xDocProps.is(), "Doc has no DocumentProperties");
883 :
884 404 : sal_uInt16 nExtSub = nSub & 0xff00;
885 404 : nSub &= 0xff; // do not consider extended SubTypes
886 :
887 808 : OUString aStr;
888 404 : switch(nSub)
889 : {
890 190 : case DI_TITEL: aStr = xDocProps->getTitle(); break;
891 0 : case DI_THEMA: aStr = xDocProps->getSubject(); break;
892 0 : case DI_KEYS: aStr = ::comphelper::string::convertCommaSeparated(
893 0 : xDocProps->getKeywords());
894 0 : break;
895 0 : case DI_COMMENT:aStr = xDocProps->getDescription(); break;
896 112 : case DI_DOCNO: aStr = OUString::number(
897 112 : xDocProps->getEditingCycles() );
898 56 : break;
899 : case DI_EDIT:
900 56 : if ( !nFormat )
901 : {
902 56 : lcl_GetLocalDataWrapper( nLang, &pAppLocalData, &pLocalData );
903 56 : sal_Int32 dur = xDocProps->getEditingDuration();
904 : // If Seconds > 0 then bSec should be TRUE otherwise Seconds
905 : // information will be lost if file has EditTime in Seconds format.
906 112 : aStr = pLocalData->getTime( tools::Time(dur/3600, (dur%3600)/60, dur%60),
907 112 : (dur%60 > 0 ? true : false), false);
908 : }
909 : else
910 : {
911 0 : sal_Int32 dur = xDocProps->getEditingDuration();
912 0 : double fVal = tools::Time(dur/3600, (dur%3600)/60, dur%60).GetTimeInDays();
913 0 : aStr = ExpandValue(fVal, nFormat, nLang);
914 : }
915 56 : break;
916 : case DI_CUSTOM:
917 : {
918 24 : OUString sVal;
919 : try
920 : {
921 24 : uno::Any aAny;
922 : uno::Reference < beans::XPropertySet > xSet(
923 24 : xDocProps->getUserDefinedProperties(),
924 48 : uno::UNO_QUERY_THROW);
925 24 : aAny = xSet->getPropertyValue( rName );
926 :
927 48 : uno::Reference < script::XTypeConverter > xConverter( script::Converter::create(comphelper::getProcessComponentContext()) );
928 48 : uno::Any aNew;
929 24 : aNew = xConverter->convertToSimpleType( aAny, uno::TypeClass_STRING );
930 36 : aNew >>= sVal;
931 : }
932 12 : catch (uno::Exception&) {}
933 24 : return sVal;
934 : }
935 :
936 : default:
937 : {
938 78 : OUString aName( xDocProps->getAuthor() );
939 78 : util::DateTime uDT( xDocProps->getCreationDate() );
940 78 : Date aD(uDT.Day, uDT.Month, uDT.Year);
941 78 : tools::Time aT(uDT.Hours, uDT.Minutes, uDT.Seconds, uDT.NanoSeconds);
942 78 : DateTime aDate(aD,aT);
943 78 : if( nSub == DI_CREATE )
944 : ; // das wars schon!!
945 78 : else if( nSub == DI_CHANGE )
946 : {
947 78 : aName = xDocProps->getModifiedBy();
948 78 : uDT = xDocProps->getModificationDate();
949 78 : Date bD(uDT.Day, uDT.Month, uDT.Year);
950 78 : tools::Time bT(uDT.Hours, uDT.Minutes, uDT.Seconds, uDT.NanoSeconds);
951 78 : DateTime bDate(bD,bT);
952 78 : aDate = bDate;
953 : }
954 0 : else if( nSub == DI_PRINT )
955 : {
956 0 : aName = xDocProps->getPrintedBy();
957 0 : uDT = xDocProps->getPrintDate();
958 0 : Date bD(uDT.Day, uDT.Month, uDT.Year);
959 0 : tools::Time bT(uDT.Hours, uDT.Minutes, uDT.Seconds, uDT.NanoSeconds);
960 0 : DateTime bDate(bD,bT);
961 0 : aDate = bDate;
962 : }
963 : else
964 0 : break;
965 :
966 78 : if (aDate.IsValidAndGregorian())
967 : {
968 78 : switch (nExtSub & ~DI_SUB_FIXED)
969 : {
970 : case DI_SUB_AUTHOR:
971 56 : aStr = aName;
972 56 : break;
973 :
974 : case DI_SUB_TIME:
975 0 : if (!nFormat)
976 : {
977 : lcl_GetLocalDataWrapper( nLang, &pAppLocalData,
978 0 : &pLocalData );
979 0 : aStr = pLocalData->getTime( aDate,
980 0 : false, false);
981 : }
982 : else
983 : {
984 : // Numberformatter anwerfen!
985 : double fVal = SwDateTimeField::GetDateTime( GetDoc(),
986 0 : aDate);
987 0 : aStr = ExpandValue(fVal, nFormat, nLang);
988 : }
989 0 : break;
990 :
991 : case DI_SUB_DATE:
992 22 : if (!nFormat)
993 : {
994 : lcl_GetLocalDataWrapper( nLang, &pAppLocalData,
995 0 : &pLocalData );
996 0 : aStr = pLocalData->getDate( aDate );
997 : }
998 : else
999 : {
1000 : // Numberformatter anwerfen!
1001 : double fVal = SwDateTimeField::GetDateTime( GetDoc(),
1002 22 : aDate);
1003 22 : aStr = ExpandValue(fVal, nFormat, nLang);
1004 : }
1005 22 : break;
1006 : }
1007 78 : }
1008 : }
1009 78 : break;
1010 : }
1011 :
1012 380 : if( pAppLocalData != pLocalData )
1013 56 : delete pLocalData;
1014 :
1015 784 : return aStr;
1016 : }
1017 :
1018 : // document info field
1019 :
1020 270 : SwDocInfoField::SwDocInfoField(SwDocInfoFieldType* pTyp, sal_uInt16 nSub, const OUString& rName, sal_uInt32 nFmt) :
1021 270 : SwValueField(pTyp, nFmt), nSubType(nSub)
1022 : {
1023 270 : aName = rName;
1024 270 : aContent = ((SwDocInfoFieldType*)GetTyp())->Expand(nSubType, nFmt, GetLanguage(), aName);
1025 270 : }
1026 :
1027 0 : SwDocInfoField::SwDocInfoField(SwDocInfoFieldType* pTyp, sal_uInt16 nSub, const OUString& rName, const OUString& rValue, sal_uInt32 nFmt) :
1028 0 : SwValueField(pTyp, nFmt), nSubType(nSub)
1029 : {
1030 0 : aName = rName;
1031 0 : aContent = rValue;
1032 0 : }
1033 :
1034 : template<class T>
1035 6 : static double lcl_TimeToDouble( const T& rTime )
1036 : {
1037 6 : const double fNanoSecondsPerDay = 86400000000000.0;
1038 6 : return ((rTime.Hours*3600000)+(rTime.Minutes*60000)+(rTime.Seconds*1000)+(rTime.NanoSeconds)) / fNanoSecondsPerDay;
1039 : }
1040 :
1041 : template<class D>
1042 6 : static double lcl_DateToDouble( const D& rDate, const Date& rNullDate )
1043 : {
1044 6 : long nDate = Date::DateToDays( rDate.Day, rDate.Month, rDate.Year );
1045 6 : long nNullDate = Date::DateToDays( rNullDate.GetDay(), rNullDate.GetMonth(), rNullDate.GetYear() );
1046 6 : return double( nDate - nNullDate );
1047 : }
1048 :
1049 146 : OUString SwDocInfoField::Expand() const
1050 : {
1051 146 : if ( ( nSubType & 0xFF ) == DI_CUSTOM )
1052 : {
1053 : // custom properties currently need special treatment
1054 : // We don't have a secure way to detect "real" custom properties in Word import of text
1055 : // fields, so we treat *every* unknown property as a custom property, even the "built-in"
1056 : // section in Word's document summary information stream as these properties have not been
1057 : // inserted when the document summary information was imported, we do it here.
1058 : // This approach is still a lot better than the old one to import such fields as
1059 : // "user fields" and simple text
1060 12 : SwDocShell* pDocShell = GetDoc()->GetDocShell();
1061 12 : if( !pDocShell )
1062 0 : return aContent;
1063 : try
1064 : {
1065 12 : uno::Reference<document::XDocumentPropertiesSupplier> xDPS( pDocShell->GetModel(), uno::UNO_QUERY_THROW);
1066 24 : uno::Reference<document::XDocumentProperties> xDocProps( xDPS->getDocumentProperties());
1067 24 : uno::Reference < beans::XPropertySet > xSet( xDocProps->getUserDefinedProperties(), uno::UNO_QUERY_THROW);
1068 24 : uno::Reference < beans::XPropertySetInfo > xSetInfo = xSet->getPropertySetInfo();
1069 :
1070 24 : uno::Any aAny;
1071 12 : if( xSetInfo->hasPropertyByName( aName ) )
1072 12 : aAny = xSet->getPropertyValue( aName );
1073 12 : if ( aAny.getValueType() != ::getVoidCppuType() )
1074 : {
1075 : // "void" type means that the property has not been inserted until now
1076 12 : if ( !IsFixed() )
1077 : {
1078 : // if the field is "fixed" we don't update it from the property
1079 12 : OUString sVal;
1080 24 : uno::Reference < script::XTypeConverter > xConverter( script::Converter::create(comphelper::getProcessComponentContext()) );
1081 12 : util::Date aDate;
1082 12 : util::DateTime aDateTime;
1083 12 : util::Duration aDuration;
1084 12 : if( aAny >>= aDate)
1085 : {
1086 0 : SvNumberFormatter* pFormatter = pDocShell->GetDoc()->GetNumberFormatter();
1087 0 : Date* pNullDate = pFormatter->GetNullDate();
1088 0 : sVal = ExpandValue( lcl_DateToDouble<util::Date>( aDate, *pNullDate ), GetFormat(), GetLanguage());
1089 : }
1090 12 : else if( aAny >>= aDateTime )
1091 : {
1092 6 : double fDateTime = lcl_TimeToDouble<util::DateTime>( aDateTime );
1093 6 : SvNumberFormatter* pFormatter = pDocShell->GetDoc()->GetNumberFormatter();
1094 6 : Date* pNullDate = pFormatter->GetNullDate();
1095 6 : fDateTime += lcl_DateToDouble<util::DateTime>( aDateTime, *pNullDate );
1096 6 : sVal = ExpandValue( fDateTime, GetFormat(), GetLanguage());
1097 : }
1098 6 : else if( aAny >>= aDuration )
1099 : {
1100 0 : sVal = OUString(aDuration.Negative ? '-' : '+')
1101 0 : + SwViewShell::GetShellRes()->sDurationFormat;
1102 0 : sVal = sVal.replaceFirst("%1", OUString::number( aDuration.Years ) );
1103 0 : sVal = sVal.replaceFirst("%2", OUString::number( aDuration.Months ) );
1104 0 : sVal = sVal.replaceFirst("%3", OUString::number( aDuration.Days ) );
1105 0 : sVal = sVal.replaceFirst("%4", OUString::number( aDuration.Hours ) );
1106 0 : sVal = sVal.replaceFirst("%5", OUString::number( aDuration.Minutes) );
1107 0 : sVal = sVal.replaceFirst("%6", OUString::number( aDuration.Seconds) );
1108 : }
1109 : else
1110 : {
1111 6 : uno::Any aNew = xConverter->convertToSimpleType( aAny, uno::TypeClass_STRING );
1112 6 : aNew >>= sVal;
1113 : }
1114 24 : ((SwDocInfoField*)this)->aContent = sVal;
1115 : }
1116 12 : }
1117 : }
1118 0 : catch (uno::Exception&) {}
1119 : }
1120 134 : else if ( !IsFixed() )
1121 134 : ((SwDocInfoField*)this)->aContent = ((SwDocInfoFieldType*)GetTyp())->Expand(nSubType, GetFormat(), GetLanguage(), aName);
1122 :
1123 146 : return aContent;
1124 : }
1125 :
1126 0 : OUString SwDocInfoField::GetFieldName() const
1127 : {
1128 0 : OUString aStr(SwFieldType::GetTypeStr(GetTypeId()) + ":");
1129 :
1130 0 : sal_uInt16 const nSub = nSubType & 0xff;
1131 :
1132 0 : switch (nSub)
1133 : {
1134 : case DI_CUSTOM:
1135 0 : aStr += aName;
1136 0 : break;
1137 :
1138 : default:
1139 0 : aStr += SwViewShell::GetShellRes()
1140 0 : ->aDocInfoLst[ nSub - DI_SUBTYPE_BEGIN ];
1141 0 : break;
1142 : }
1143 0 : if (IsFixed())
1144 : {
1145 0 : aStr += " " + OUString(SwViewShell::GetShellRes()->aFixedStr);
1146 : }
1147 0 : return aStr;
1148 : }
1149 :
1150 232 : SwField* SwDocInfoField::Copy() const
1151 : {
1152 232 : SwDocInfoField* pFld = new SwDocInfoField((SwDocInfoFieldType*)GetTyp(), nSubType, aName, GetFormat());
1153 232 : pFld->SetAutomaticLanguage(IsAutomaticLanguage());
1154 232 : pFld->aContent = aContent;
1155 :
1156 232 : return pFld;
1157 : }
1158 :
1159 224 : sal_uInt16 SwDocInfoField::GetSubType() const
1160 : {
1161 224 : return nSubType;
1162 : }
1163 :
1164 0 : void SwDocInfoField::SetSubType(sal_uInt16 nSub)
1165 : {
1166 0 : nSubType = nSub;
1167 0 : }
1168 :
1169 30 : void SwDocInfoField::SetLanguage(sal_uInt16 nLng)
1170 : {
1171 30 : if (!GetFormat())
1172 26 : SwField::SetLanguage(nLng);
1173 : else
1174 4 : SwValueField::SetLanguage(nLng);
1175 30 : }
1176 :
1177 0 : bool SwDocInfoField::QueryValue( uno::Any& rAny, sal_uInt16 nWhichId ) const
1178 : {
1179 0 : switch( nWhichId )
1180 : {
1181 : case FIELD_PROP_PAR1:
1182 0 : rAny <<= aContent;
1183 0 : break;
1184 :
1185 : case FIELD_PROP_PAR4:
1186 0 : rAny <<= aName;
1187 0 : break;
1188 :
1189 : case FIELD_PROP_USHORT1:
1190 0 : rAny <<= (sal_Int16)aContent.toInt32();
1191 0 : break;
1192 :
1193 : case FIELD_PROP_BOOL1:
1194 : {
1195 0 : sal_Bool bVal = 0 != (nSubType & DI_SUB_FIXED);
1196 0 : rAny.setValue(&bVal, ::getBooleanCppuType());
1197 : }
1198 0 : break;
1199 : case FIELD_PROP_FORMAT:
1200 0 : rAny <<= (sal_Int32)GetFormat();
1201 0 : break;
1202 :
1203 : case FIELD_PROP_DOUBLE:
1204 : {
1205 0 : double fVal = GetValue();
1206 0 : rAny.setValue(&fVal, ::getCppuType(&fVal));
1207 : }
1208 0 : break;
1209 : case FIELD_PROP_PAR3:
1210 0 : rAny <<= Expand();
1211 0 : break;
1212 : case FIELD_PROP_BOOL2:
1213 : {
1214 0 : sal_uInt16 nExtSub = (nSubType & 0xff00) & ~DI_SUB_FIXED;
1215 0 : sal_Bool bVal = (nExtSub == DI_SUB_DATE);
1216 0 : rAny.setValue(&bVal, ::getBooleanCppuType());
1217 : }
1218 0 : break;
1219 : default:
1220 0 : return SwField::QueryValue(rAny, nWhichId);
1221 : }
1222 0 : return true;
1223 : }
1224 :
1225 0 : bool SwDocInfoField::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId )
1226 : {
1227 0 : sal_Int32 nValue = 0;
1228 0 : switch( nWhichId )
1229 : {
1230 : case FIELD_PROP_PAR1:
1231 0 : if( nSubType & DI_SUB_FIXED )
1232 0 : rAny >>= aContent;
1233 0 : break;
1234 :
1235 : case FIELD_PROP_USHORT1:
1236 0 : if( nSubType & DI_SUB_FIXED )
1237 : {
1238 0 : rAny >>= nValue;
1239 0 : aContent = OUString::number(nValue);
1240 : }
1241 0 : break;
1242 :
1243 : case FIELD_PROP_BOOL1:
1244 0 : if(*(sal_Bool*)rAny.getValue())
1245 0 : nSubType |= DI_SUB_FIXED;
1246 : else
1247 0 : nSubType &= ~DI_SUB_FIXED;
1248 0 : break;
1249 : case FIELD_PROP_FORMAT:
1250 : {
1251 0 : rAny >>= nValue;
1252 0 : if( nValue >= 0)
1253 0 : SetFormat(nValue);
1254 : }
1255 0 : break;
1256 :
1257 : case FIELD_PROP_PAR3:
1258 0 : rAny >>= aContent;
1259 0 : break;
1260 : case FIELD_PROP_BOOL2:
1261 0 : nSubType &= 0xf0ff;
1262 0 : if(*(sal_Bool*)rAny.getValue())
1263 0 : nSubType |= DI_SUB_DATE;
1264 : else
1265 0 : nSubType |= DI_SUB_TIME;
1266 0 : break;
1267 : default:
1268 0 : return SwField::PutValue(rAny, nWhichId);
1269 : }
1270 0 : return true;
1271 : }
1272 :
1273 5052 : SwHiddenTxtFieldType::SwHiddenTxtFieldType( bool bSetHidden )
1274 5052 : : SwFieldType( RES_HIDDENTXTFLD ), bHidden( bSetHidden )
1275 : {
1276 5052 : }
1277 :
1278 0 : SwFieldType* SwHiddenTxtFieldType::Copy() const
1279 : {
1280 0 : return new SwHiddenTxtFieldType( bHidden );
1281 : }
1282 :
1283 5324 : void SwHiddenTxtFieldType::SetHiddenFlag( bool bSetHidden )
1284 : {
1285 5324 : if( bHidden != bSetHidden )
1286 : {
1287 6 : bHidden = bSetHidden;
1288 6 : UpdateFlds(); // notify all HiddenTexts
1289 : }
1290 5324 : }
1291 :
1292 0 : SwHiddenTxtField::SwHiddenTxtField( SwHiddenTxtFieldType* pFldType,
1293 : bool bConditional,
1294 : const OUString& rCond,
1295 : const OUString& rStr,
1296 : bool bHidden,
1297 : sal_uInt16 nSub) :
1298 : SwField( pFldType ), aCond(rCond), nSubType(nSub),
1299 0 : bCanToggle(bConditional), bIsHidden(bHidden), bValid(false)
1300 : {
1301 0 : if(nSubType == TYP_CONDTXTFLD)
1302 : {
1303 0 : sal_Int32 nPos = 0;
1304 0 : aTRUETxt = rStr.getToken(0, '|', nPos);
1305 :
1306 0 : if(nPos != -1)
1307 : {
1308 0 : aFALSETxt = rStr.getToken(0, '|', nPos);
1309 0 : if(nPos != -1)
1310 : {
1311 0 : aContent = rStr.getToken(0, '|', nPos);
1312 0 : bValid = true;
1313 : }
1314 : }
1315 : }
1316 : else
1317 0 : aTRUETxt = rStr;
1318 0 : }
1319 :
1320 0 : SwHiddenTxtField::SwHiddenTxtField( SwHiddenTxtFieldType* pFldType,
1321 : const OUString& rCond,
1322 : const OUString& rTrue,
1323 : const OUString& rFalse,
1324 : sal_uInt16 nSub)
1325 : : SwField( pFldType ), aTRUETxt(rTrue), aFALSETxt(rFalse), aCond(rCond), nSubType(nSub),
1326 0 : bIsHidden(true), bValid(false)
1327 : {
1328 0 : bCanToggle = !aCond.isEmpty();
1329 0 : }
1330 :
1331 0 : OUString SwHiddenTxtField::Expand() const
1332 : {
1333 : // Type: !Hidden -> show always
1334 : // Hide -> evaluate condition
1335 :
1336 0 : if( TYP_CONDTXTFLD == nSubType )
1337 : {
1338 0 : if( bValid )
1339 0 : return aContent;
1340 :
1341 0 : if( bCanToggle && !bIsHidden )
1342 0 : return aTRUETxt;
1343 : }
1344 0 : else if( !((SwHiddenTxtFieldType*)GetTyp())->GetHiddenFlag() ||
1345 0 : ( bCanToggle && bIsHidden ))
1346 0 : return aTRUETxt;
1347 :
1348 0 : return aFALSETxt;
1349 : }
1350 :
1351 : /// get current field value and cache it
1352 0 : void SwHiddenTxtField::Evaluate(SwDoc* pDoc)
1353 : {
1354 : OSL_ENSURE(pDoc, "got no document");
1355 :
1356 0 : if( TYP_CONDTXTFLD == nSubType )
1357 : {
1358 : #if !HAVE_FEATURE_DBCONNECTIVITY
1359 : (void) pDoc;
1360 : #else
1361 0 : SwDBManager* pMgr = pDoc->GetDBManager();
1362 : #endif
1363 0 : bValid = false;
1364 0 : OUString sTmpName = (bCanToggle && !bIsHidden) ? aTRUETxt : aFALSETxt;
1365 :
1366 : // Database expressions need to be different from normal text. Therefore, normal text is set
1367 : // in quotes. If the latter exist they will be removed. If not, check if potential DB name.
1368 : // Only if there are two or more dots and no quotes, we assume a database.
1369 0 : if (sTmpName.getLength()>1 &&
1370 0 : sTmpName.startsWith("\"") &&
1371 0 : sTmpName.endsWith("\""))
1372 : {
1373 0 : aContent = sTmpName.copy(1, sTmpName.getLength() - 2);
1374 0 : bValid = true;
1375 : }
1376 0 : else if(sTmpName.indexOf('\"')<0 &&
1377 0 : comphelper::string::getTokenCount(sTmpName, '.') > 2)
1378 : {
1379 0 : sTmpName = ::ReplacePoint(sTmpName);
1380 0 : if(sTmpName.startsWith("[") && sTmpName.endsWith("]"))
1381 : { // remove brackets
1382 0 : sTmpName = sTmpName.copy(1, sTmpName.getLength() - 2);
1383 : }
1384 : #if HAVE_FEATURE_DBCONNECTIVITY
1385 0 : if( pMgr)
1386 : {
1387 0 : OUString sDBName( GetDBName( sTmpName, pDoc ));
1388 0 : OUString sDataSource(sDBName.getToken(0, DB_DELIM));
1389 0 : OUString sDataTableOrQuery(sDBName.getToken(1, DB_DELIM));
1390 0 : if( pMgr->IsInMerge() && !sDBName.isEmpty() &&
1391 : pMgr->IsDataSourceOpen( sDataSource,
1392 0 : sDataTableOrQuery, false))
1393 : {
1394 : double fNumber;
1395 : sal_uInt32 nTmpFormat;
1396 : pMgr->GetMergeColumnCnt(GetColumnName( sTmpName ),
1397 0 : GetLanguage(), aContent, &fNumber, &nTmpFormat );
1398 0 : bValid = true;
1399 : }
1400 0 : else if( !sDBName.isEmpty() && !sDataSource.isEmpty() &&
1401 0 : !sDataTableOrQuery.isEmpty() )
1402 0 : bValid = true;
1403 : }
1404 : #endif
1405 0 : }
1406 : }
1407 0 : }
1408 :
1409 0 : OUString SwHiddenTxtField::GetFieldName() const
1410 : {
1411 0 : OUString aStr = SwFieldType::GetTypeStr(nSubType) +
1412 0 : " " + aCond + " " + aTRUETxt;
1413 :
1414 0 : if (nSubType == TYP_CONDTXTFLD)
1415 : {
1416 0 : aStr += " : " + aFALSETxt;
1417 : }
1418 0 : return aStr;
1419 : }
1420 :
1421 0 : SwField* SwHiddenTxtField::Copy() const
1422 : {
1423 : SwHiddenTxtField* pFld =
1424 0 : new SwHiddenTxtField((SwHiddenTxtFieldType*)GetTyp(), aCond,
1425 0 : aTRUETxt, aFALSETxt);
1426 0 : pFld->bIsHidden = bIsHidden;
1427 0 : pFld->bValid = bValid;
1428 0 : pFld->aContent = aContent;
1429 0 : pFld->SetFormat(GetFormat());
1430 0 : pFld->nSubType = nSubType;
1431 0 : return pFld;
1432 : }
1433 :
1434 : /// set condition
1435 0 : void SwHiddenTxtField::SetPar1(const OUString& rStr)
1436 : {
1437 0 : aCond = rStr;
1438 0 : bCanToggle = !aCond.isEmpty();
1439 0 : }
1440 :
1441 0 : OUString SwHiddenTxtField::GetPar1() const
1442 : {
1443 0 : return aCond;
1444 : }
1445 :
1446 : /// set True/False text
1447 0 : void SwHiddenTxtField::SetPar2(const OUString& rStr)
1448 : {
1449 0 : if (nSubType == TYP_CONDTXTFLD)
1450 : {
1451 0 : sal_Int32 nPos = rStr.indexOf('|');
1452 0 : if (nPos == -1)
1453 0 : aTRUETxt = rStr;
1454 : else
1455 : {
1456 0 : aTRUETxt = rStr.copy(0, nPos);
1457 0 : aFALSETxt = rStr.copy(nPos + 1);
1458 : }
1459 : }
1460 : else
1461 0 : aTRUETxt = rStr;
1462 0 : }
1463 :
1464 : /// get True/False text
1465 0 : OUString SwHiddenTxtField::GetPar2() const
1466 : {
1467 0 : if(nSubType != TYP_CONDTXTFLD)
1468 : {
1469 0 : return aTRUETxt;
1470 : }
1471 0 : return aTRUETxt + "|" + aFALSETxt;
1472 : }
1473 :
1474 0 : sal_uInt16 SwHiddenTxtField::GetSubType() const
1475 : {
1476 0 : return nSubType;
1477 : }
1478 :
1479 0 : bool SwHiddenTxtField::QueryValue( uno::Any& rAny, sal_uInt16 nWhichId ) const
1480 : {
1481 0 : switch( nWhichId )
1482 : {
1483 : case FIELD_PROP_PAR1:
1484 0 : rAny <<= aCond;
1485 0 : break;
1486 : case FIELD_PROP_PAR2:
1487 0 : rAny <<= aTRUETxt;
1488 0 : break;
1489 : case FIELD_PROP_PAR3:
1490 0 : rAny <<= aFALSETxt;
1491 0 : break;
1492 : case FIELD_PROP_PAR4 :
1493 0 : rAny <<= aContent;
1494 0 : break;
1495 : case FIELD_PROP_BOOL1:
1496 : {
1497 0 : sal_Bool bHidden = bIsHidden;
1498 0 : rAny.setValue(&bHidden, ::getBooleanCppuType());
1499 : }
1500 0 : break;
1501 : default:
1502 : OSL_FAIL("illegal property");
1503 : }
1504 0 : return true;
1505 : }
1506 :
1507 0 : bool SwHiddenTxtField::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId )
1508 : {
1509 0 : switch( nWhichId )
1510 : {
1511 : case FIELD_PROP_PAR1:
1512 : {
1513 0 : OUString sVal;
1514 0 : rAny >>= sVal;
1515 0 : SetPar1(sVal);
1516 : }
1517 0 : break;
1518 : case FIELD_PROP_PAR2:
1519 0 : rAny >>= aTRUETxt;
1520 0 : break;
1521 : case FIELD_PROP_PAR3:
1522 0 : rAny >>= aFALSETxt;
1523 0 : break;
1524 : case FIELD_PROP_BOOL1:
1525 0 : bIsHidden = *(sal_Bool*)rAny.getValue();
1526 0 : break;
1527 : case FIELD_PROP_PAR4:
1528 0 : rAny >>= aContent;
1529 0 : bValid = true;
1530 0 : break;
1531 : default:
1532 : OSL_FAIL("illegal property");
1533 : }
1534 0 : return true;
1535 : }
1536 :
1537 0 : OUString SwHiddenTxtField::GetColumnName(const OUString& rName)
1538 : {
1539 0 : sal_Int32 nPos = rName.indexOf(DB_DELIM);
1540 0 : if( nPos>=0 )
1541 : {
1542 0 : nPos = rName.indexOf(DB_DELIM, nPos + 1);
1543 :
1544 0 : if( nPos>=0 )
1545 0 : return rName.copy(nPos + 1);
1546 : }
1547 0 : return rName;
1548 : }
1549 :
1550 0 : OUString SwHiddenTxtField::GetDBName(const OUString& rName, SwDoc *pDoc)
1551 : {
1552 0 : sal_Int32 nPos = rName.indexOf(DB_DELIM);
1553 0 : if( nPos>=0 )
1554 : {
1555 0 : nPos = rName.indexOf(DB_DELIM, nPos + 1);
1556 :
1557 0 : if( nPos>=0 )
1558 0 : return rName.copy(0, nPos);
1559 : }
1560 :
1561 0 : SwDBData aData = pDoc->GetDBData();
1562 0 : return aData.sDataSource + OUString(DB_DELIM) + aData.sCommand;
1563 : }
1564 :
1565 : // field type for line height 0
1566 :
1567 5052 : SwHiddenParaFieldType::SwHiddenParaFieldType()
1568 5052 : : SwFieldType( RES_HIDDENPARAFLD )
1569 : {
1570 5052 : }
1571 :
1572 0 : SwFieldType* SwHiddenParaFieldType::Copy() const
1573 : {
1574 0 : SwHiddenParaFieldType* pTyp = new SwHiddenParaFieldType();
1575 0 : return pTyp;
1576 : }
1577 :
1578 : // field for line height 0
1579 :
1580 0 : SwHiddenParaField::SwHiddenParaField(SwHiddenParaFieldType* pTyp, const OUString& rStr)
1581 0 : : SwField(pTyp), aCond(rStr)
1582 : {
1583 0 : bIsHidden = false;
1584 0 : }
1585 :
1586 0 : OUString SwHiddenParaField::Expand() const
1587 : {
1588 0 : return OUString();
1589 : }
1590 :
1591 0 : SwField* SwHiddenParaField::Copy() const
1592 : {
1593 0 : SwHiddenParaField* pFld = new SwHiddenParaField((SwHiddenParaFieldType*)GetTyp(), aCond);
1594 0 : pFld->bIsHidden = bIsHidden;
1595 :
1596 0 : return pFld;
1597 : }
1598 :
1599 0 : bool SwHiddenParaField::QueryValue( uno::Any& rAny, sal_uInt16 nWhichId ) const
1600 : {
1601 0 : switch ( nWhichId )
1602 : {
1603 : case FIELD_PROP_PAR1:
1604 0 : rAny <<= aCond;
1605 0 : break;
1606 : case FIELD_PROP_BOOL1:
1607 : {
1608 0 : sal_Bool bHidden = bIsHidden;
1609 0 : rAny.setValue(&bHidden, ::getBooleanCppuType());
1610 : }
1611 0 : break;
1612 :
1613 : default:
1614 : OSL_FAIL("illegal property");
1615 : }
1616 0 : return true;
1617 : }
1618 :
1619 0 : bool SwHiddenParaField::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId )
1620 : {
1621 0 : switch ( nWhichId )
1622 : {
1623 : case FIELD_PROP_PAR1:
1624 0 : rAny >>= aCond;
1625 0 : break;
1626 : case FIELD_PROP_BOOL1:
1627 0 : bIsHidden = *(sal_Bool*)rAny.getValue();
1628 0 : break;
1629 :
1630 : default:
1631 : OSL_FAIL("illegal property");
1632 : }
1633 0 : return true;
1634 : }
1635 :
1636 : /// set condition
1637 0 : void SwHiddenParaField::SetPar1(const OUString& rStr)
1638 : {
1639 0 : aCond = rStr;
1640 0 : }
1641 :
1642 0 : OUString SwHiddenParaField::GetPar1() const
1643 : {
1644 0 : return aCond;
1645 : }
1646 :
1647 : // PostIt field type
1648 :
1649 5052 : SwPostItFieldType::SwPostItFieldType(SwDoc *pDoc)
1650 : : SwFieldType( RES_POSTITFLD )
1651 5052 : , mpDoc(pDoc)
1652 5052 : {}
1653 :
1654 0 : SwFieldType* SwPostItFieldType::Copy() const
1655 : {
1656 0 : return new SwPostItFieldType(mpDoc);
1657 : }
1658 :
1659 : // PostIt field
1660 :
1661 996 : SwPostItField::SwPostItField( SwPostItFieldType* pT,
1662 : const OUString& rAuthor,
1663 : const OUString& rTxt,
1664 : const OUString& rInitials,
1665 : const OUString& rName,
1666 : const DateTime& rDateTime )
1667 : : SwField( pT )
1668 : , sTxt( rTxt )
1669 : , sAuthor( rAuthor )
1670 : , sInitials( rInitials )
1671 : , sName( rName )
1672 : , aDateTime( rDateTime )
1673 : , mpText( NULL )
1674 996 : , m_pTextObject( NULL )
1675 : {
1676 996 : }
1677 :
1678 2930 : SwPostItField::~SwPostItField()
1679 : {
1680 996 : if ( m_pTextObject != NULL )
1681 : {
1682 22 : m_pTextObject->DisposeEditSource();
1683 22 : m_pTextObject->release();
1684 : }
1685 :
1686 996 : delete mpText;
1687 1934 : }
1688 :
1689 252 : OUString SwPostItField::Expand() const
1690 : {
1691 252 : return OUString();
1692 : }
1693 :
1694 4 : OUString SwPostItField::GetDescription() const
1695 : {
1696 4 : return SW_RES(STR_NOTE);
1697 : }
1698 :
1699 838 : SwField* SwPostItField::Copy() const
1700 : {
1701 838 : SwPostItField* pRet = new SwPostItField( (SwPostItFieldType*)GetTyp(), sAuthor, sTxt, sInitials, sName,
1702 838 : aDateTime);
1703 838 : if (mpText)
1704 684 : pRet->SetTextObject( new OutlinerParaObject(*mpText) );
1705 :
1706 : // Note: member <m_pTextObject> not copied.
1707 :
1708 838 : return pRet;
1709 : }
1710 :
1711 : /// set author
1712 0 : void SwPostItField::SetPar1(const OUString& rStr)
1713 : {
1714 0 : sAuthor = rStr;
1715 0 : }
1716 :
1717 : /// get author
1718 424 : OUString SwPostItField::GetPar1() const
1719 : {
1720 424 : return sAuthor;
1721 : }
1722 :
1723 : /// set the PostIt's text
1724 100 : void SwPostItField::SetPar2(const OUString& rStr)
1725 : {
1726 100 : sTxt = rStr;
1727 100 : }
1728 :
1729 : /// get the PostIt's text
1730 130 : OUString SwPostItField::GetPar2() const
1731 : {
1732 130 : return sTxt;
1733 : }
1734 :
1735 :
1736 72 : void SwPostItField::SetName(const OUString& rName)
1737 : {
1738 72 : sName = rName;
1739 72 : }
1740 :
1741 :
1742 :
1743 814 : void SwPostItField::SetTextObject( OutlinerParaObject* pText )
1744 : {
1745 814 : delete mpText;
1746 814 : mpText = pText;
1747 814 : }
1748 :
1749 49 : sal_Int32 SwPostItField::GetNumberOfParagraphs() const
1750 : {
1751 49 : return (mpText) ? mpText->Count() : 1;
1752 : }
1753 :
1754 156 : bool SwPostItField::QueryValue( uno::Any& rAny, sal_uInt16 nWhichId ) const
1755 : {
1756 156 : switch( nWhichId )
1757 : {
1758 : case FIELD_PROP_PAR1:
1759 14 : rAny <<= sAuthor;
1760 14 : break;
1761 : case FIELD_PROP_PAR2:
1762 : {
1763 16 : rAny <<= sTxt;
1764 16 : break;
1765 : }
1766 : case FIELD_PROP_PAR3:
1767 30 : rAny <<= sInitials;
1768 30 : break;
1769 : case FIELD_PROP_PAR4:
1770 46 : rAny <<= sName;
1771 46 : break;
1772 : case FIELD_PROP_TEXT:
1773 : {
1774 36 : if ( !m_pTextObject )
1775 : {
1776 22 : SwPostItFieldType* pGetType = (SwPostItFieldType*)GetTyp();
1777 22 : SwDoc* pDoc = pGetType->GetDoc();
1778 22 : SwTextAPIEditSource* pObj = new SwTextAPIEditSource( pDoc );
1779 22 : const_cast <SwPostItField*> (this)->m_pTextObject = new SwTextAPIObject( pObj );
1780 22 : m_pTextObject->acquire();
1781 : }
1782 :
1783 36 : if ( mpText )
1784 36 : m_pTextObject->SetText( *mpText );
1785 : else
1786 0 : m_pTextObject->SetString( sTxt );
1787 :
1788 36 : uno::Reference < text::XText > xText( m_pTextObject );
1789 36 : rAny <<= xText;
1790 36 : break;
1791 : }
1792 : case FIELD_PROP_DATE:
1793 : {
1794 0 : util::Date aSetDate;
1795 0 : aSetDate.Day = aDateTime.GetDay();
1796 0 : aSetDate.Month = aDateTime.GetMonth();
1797 0 : aSetDate.Year = aDateTime.GetYear();
1798 0 : rAny.setValue(&aSetDate, ::cppu::UnoType<util::Date>::get());
1799 : }
1800 0 : break;
1801 : case FIELD_PROP_DATE_TIME:
1802 : {
1803 14 : util::DateTime DateTimeValue;
1804 14 : DateTimeValue.NanoSeconds = aDateTime.GetNanoSec();
1805 14 : DateTimeValue.Seconds = aDateTime.GetSec();
1806 14 : DateTimeValue.Minutes = aDateTime.GetMin();
1807 14 : DateTimeValue.Hours = aDateTime.GetHour();
1808 14 : DateTimeValue.Day = aDateTime.GetDay();
1809 14 : DateTimeValue.Month = aDateTime.GetMonth();
1810 14 : DateTimeValue.Year = aDateTime.GetYear();
1811 14 : rAny <<= DateTimeValue;
1812 : }
1813 14 : break;
1814 : default:
1815 : OSL_FAIL("illegal property");
1816 : }
1817 156 : return true;
1818 : }
1819 :
1820 0 : bool SwPostItField::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId )
1821 : {
1822 0 : switch( nWhichId )
1823 : {
1824 : case FIELD_PROP_PAR1:
1825 0 : rAny >>= sAuthor;
1826 0 : break;
1827 : case FIELD_PROP_PAR2:
1828 0 : rAny >>= sTxt;
1829 : //#i100374# new string via api, delete complex text object so SwPostItNote picks up the new string
1830 0 : if (mpText)
1831 : {
1832 0 : delete mpText;
1833 0 : mpText = 0;
1834 : }
1835 0 : break;
1836 : case FIELD_PROP_PAR3:
1837 0 : rAny >>= sInitials;
1838 0 : break;
1839 : case FIELD_PROP_PAR4:
1840 0 : rAny >>= sName;
1841 0 : break;
1842 : case FIELD_PROP_TEXT:
1843 : OSL_FAIL("Not implemented!");
1844 0 : break;
1845 : case FIELD_PROP_DATE:
1846 0 : if( rAny.getValueType() == ::cppu::UnoType<util::Date>::get() )
1847 : {
1848 0 : util::Date aSetDate = *(util::Date*)rAny.getValue();
1849 0 : aDateTime = Date(aSetDate.Day, aSetDate.Month, aSetDate.Year);
1850 : }
1851 0 : break;
1852 : case FIELD_PROP_DATE_TIME:
1853 : {
1854 0 : util::DateTime aDateTimeValue;
1855 0 : if(!(rAny >>= aDateTimeValue))
1856 0 : return false;
1857 0 : aDateTime.SetNanoSec(aDateTimeValue.NanoSeconds);
1858 0 : aDateTime.SetSec(aDateTimeValue.Seconds);
1859 0 : aDateTime.SetMin(aDateTimeValue.Minutes);
1860 0 : aDateTime.SetHour(aDateTimeValue.Hours);
1861 0 : aDateTime.SetDay(aDateTimeValue.Day);
1862 0 : aDateTime.SetMonth(aDateTimeValue.Month);
1863 0 : aDateTime.SetYear(aDateTimeValue.Year);
1864 : }
1865 0 : break;
1866 : default:
1867 : OSL_FAIL("illegal property");
1868 : }
1869 0 : return true;
1870 : }
1871 :
1872 : // extended user information field type
1873 :
1874 5052 : SwExtUserFieldType::SwExtUserFieldType()
1875 5052 : : SwFieldType( RES_EXTUSERFLD )
1876 : {
1877 5052 : }
1878 :
1879 0 : SwFieldType* SwExtUserFieldType::Copy() const
1880 : {
1881 0 : SwExtUserFieldType* pTyp = new SwExtUserFieldType;
1882 0 : return pTyp;
1883 : }
1884 :
1885 0 : OUString SwExtUserFieldType::Expand(sal_uInt16 nSub, sal_uInt32 ) const
1886 : {
1887 0 : sal_uInt16 nRet = USHRT_MAX;
1888 0 : switch(nSub)
1889 : {
1890 0 : case EU_FIRSTNAME: nRet = USER_OPT_FIRSTNAME; break;
1891 0 : case EU_NAME: nRet = USER_OPT_LASTNAME; break;
1892 0 : case EU_SHORTCUT: nRet = USER_OPT_ID; break;
1893 :
1894 0 : case EU_COMPANY: nRet = USER_OPT_COMPANY; break;
1895 0 : case EU_STREET: nRet = USER_OPT_STREET; break;
1896 0 : case EU_TITLE: nRet = USER_OPT_TITLE; break;
1897 0 : case EU_POSITION: nRet = USER_OPT_POSITION; break;
1898 0 : case EU_PHONE_PRIVATE: nRet = USER_OPT_TELEPHONEHOME; break;
1899 0 : case EU_PHONE_COMPANY: nRet = USER_OPT_TELEPHONEWORK; break;
1900 0 : case EU_FAX: nRet = USER_OPT_FAX; break;
1901 0 : case EU_EMAIL: nRet = USER_OPT_EMAIL; break;
1902 0 : case EU_COUNTRY: nRet = USER_OPT_COUNTRY; break;
1903 0 : case EU_ZIP: nRet = USER_OPT_ZIP; break;
1904 0 : case EU_CITY: nRet = USER_OPT_CITY; break;
1905 0 : case EU_STATE: nRet = USER_OPT_STATE; break;
1906 0 : case EU_FATHERSNAME: nRet = USER_OPT_FATHERSNAME; break;
1907 0 : case EU_APARTMENT: nRet = USER_OPT_APARTMENT; break;
1908 : default: OSL_ENSURE( false, "Field unknown");
1909 : }
1910 0 : if( USHRT_MAX != nRet )
1911 : {
1912 0 : SvtUserOptions& rUserOpt = SW_MOD()->GetUserOptions();
1913 0 : return rUserOpt.GetToken( nRet );
1914 : }
1915 0 : return OUString();
1916 : }
1917 :
1918 : // extended user information field
1919 :
1920 0 : SwExtUserField::SwExtUserField(SwExtUserFieldType* pTyp, sal_uInt16 nSubTyp, sal_uInt32 nFmt) :
1921 0 : SwField(pTyp, nFmt), nType(nSubTyp)
1922 : {
1923 0 : aContent = ((SwExtUserFieldType*)GetTyp())->Expand(nType, GetFormat());
1924 0 : }
1925 :
1926 0 : OUString SwExtUserField::Expand() const
1927 : {
1928 0 : if (!IsFixed())
1929 0 : ((SwExtUserField*)this)->aContent = ((SwExtUserFieldType*)GetTyp())->Expand(nType, GetFormat());
1930 :
1931 0 : return aContent;
1932 : }
1933 :
1934 0 : SwField* SwExtUserField::Copy() const
1935 : {
1936 0 : SwExtUserField* pFld = new SwExtUserField((SwExtUserFieldType*)GetTyp(), nType, GetFormat());
1937 0 : pFld->SetExpansion(aContent);
1938 :
1939 0 : return pFld;
1940 : }
1941 :
1942 0 : sal_uInt16 SwExtUserField::GetSubType() const
1943 : {
1944 0 : return nType;
1945 : }
1946 :
1947 0 : void SwExtUserField::SetSubType(sal_uInt16 nSub)
1948 : {
1949 0 : nType = nSub;
1950 0 : }
1951 :
1952 0 : bool SwExtUserField::QueryValue( uno::Any& rAny, sal_uInt16 nWhichId ) const
1953 : {
1954 0 : switch( nWhichId )
1955 : {
1956 : case FIELD_PROP_PAR1:
1957 0 : rAny <<= aContent;
1958 0 : break;
1959 :
1960 : case FIELD_PROP_USHORT1:
1961 : {
1962 0 : sal_Int16 nTmp = nType;
1963 0 : rAny <<= nTmp;
1964 : }
1965 0 : break;
1966 : case FIELD_PROP_BOOL1:
1967 : {
1968 0 : sal_Bool bTmp = IsFixed();
1969 0 : rAny.setValue(&bTmp, ::getBooleanCppuType());
1970 : }
1971 0 : break;
1972 : default:
1973 : OSL_FAIL("illegal property");
1974 : }
1975 0 : return true;
1976 : }
1977 :
1978 0 : bool SwExtUserField::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId )
1979 : {
1980 0 : switch( nWhichId )
1981 : {
1982 : case FIELD_PROP_PAR1:
1983 0 : rAny >>= aContent;
1984 0 : break;
1985 :
1986 : case FIELD_PROP_USHORT1:
1987 : {
1988 0 : sal_Int16 nTmp = 0;
1989 0 : rAny >>= nTmp;
1990 0 : nType = nTmp;
1991 : }
1992 0 : break;
1993 : case FIELD_PROP_BOOL1:
1994 0 : if( *(sal_Bool*)rAny.getValue() )
1995 0 : SetFormat(GetFormat() | AF_FIXED);
1996 : else
1997 0 : SetFormat(GetFormat() & ~AF_FIXED);
1998 0 : break;
1999 : default:
2000 : OSL_FAIL("illegal property");
2001 : }
2002 0 : return true;
2003 : }
2004 :
2005 : // field type for relative page numbers
2006 :
2007 5052 : SwRefPageSetFieldType::SwRefPageSetFieldType()
2008 5052 : : SwFieldType( RES_REFPAGESETFLD )
2009 : {
2010 5052 : }
2011 :
2012 0 : SwFieldType* SwRefPageSetFieldType::Copy() const
2013 : {
2014 0 : return new SwRefPageSetFieldType;
2015 : }
2016 :
2017 : // overridden since there is nothing to update
2018 0 : void SwRefPageSetFieldType::Modify( const SfxPoolItem*, const SfxPoolItem * )
2019 : {
2020 0 : }
2021 :
2022 : // field for relative page numbers
2023 :
2024 0 : SwRefPageSetField::SwRefPageSetField( SwRefPageSetFieldType* pTyp,
2025 : short nOff, bool bFlag )
2026 0 : : SwField( pTyp ), nOffset( nOff ), bOn( bFlag )
2027 : {
2028 0 : }
2029 :
2030 0 : OUString SwRefPageSetField::Expand() const
2031 : {
2032 0 : return OUString();
2033 : }
2034 :
2035 0 : SwField* SwRefPageSetField::Copy() const
2036 : {
2037 0 : return new SwRefPageSetField( (SwRefPageSetFieldType*)GetTyp(), nOffset, bOn );
2038 : }
2039 :
2040 0 : OUString SwRefPageSetField::GetPar2() const
2041 : {
2042 0 : return OUString::number(GetOffset());
2043 : }
2044 :
2045 0 : void SwRefPageSetField::SetPar2(const OUString& rStr)
2046 : {
2047 0 : SetOffset( (short) rStr.toInt32() );
2048 0 : }
2049 :
2050 0 : bool SwRefPageSetField::QueryValue( uno::Any& rAny, sal_uInt16 nWhichId ) const
2051 : {
2052 0 : switch( nWhichId )
2053 : {
2054 : case FIELD_PROP_BOOL1:
2055 0 : rAny.setValue(&bOn, ::getBooleanCppuType());
2056 0 : break;
2057 : case FIELD_PROP_USHORT1:
2058 0 : rAny <<= (sal_Int16)nOffset;
2059 0 : break;
2060 : default:
2061 : OSL_FAIL("illegal property");
2062 : }
2063 0 : return true;
2064 : }
2065 :
2066 0 : bool SwRefPageSetField::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId )
2067 : {
2068 0 : switch( nWhichId )
2069 : {
2070 : case FIELD_PROP_BOOL1:
2071 0 : bOn = *(sal_Bool*)rAny.getValue();
2072 0 : break;
2073 : case FIELD_PROP_USHORT1:
2074 0 : rAny >>=nOffset;
2075 0 : break;
2076 : default:
2077 : OSL_FAIL("illegal property");
2078 : }
2079 0 : return true;
2080 : }
2081 :
2082 : // relative page numbers - query field
2083 :
2084 5052 : SwRefPageGetFieldType::SwRefPageGetFieldType( SwDoc* pDc )
2085 5052 : : SwFieldType( RES_REFPAGEGETFLD ), pDoc( pDc ), nNumberingType( SVX_NUM_ARABIC )
2086 : {
2087 5052 : }
2088 :
2089 0 : SwFieldType* SwRefPageGetFieldType::Copy() const
2090 : {
2091 0 : SwRefPageGetFieldType* pNew = new SwRefPageGetFieldType( pDoc );
2092 0 : pNew->nNumberingType = nNumberingType;
2093 0 : return pNew;
2094 : }
2095 :
2096 7110 : void SwRefPageGetFieldType::Modify( const SfxPoolItem* pOld, const SfxPoolItem* pNew )
2097 : {
2098 : // update all GetReference fields
2099 7110 : if( !pNew && !pOld && GetDepends() )
2100 : {
2101 : // first collect all SetPageRefFields
2102 0 : _SetGetExpFlds aTmpLst;
2103 0 : if( MakeSetList( aTmpLst ) )
2104 : {
2105 0 : SwIterator<SwFmtFld,SwFieldType> aIter( *this );
2106 0 : for ( SwFmtFld* pFmtFld = aIter.First(); pFmtFld; pFmtFld = aIter.Next() )
2107 : // update only the GetRef fields
2108 0 : if( pFmtFld->GetTxtFld() )
2109 0 : UpdateField( pFmtFld->GetTxtFld(), aTmpLst );
2110 0 : }
2111 : }
2112 :
2113 : // forward to text fields, they "expand" the text
2114 7110 : NotifyClients( pOld, pNew );
2115 7110 : }
2116 :
2117 0 : sal_uInt16 SwRefPageGetFieldType::MakeSetList( _SetGetExpFlds& rTmpLst )
2118 : {
2119 0 : SwIterator<SwFmtFld,SwFieldType> aIter(*pDoc->getIDocumentFieldsAccess().GetSysFldType( RES_REFPAGESETFLD));
2120 0 : for ( SwFmtFld* pFmtFld = aIter.First(); pFmtFld; pFmtFld = aIter.Next() )
2121 : {
2122 : // update only the GetRef fields
2123 0 : const SwTxtFld* pTFld = pFmtFld->GetTxtFld();
2124 0 : if( pTFld )
2125 : {
2126 0 : const SwTxtNode& rTxtNd = pTFld->GetTxtNode();
2127 :
2128 : // Always the first! (in Tab-Headline, header/footer )
2129 0 : Point aPt;
2130 0 : const SwCntntFrm* pFrm = rTxtNd.getLayoutFrm( rTxtNd.GetDoc()->getIDocumentLayoutAccess().GetCurrentLayout(), &aPt, 0, false );
2131 :
2132 : _SetGetExpFld* pNew;
2133 :
2134 0 : if( !pFrm ||
2135 0 : pFrm->IsInDocBody() ||
2136 : // #i31868#
2137 : // Check if pFrm is not yet connected to the layout.
2138 0 : !pFrm->FindPageFrm() )
2139 : {
2140 : // create index for determination of the TextNode
2141 0 : SwNodeIndex aIdx( rTxtNd );
2142 0 : pNew = new _SetGetExpFld( aIdx, pTFld );
2143 : }
2144 : else
2145 : {
2146 : // create index for determination of the TextNode
2147 0 : SwPosition aPos( pDoc->GetNodes().GetEndOfPostIts() );
2148 0 : bool const bResult = GetBodyTxtNode( *pDoc, aPos, *pFrm );
2149 : OSL_ENSURE(bResult, "where is the Field?");
2150 : (void) bResult; // unused in non-debug
2151 : pNew = new _SetGetExpFld( aPos.nNode, pTFld,
2152 0 : &aPos.nContent );
2153 : }
2154 :
2155 0 : if( !rTmpLst.insert( pNew ).second)
2156 0 : delete pNew;
2157 : }
2158 : }
2159 :
2160 0 : return rTmpLst.size();
2161 : }
2162 :
2163 0 : void SwRefPageGetFieldType::UpdateField( SwTxtFld* pTxtFld,
2164 : _SetGetExpFlds& rSetList )
2165 : {
2166 0 : SwRefPageGetField* pGetFld = (SwRefPageGetField*)pTxtFld->GetFmtFld().GetField();
2167 0 : pGetFld->SetText( OUString() );
2168 :
2169 : // then search the correct RefPageSet field
2170 0 : SwTxtNode* pTxtNode = (SwTxtNode*)&pTxtFld->GetTxtNode();
2171 0 : if( pTxtNode->StartOfSectionIndex() >
2172 0 : pDoc->GetNodes().GetEndOfExtras().GetIndex() )
2173 : {
2174 0 : SwNodeIndex aIdx( *pTxtNode );
2175 0 : _SetGetExpFld aEndFld( aIdx, pTxtFld );
2176 :
2177 0 : _SetGetExpFlds::const_iterator itLast = rSetList.lower_bound( &aEndFld );
2178 :
2179 0 : if( itLast != rSetList.begin() )
2180 : {
2181 0 : --itLast;
2182 0 : const SwTxtFld* pRefTxtFld = (*itLast)->GetTxtFld();
2183 : const SwRefPageSetField* pSetFld =
2184 0 : (SwRefPageSetField*)pRefTxtFld->GetFmtFld().GetField();
2185 0 : if( pSetFld->IsOn() )
2186 : {
2187 : // determine the correct offset
2188 0 : Point aPt;
2189 0 : const SwCntntFrm* pFrm = pTxtNode->getLayoutFrm( pTxtNode->GetDoc()->getIDocumentLayoutAccess().GetCurrentLayout(), &aPt, 0, false );
2190 0 : const SwCntntFrm* pRefFrm = pRefTxtFld->GetTxtNode().getLayoutFrm( pRefTxtFld->GetTxtNode().GetDoc()->getIDocumentLayoutAccess().GetCurrentLayout(), &aPt, 0, false );
2191 0 : const SwPageFrm* pPgFrm = 0;
2192 0 : sal_uInt16 nDiff = ( pFrm && pRefFrm )
2193 0 : ? (pPgFrm = pFrm->FindPageFrm())->GetPhyPageNum() -
2194 0 : pRefFrm->FindPageFrm()->GetPhyPageNum() + 1
2195 0 : : 1;
2196 :
2197 0 : sal_uInt32 nTmpFmt = SVX_NUM_PAGEDESC == pGetFld->GetFormat()
2198 : ? ( !pPgFrm
2199 : ? (sal_uInt32)SVX_NUM_ARABIC
2200 0 : : pPgFrm->GetPageDesc()->GetNumType().GetNumberingType() )
2201 0 : : pGetFld->GetFormat();
2202 0 : short nPageNum = static_cast<short>(std::max(0, pSetFld->GetOffset() + (short)nDiff));
2203 0 : pGetFld->SetText( FormatNumber( nPageNum, nTmpFmt ) );
2204 : }
2205 0 : }
2206 : }
2207 : // start formatting
2208 0 : ((SwFmtFld&)pTxtFld->GetFmtFld()).ModifyNotification( 0, 0 );
2209 0 : }
2210 :
2211 : // queries for relative page numbering
2212 :
2213 0 : SwRefPageGetField::SwRefPageGetField( SwRefPageGetFieldType* pTyp,
2214 : sal_uInt32 nFmt )
2215 0 : : SwField( pTyp, nFmt )
2216 : {
2217 0 : }
2218 :
2219 0 : OUString SwRefPageGetField::Expand() const
2220 : {
2221 0 : return sTxt;
2222 : }
2223 :
2224 0 : SwField* SwRefPageGetField::Copy() const
2225 : {
2226 : SwRefPageGetField* pCpy = new SwRefPageGetField(
2227 0 : (SwRefPageGetFieldType*)GetTyp(), GetFormat() );
2228 0 : pCpy->SetText( sTxt );
2229 0 : return pCpy;
2230 : }
2231 :
2232 0 : void SwRefPageGetField::ChangeExpansion( const SwFrm* pFrm,
2233 : const SwTxtFld* pFld )
2234 : {
2235 : // only fields in Footer, Header, FootNote, Flys
2236 0 : SwRefPageGetFieldType* pGetType = (SwRefPageGetFieldType*)GetTyp();
2237 0 : SwDoc* pDoc = pGetType->GetDoc();
2238 0 : if( pFld->GetTxtNode().StartOfSectionIndex() >
2239 0 : pDoc->GetNodes().GetEndOfExtras().GetIndex() )
2240 0 : return;
2241 :
2242 0 : sTxt = OUString();
2243 :
2244 : OSL_ENSURE( !pFrm->IsInDocBody(), "Flag incorrect, frame is in DocBody" );
2245 :
2246 : // collect all SetPageRefFields
2247 0 : _SetGetExpFlds aTmpLst;
2248 0 : if( !pGetType->MakeSetList( aTmpLst ) )
2249 0 : return ;
2250 :
2251 : // create index for determination of the TextNode
2252 0 : SwPosition aPos( SwNodeIndex( pDoc->GetNodes() ) );
2253 0 : SwTxtNode* pTxtNode = (SwTxtNode*) GetBodyTxtNode( *pDoc, aPos, *pFrm );
2254 :
2255 : // If no layout exists, ChangeExpansion is called for header and
2256 : // footer lines via layout formatting without existing TxtNode.
2257 0 : if(!pTxtNode)
2258 0 : return;
2259 :
2260 0 : _SetGetExpFld aEndFld( aPos.nNode, pFld, &aPos.nContent );
2261 :
2262 0 : _SetGetExpFlds::const_iterator itLast = aTmpLst.lower_bound( &aEndFld );
2263 :
2264 0 : if( itLast == aTmpLst.begin() )
2265 0 : return; // there is no corresponding set-field in front
2266 0 : --itLast;
2267 :
2268 0 : const SwTxtFld* pRefTxtFld = (*itLast)->GetTxtFld();
2269 : const SwRefPageSetField* pSetFld =
2270 0 : (SwRefPageSetField*)pRefTxtFld->GetFmtFld().GetField();
2271 0 : Point aPt;
2272 0 : const SwCntntFrm* pRefFrm = pRefTxtFld->GetTxtNode().getLayoutFrm( pFrm->getRootFrm(), &aPt, 0, false );
2273 0 : if( pSetFld->IsOn() && pRefFrm )
2274 : {
2275 : // determine the correct offset
2276 0 : const SwPageFrm* pPgFrm = pFrm->FindPageFrm();
2277 0 : sal_uInt16 nDiff = pPgFrm->GetPhyPageNum() -
2278 0 : pRefFrm->FindPageFrm()->GetPhyPageNum() + 1;
2279 :
2280 0 : SwRefPageGetField* pGetFld = (SwRefPageGetField*)pFld->GetFmtFld().GetField();
2281 0 : sal_uInt32 nTmpFmt = SVX_NUM_PAGEDESC == pGetFld->GetFormat()
2282 0 : ? pPgFrm->GetPageDesc()->GetNumType().GetNumberingType()
2283 0 : : pGetFld->GetFormat();
2284 0 : short nPageNum = static_cast<short>(std::max(0, pSetFld->GetOffset() + (short)nDiff ));
2285 0 : pGetFld->SetText( FormatNumber( nPageNum, nTmpFmt ) );
2286 0 : }
2287 : }
2288 :
2289 0 : bool SwRefPageGetField::QueryValue( uno::Any& rAny, sal_uInt16 nWhichId ) const
2290 : {
2291 0 : switch( nWhichId )
2292 : {
2293 : case FIELD_PROP_USHORT1:
2294 0 : rAny <<= (sal_Int16)GetFormat();
2295 0 : break;
2296 : case FIELD_PROP_PAR1:
2297 0 : rAny <<= sTxt;
2298 0 : break;
2299 : default:
2300 : OSL_FAIL("illegal property");
2301 : }
2302 0 : return true;
2303 : }
2304 :
2305 0 : bool SwRefPageGetField::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId )
2306 : {
2307 0 : switch( nWhichId )
2308 : {
2309 : case FIELD_PROP_USHORT1:
2310 : {
2311 0 : sal_Int16 nSet = 0;
2312 0 : rAny >>= nSet;
2313 0 : if(nSet <= SVX_NUM_PAGEDESC )
2314 0 : SetFormat(nSet);
2315 : else {
2316 : }
2317 : }
2318 0 : break;
2319 : case FIELD_PROP_PAR1:
2320 0 : rAny >>= sTxt;
2321 0 : break;
2322 : default:
2323 : OSL_FAIL("illegal property");
2324 : }
2325 0 : return true;
2326 : }
2327 :
2328 : // field type to jump to and edit
2329 :
2330 5052 : SwJumpEditFieldType::SwJumpEditFieldType( SwDoc* pD )
2331 5052 : : SwFieldType( RES_JUMPEDITFLD ), pDoc( pD ), aDep( this, 0 )
2332 : {
2333 5052 : }
2334 :
2335 0 : SwFieldType* SwJumpEditFieldType::Copy() const
2336 : {
2337 0 : return new SwJumpEditFieldType( pDoc );
2338 : }
2339 :
2340 2 : SwCharFmt* SwJumpEditFieldType::GetCharFmt()
2341 : {
2342 2 : SwCharFmt* pFmt = pDoc->getIDocumentStylePoolAccess().GetCharFmtFromPool( RES_POOLCHR_JUMPEDIT );
2343 :
2344 : // not registered yet?
2345 2 : if( !aDep.GetRegisteredIn() )
2346 2 : pFmt->Add( &aDep ); // register
2347 :
2348 2 : return pFmt;
2349 : }
2350 :
2351 88 : SwJumpEditField::SwJumpEditField( SwJumpEditFieldType* pTyp, sal_uInt32 nForm,
2352 : const OUString& rTxt, const OUString& rHelp )
2353 88 : : SwField( pTyp, nForm ), sTxt( rTxt ), sHelp( rHelp )
2354 : {
2355 88 : }
2356 :
2357 18 : OUString SwJumpEditField::Expand() const
2358 : {
2359 18 : return "<" + sTxt + ">";
2360 : }
2361 :
2362 72 : SwField* SwJumpEditField::Copy() const
2363 : {
2364 144 : return new SwJumpEditField( (SwJumpEditFieldType*)GetTyp(), GetFormat(),
2365 144 : sTxt, sHelp );
2366 : }
2367 :
2368 : /// get place holder text
2369 2 : OUString SwJumpEditField::GetPar1() const
2370 : {
2371 2 : return sTxt;
2372 : }
2373 :
2374 : /// set place holder text
2375 0 : void SwJumpEditField::SetPar1(const OUString& rStr)
2376 : {
2377 0 : sTxt = rStr;
2378 0 : }
2379 :
2380 : /// get hint text
2381 0 : OUString SwJumpEditField::GetPar2() const
2382 : {
2383 0 : return sHelp;
2384 : }
2385 :
2386 : /// set hint text
2387 0 : void SwJumpEditField::SetPar2(const OUString& rStr)
2388 : {
2389 0 : sHelp = rStr;
2390 0 : }
2391 :
2392 0 : bool SwJumpEditField::QueryValue( uno::Any& rAny, sal_uInt16 nWhichId ) const
2393 : {
2394 0 : switch( nWhichId )
2395 : {
2396 : case FIELD_PROP_USHORT1:
2397 : {
2398 : sal_Int16 nRet;
2399 0 : switch( GetFormat() )
2400 : {
2401 0 : case JE_FMT_TABLE: nRet = text::PlaceholderType::TABLE; break;
2402 0 : case JE_FMT_FRAME: nRet = text::PlaceholderType::TEXTFRAME; break;
2403 0 : case JE_FMT_GRAPHIC:nRet = text::PlaceholderType::GRAPHIC; break;
2404 0 : case JE_FMT_OLE: nRet = text::PlaceholderType::OBJECT; break;
2405 : default:
2406 0 : nRet = text::PlaceholderType::TEXT; break;
2407 : }
2408 0 : rAny <<= nRet;
2409 : }
2410 0 : break;
2411 : case FIELD_PROP_PAR1 :
2412 0 : rAny <<= sHelp;
2413 0 : break;
2414 : case FIELD_PROP_PAR2 :
2415 0 : rAny <<= sTxt;
2416 0 : break;
2417 : default:
2418 : OSL_FAIL("illegal property");
2419 : }
2420 0 : return true;
2421 : }
2422 :
2423 0 : bool SwJumpEditField::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId )
2424 : {
2425 0 : switch( nWhichId )
2426 : {
2427 : case FIELD_PROP_USHORT1:
2428 : {
2429 : //JP 24.10.2001: int32 because in UnoField.cxx a putvalue is
2430 : // called with a int32 value! But normally we need
2431 : // here only a int16
2432 0 : sal_Int32 nSet = 0;
2433 0 : rAny >>= nSet;
2434 0 : switch( nSet )
2435 : {
2436 0 : case text::PlaceholderType::TEXT : SetFormat(JE_FMT_TEXT); break;
2437 0 : case text::PlaceholderType::TABLE : SetFormat(JE_FMT_TABLE); break;
2438 0 : case text::PlaceholderType::TEXTFRAME: SetFormat(JE_FMT_FRAME); break;
2439 0 : case text::PlaceholderType::GRAPHIC : SetFormat(JE_FMT_GRAPHIC); break;
2440 0 : case text::PlaceholderType::OBJECT : SetFormat(JE_FMT_OLE); break;
2441 : }
2442 : }
2443 0 : break;
2444 : case FIELD_PROP_PAR1 :
2445 0 : rAny >>= sHelp;
2446 0 : break;
2447 : case FIELD_PROP_PAR2 :
2448 0 : rAny >>= sTxt;
2449 0 : break;
2450 : default:
2451 : OSL_FAIL("illegal property");
2452 : }
2453 0 : return true;
2454 : }
2455 :
2456 : // combined character field type
2457 :
2458 5052 : SwCombinedCharFieldType::SwCombinedCharFieldType()
2459 5052 : : SwFieldType( RES_COMBINED_CHARS )
2460 : {
2461 5052 : }
2462 :
2463 0 : SwFieldType* SwCombinedCharFieldType::Copy() const
2464 : {
2465 0 : return new SwCombinedCharFieldType;
2466 : }
2467 :
2468 : // combined character field
2469 :
2470 0 : SwCombinedCharField::SwCombinedCharField( SwCombinedCharFieldType* pFTyp,
2471 : const OUString& rChars )
2472 : : SwField( pFTyp, 0 ),
2473 0 : sCharacters( rChars.copy( 0, std::min<sal_Int32>(rChars.getLength(), MAX_COMBINED_CHARACTERS) ))
2474 : {
2475 0 : }
2476 :
2477 0 : OUString SwCombinedCharField::Expand() const
2478 : {
2479 0 : return sCharacters;
2480 : }
2481 :
2482 0 : SwField* SwCombinedCharField::Copy() const
2483 : {
2484 0 : return new SwCombinedCharField( (SwCombinedCharFieldType*)GetTyp(),
2485 0 : sCharacters );
2486 : }
2487 :
2488 0 : OUString SwCombinedCharField::GetPar1() const
2489 : {
2490 0 : return sCharacters;
2491 : }
2492 :
2493 0 : void SwCombinedCharField::SetPar1(const OUString& rStr)
2494 : {
2495 0 : sCharacters = rStr.copy(0, std::min<sal_Int32>(rStr.getLength(), MAX_COMBINED_CHARACTERS));
2496 0 : }
2497 :
2498 0 : bool SwCombinedCharField::QueryValue( uno::Any& rAny,
2499 : sal_uInt16 nWhichId ) const
2500 : {
2501 0 : switch( nWhichId )
2502 : {
2503 : case FIELD_PROP_PAR1:
2504 0 : rAny <<= sCharacters;
2505 0 : break;
2506 : default:
2507 : OSL_FAIL("illegal property");
2508 : }
2509 0 : return true;
2510 : }
2511 :
2512 0 : bool SwCombinedCharField::PutValue( const uno::Any& rAny,
2513 : sal_uInt16 nWhichId )
2514 : {
2515 0 : switch( nWhichId )
2516 : {
2517 : case FIELD_PROP_PAR1:
2518 : {
2519 0 : OUString sTmp;
2520 0 : rAny >>= sTmp;
2521 0 : SetPar1(sTmp);
2522 : }
2523 0 : break;
2524 : default:
2525 : OSL_FAIL("illegal property");
2526 : }
2527 0 : return true;
2528 270 : }
2529 :
2530 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
