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