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