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