Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <comphelper/string.hxx>
21 : #include <vcl/metaact.hxx>
22 : #include <svl/zforlist.hxx>
23 : #include <tools/urlobj.hxx>
24 :
25 : #include <unotools/localfilehelper.hxx>
26 :
27 : #include <editeng/flditem.hxx>
28 : #include <editeng/measfld.hxx>
29 : #include "editeng/unonames.hxx"
30 :
31 : #include <tools/tenccvt.hxx>
32 :
33 : #include <com/sun/star/beans/XPropertySet.hpp>
34 : #include <com/sun/star/text/XTextContent.hpp>
35 : #include <com/sun/star/text/FilenameDisplayFormat.hpp>
36 : #include <com/sun/star/util/DateTime.hpp>
37 :
38 : using namespace com::sun::star;
39 :
40 520 : SvxFieldData* SvxFieldData::Create(const uno::Reference<text::XTextContent>& xTextContent)
41 : {
42 520 : uno::Reference<beans::XPropertySet> xPropSet(xTextContent, uno::UNO_QUERY);
43 520 : if (!xPropSet.is())
44 6 : return NULL;
45 :
46 : // we do not support these fields from Writer, so make sure we do not throw
47 : // here - see fdo#63436 how to possibly extend Writer to make use of this
48 1028 : uno::Any aAny;
49 : try {
50 514 : aAny = xPropSet->getPropertyValue(UNO_TC_PROP_TEXTFIELD_TYPE);
51 514 : if ( !aAny.has<sal_Int32>() )
52 4 : return NULL;
53 :
54 510 : sal_Int32 nFieldType = aAny.get<sal_Int32>();
55 :
56 510 : switch (nFieldType)
57 : {
58 : case text::textfield::Type::TIME:
59 : case text::textfield::Type::EXTENDED_TIME:
60 : case text::textfield::Type::DATE:
61 : {
62 64 : bool bIsDate = false;
63 64 : xPropSet->getPropertyValue(UNO_TC_PROP_IS_DATE) >>= bIsDate;
64 :
65 64 : if (bIsDate)
66 : {
67 64 : util::DateTime aDateTime = xPropSet->getPropertyValue(UNO_TC_PROP_DATE_TIME).get<util::DateTime>();
68 64 : Date aDate(aDateTime.Day, aDateTime.Month, aDateTime.Year);
69 64 : bool bIsFixed = false;
70 64 : xPropSet->getPropertyValue(UNO_TC_PROP_IS_FIXED) >>= bIsFixed;
71 :
72 64 : SvxDateField* pData = new SvxDateField(aDate, bIsFixed ? SVXDATETYPE_FIX : SVXDATETYPE_VAR);
73 64 : sal_Int32 nNumFmt = -1;
74 64 : xPropSet->getPropertyValue(UNO_TC_PROP_NUMFORMAT) >>= nNumFmt;
75 64 : if (nNumFmt >= SVXDATEFORMAT_APPDEFAULT && nNumFmt <= SVXDATEFORMAT_F)
76 64 : pData->SetFormat(static_cast<SvxDateFormat>(nNumFmt));
77 :
78 64 : return pData;
79 : }
80 :
81 0 : if (nFieldType != text::textfield::Type::TIME)
82 : {
83 0 : util::DateTime aDateTime = xPropSet->getPropertyValue(UNO_TC_PROP_DATE_TIME).get<util::DateTime>();
84 0 : tools::Time aTime(aDateTime.Hours, aDateTime.Minutes, aDateTime.Seconds, aDateTime.NanoSeconds);
85 :
86 0 : bool bIsFixed = false;
87 0 : xPropSet->getPropertyValue(UNO_TC_PROP_IS_FIXED) >>= bIsFixed;
88 :
89 0 : SvxExtTimeField* pData = new SvxExtTimeField(aTime, bIsFixed ? SVXTIMETYPE_FIX : SVXTIMETYPE_VAR);
90 :
91 0 : sal_Int32 nNumFmt = -1;
92 0 : xPropSet->getPropertyValue(UNO_TC_PROP_NUMFORMAT) >>= nNumFmt;
93 0 : if (nNumFmt >= SVXTIMEFORMAT_APPDEFAULT && nNumFmt <= SVXTIMEFORMAT_AM_HMSH)
94 0 : pData->SetFormat(static_cast<SvxTimeFormat>(nNumFmt));
95 :
96 0 : return pData;
97 : }
98 :
99 0 : return new SvxTimeField();
100 : }
101 : case text::textfield::Type::URL:
102 : {
103 4 : OUString aRep, aTarget, aURL;
104 2 : sal_Int16 nFmt = -1;
105 2 : xPropSet->getPropertyValue(UNO_TC_PROP_URL_REPRESENTATION) >>= aRep;
106 2 : xPropSet->getPropertyValue(UNO_TC_PROP_URL_TARGET) >>= aTarget;
107 2 : xPropSet->getPropertyValue(UNO_TC_PROP_URL) >>= aURL;
108 2 : xPropSet->getPropertyValue(UNO_TC_PROP_URL_FORMAT) >>= nFmt;
109 2 : SvxURLField* pData = new SvxURLField(aURL, aRep, aRep.isEmpty() ? SVXURLFORMAT_URL : SVXURLFORMAT_REPR);
110 2 : pData->SetTargetFrame(aTarget);
111 2 : if (nFmt >= SVXURLFORMAT_APPDEFAULT && nFmt <= SVXURLFORMAT_REPR)
112 2 : pData->SetFormat(static_cast<SvxURLFormat>(nFmt));
113 :
114 4 : return pData;
115 : }
116 : case text::textfield::Type::PAGE:
117 178 : return new SvxPageField();
118 : case text::textfield::Type::PAGES:
119 0 : return new SvxPagesField();
120 : case text::textfield::Type::PAGE_TITLE:
121 0 : return new SvxPageTitleField();
122 : case text::textfield::Type::DOCINFO_TITLE:
123 0 : return new SvxFileField();
124 : case text::textfield::Type::TABLE:
125 : {
126 0 : sal_Int32 nTab = 0;
127 0 : xPropSet->getPropertyValue(UNO_TC_PROP_TABLE_POSITION) >>= nTab;
128 0 : return new SvxTableField(nTab);
129 : }
130 : case text::textfield::Type::EXTENDED_FILE:
131 : {
132 0 : OUString aPresentation;
133 0 : bool bIsFixed = false;
134 0 : sal_Int16 nFmt = text::FilenameDisplayFormat::FULL;
135 0 : xPropSet->getPropertyValue(UNO_TC_PROP_IS_FIXED) >>= bIsFixed;
136 0 : xPropSet->getPropertyValue(UNO_TC_PROP_CURRENT_PRESENTATION) >>= aPresentation;
137 0 : xPropSet->getPropertyValue(UNO_TC_PROP_FILE_FORMAT) >>= nFmt;
138 :
139 0 : SvxFileFormat eFmt = SVXFILEFORMAT_NAME_EXT;
140 0 : switch (nFmt)
141 : {
142 0 : case text::FilenameDisplayFormat::FULL: eFmt = SVXFILEFORMAT_FULLPATH; break;
143 0 : case text::FilenameDisplayFormat::PATH: eFmt = SVXFILEFORMAT_PATH; break;
144 0 : case text::FilenameDisplayFormat::NAME: eFmt = SVXFILEFORMAT_NAME; break;
145 : default:;
146 : }
147 :
148 : // pass fixed attribute to constructor
149 : return new SvxExtFileField(
150 0 : aPresentation, bIsFixed ? SVXFILETYPE_FIX : SVXFILETYPE_VAR, eFmt);
151 : }
152 : case text::textfield::Type::AUTHOR:
153 : {
154 0 : bool bIsFixed = false;
155 0 : bool bFullName = false;
156 0 : sal_Int16 nFmt = -1;
157 0 : OUString aPresentation, aContent, aFirstName, aLastName;
158 0 : xPropSet->getPropertyValue(UNO_TC_PROP_IS_FIXED) >>= bIsFixed;
159 0 : xPropSet->getPropertyValue(UNO_TC_PROP_AUTHOR_FULLNAME) >>= bFullName;
160 0 : xPropSet->getPropertyValue(UNO_TC_PROP_CURRENT_PRESENTATION) >>= aPresentation;
161 0 : xPropSet->getPropertyValue(UNO_TC_PROP_AUTHOR_CONTENT) >>= aContent;
162 0 : xPropSet->getPropertyValue(UNO_TC_PROP_AUTHOR_FORMAT) >>= nFmt;
163 :
164 : // do we have CurrentPresentation given? Mimic behaviour of
165 : // writer, which means: prefer CurrentPresentation over Content
166 : // if both are given.
167 0 : if (!aPresentation.isEmpty())
168 0 : aContent = aPresentation;
169 :
170 0 : sal_Int32 nPos = aContent.lastIndexOf(' ', 0);
171 0 : if (nPos > 0)
172 : {
173 0 : aFirstName = aContent.copy(0, nPos);
174 0 : aLastName = aContent.copy(nPos + 1);
175 : }
176 : else
177 : {
178 0 : aLastName = aContent;
179 : }
180 :
181 : // #92009# pass fixed attribute to constructor
182 : SvxAuthorField* pData = new SvxAuthorField(
183 0 : aFirstName, aLastName, OUString(), bIsFixed ? SVXAUTHORTYPE_FIX : SVXAUTHORTYPE_VAR);
184 :
185 0 : if (!bFullName)
186 : {
187 0 : pData->SetFormat(SVXAUTHORFORMAT_SHORTNAME);
188 : }
189 0 : else if (nFmt >= SVXAUTHORFORMAT_FULLNAME || nFmt <= SVXAUTHORFORMAT_SHORTNAME)
190 : {
191 0 : pData->SetFormat(static_cast<SvxAuthorFormat>(nFmt));
192 : }
193 :
194 0 : return pData;
195 : }
196 : case text::textfield::Type::MEASURE:
197 : {
198 8 : SdrMeasureFieldKind eKind = SDRMEASUREFIELD_VALUE;
199 8 : sal_Int16 nTmp = -1;
200 8 : xPropSet->getPropertyValue(UNO_TC_PROP_MEASURE_KIND) >>= nTmp;
201 14 : if (nTmp == static_cast<sal_Int16>(SDRMEASUREFIELD_UNIT) ||
202 6 : nTmp == static_cast<sal_Int16>(SDRMEASUREFIELD_ROTA90BLANCS))
203 6 : eKind = static_cast<SdrMeasureFieldKind>(nTmp);
204 :
205 8 : return new SdrMeasureField(eKind);
206 : }
207 : case text::textfield::Type::PRESENTATION_HEADER:
208 66 : return new SvxHeaderField();
209 : case text::textfield::Type::PRESENTATION_FOOTER:
210 96 : return new SvxFooterField();
211 : case text::textfield::Type::PRESENTATION_DATE_TIME:
212 96 : return new SvxDateTimeField();
213 : default:
214 : ;
215 : };
216 0 : } catch ( const beans::UnknownPropertyException& )
217 : {
218 0 : return NULL;
219 : }
220 :
221 520 : return NULL;
222 : }
223 :
224 268349 : TYPEINIT1( SvxFieldItem, SfxPoolItem );
225 :
226 2288 : SV_IMPL_PERSIST1( SvxFieldData, SvPersistBase );
227 :
228 :
229 :
230 141793 : SvxFieldData::SvxFieldData()
231 : {
232 141793 : }
233 :
234 :
235 :
236 156969 : SvxFieldData::~SvxFieldData()
237 : {
238 156969 : }
239 :
240 :
241 :
242 180 : SvxFieldData* SvxFieldData::Clone() const
243 : {
244 180 : return new SvxFieldData;
245 : }
246 :
247 :
248 :
249 0 : bool SvxFieldData::operator==( const SvxFieldData& rFld ) const
250 : {
251 : DBG_ASSERT( Type() == rFld.Type(), "==: Different Types" );
252 : (void)rFld;
253 0 : return true; // Basic class is always the same.
254 : }
255 :
256 :
257 :
258 0 : void SvxFieldData::Load( SvPersistStream & /*rStm*/ )
259 : {
260 0 : }
261 :
262 :
263 :
264 0 : void SvxFieldData::Save( SvPersistStream & /*rStm*/ )
265 : {
266 0 : }
267 :
268 :
269 0 : MetaAction* SvxFieldData::createBeginComment() const
270 : {
271 0 : return new MetaCommentAction( "FIELD_SEQ_BEGIN" );
272 : }
273 :
274 0 : MetaAction* SvxFieldData::createEndComment() const
275 : {
276 0 : return new MetaCommentAction( "FIELD_SEQ_END" );
277 : }
278 :
279 :
280 :
281 0 : SvxFieldItem::SvxFieldItem( SvxFieldData* pFld, const sal_uInt16 nId ) :
282 0 : SfxPoolItem( nId )
283 : {
284 0 : pField = pFld; // belongs directly to the item
285 0 : }
286 :
287 :
288 :
289 14448 : SvxFieldItem::SvxFieldItem( const SvxFieldData& rField, const sal_uInt16 nId ) :
290 14448 : SfxPoolItem( nId )
291 : {
292 14448 : pField = rField.Clone();
293 14448 : }
294 :
295 :
296 :
297 128787 : SvxFieldItem::SvxFieldItem( const SvxFieldItem& rItem ) :
298 128787 : SfxPoolItem ( rItem )
299 : {
300 128787 : pField = rItem.GetField() ? rItem.GetField()->Clone() : 0;
301 128787 : }
302 :
303 :
304 :
305 415465 : SvxFieldItem::~SvxFieldItem()
306 : {
307 143211 : delete pField;
308 272254 : }
309 :
310 :
311 :
312 128451 : SfxPoolItem* SvxFieldItem::Clone( SfxItemPool* ) const
313 : {
314 128451 : return new SvxFieldItem(*this);
315 : }
316 :
317 :
318 :
319 0 : SfxPoolItem* SvxFieldItem::Create( SvStream& rStrm, sal_uInt16 ) const
320 : {
321 0 : SvxFieldData* pData = 0;
322 0 : SvPersistStream aPStrm( GetClassManager(), &rStrm );
323 0 : aPStrm >> pData;
324 :
325 0 : if( aPStrm.IsEof() )
326 0 : aPStrm.SetError( SVSTREAM_GENERALERROR );
327 :
328 0 : if ( aPStrm.GetError() == ERRCODE_IO_NOFACTORY )
329 0 : aPStrm.ResetError(); // Actually a code for that not all were read Attr ...
330 :
331 0 : return new SvxFieldItem( pData, Which() );
332 : }
333 :
334 :
335 :
336 0 : SvStream& SvxFieldItem::Store( SvStream& rStrm, sal_uInt16 /*nItemVersion*/ ) const
337 : {
338 : DBG_ASSERT( pField, "SvxFieldItem::Store: Field?!" );
339 0 : SvPersistStream aPStrm( GetClassManager(), &rStrm );
340 : // The reset error in the above Create method did not exist in 3.1,
341 : // therefore newer items can not be saved for 3.x-exports!
342 0 : if ( ( rStrm.GetVersion() <= SOFFICE_FILEFORMAT_31 ) && pField &&
343 0 : pField->GetClassId() == 50 /* SdrMeasureField */ )
344 : {
345 : // SvxFieldData not enough, because not registered on ClassMgr.
346 0 : SvxURLField aDummyData;
347 0 : WriteSvPersistBase( aPStrm , &aDummyData );
348 : }
349 : else
350 0 : WriteSvPersistBase( aPStrm, pField );
351 :
352 0 : return rStrm;
353 : }
354 :
355 :
356 :
357 1968 : bool SvxFieldItem::operator==( const SfxPoolItem& rItem ) const
358 : {
359 : DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal which or type" );
360 :
361 1968 : const SvxFieldData* pOtherFld = static_cast<const SvxFieldItem&>(rItem).GetField();
362 1968 : if ( !pField && !pOtherFld )
363 0 : return true;
364 :
365 1968 : if ( ( !pField && pOtherFld ) || ( pField && !pOtherFld ) )
366 0 : return false;
367 :
368 1968 : return ( ( pField->Type() == pOtherFld->Type() )
369 1968 : && ( *pField == *pOtherFld ) );
370 : }
371 :
372 :
373 : // The following are the derivatives of SvxFieldData ...
374 :
375 :
376 1070 : SV_IMPL_PERSIST1( SvxDateField, SvxFieldData );
377 :
378 :
379 :
380 284 : SvxDateField::SvxDateField()
381 : {
382 284 : nFixDate = Date( Date::SYSTEM ).GetDate();
383 284 : eType = SVXDATETYPE_VAR;
384 284 : eFormat = SVXDATEFORMAT_STDSMALL;
385 284 : }
386 :
387 :
388 :
389 1018 : SvxDateField::SvxDateField( const Date& rDate, SvxDateType eT, SvxDateFormat eF )
390 : {
391 1018 : nFixDate = rDate.GetDate();
392 1018 : eType = eT;
393 1018 : eFormat = eF;
394 1018 : }
395 :
396 :
397 :
398 10934 : SvxFieldData* SvxDateField::Clone() const
399 : {
400 10934 : return new SvxDateField( *this );
401 : }
402 :
403 :
404 :
405 0 : bool SvxDateField::operator==( const SvxFieldData& rOther ) const
406 : {
407 0 : if ( rOther.Type() != Type() )
408 0 : return false;
409 :
410 0 : const SvxDateField& rOtherFld = static_cast<const SvxDateField&>(rOther);
411 0 : return ( ( nFixDate == rOtherFld.nFixDate ) &&
412 0 : ( eType == rOtherFld.eType ) &&
413 0 : ( eFormat == rOtherFld.eFormat ) );
414 : }
415 :
416 :
417 :
418 0 : void SvxDateField::Load( SvPersistStream & rStm )
419 : {
420 : sal_uInt16 nType, nFormat;
421 :
422 0 : rStm.ReadUInt32( nFixDate );
423 0 : rStm.ReadUInt16( nType );
424 0 : rStm.ReadUInt16( nFormat );
425 :
426 0 : eType = (SvxDateType)nType;
427 0 : eFormat= (SvxDateFormat)nFormat;
428 0 : }
429 :
430 :
431 :
432 0 : void SvxDateField::Save( SvPersistStream & rStm )
433 : {
434 0 : rStm.WriteUInt32( nFixDate );
435 0 : rStm.WriteUInt16( eType );
436 0 : rStm.WriteUInt16( eFormat );
437 0 : }
438 :
439 :
440 :
441 60 : OUString SvxDateField::GetFormatted( SvNumberFormatter& rFormatter, LanguageType eLang ) const
442 : {
443 60 : Date aDate( Date::EMPTY );
444 60 : if ( eType == SVXDATETYPE_FIX )
445 0 : aDate.SetDate( nFixDate );
446 : else
447 60 : aDate = Date( Date::SYSTEM ); // current date
448 :
449 60 : return GetFormatted( aDate, eFormat, rFormatter, eLang );
450 : }
451 :
452 60 : OUString SvxDateField::GetFormatted( Date& aDate, SvxDateFormat eFormat, SvNumberFormatter& rFormatter, LanguageType eLang )
453 : {
454 60 : if ( eFormat == SVXDATEFORMAT_SYSTEM )
455 : {
456 : OSL_FAIL( "SVXDATEFORMAT_SYSTEM not implemented!" );
457 0 : eFormat = SVXDATEFORMAT_STDSMALL;
458 : }
459 60 : else if ( eFormat == SVXDATEFORMAT_APPDEFAULT )
460 : {
461 : OSL_FAIL( "SVXDATEFORMAT_APPDEFAULT: take them from where? ");
462 0 : eFormat = SVXDATEFORMAT_STDSMALL;
463 : }
464 :
465 : sal_uLong nFormatKey;
466 :
467 60 : switch( eFormat )
468 : {
469 : case SVXDATEFORMAT_STDSMALL:
470 : // short
471 60 : nFormatKey = rFormatter.GetFormatIndex( NF_DATE_SYSTEM_SHORT, eLang );
472 60 : break;
473 : case SVXDATEFORMAT_STDBIG:
474 : // long
475 0 : nFormatKey = rFormatter.GetFormatIndex( NF_DATE_SYSTEM_LONG, eLang );
476 0 : break;
477 : case SVXDATEFORMAT_A:
478 : // 13.02.96
479 0 : nFormatKey = rFormatter.GetFormatIndex( NF_DATE_SYS_DDMMYY, eLang );
480 0 : break;
481 : case SVXDATEFORMAT_B:
482 : // 13.02.1996
483 0 : nFormatKey = rFormatter.GetFormatIndex( NF_DATE_SYS_DDMMYYYY, eLang );
484 0 : break;
485 : case SVXDATEFORMAT_C:
486 : // 13. Feb 1996
487 0 : nFormatKey = rFormatter.GetFormatIndex( NF_DATE_SYS_DMMMYYYY, eLang );
488 0 : break;
489 : case SVXDATEFORMAT_D:
490 : // 13. February 1996
491 0 : nFormatKey = rFormatter.GetFormatIndex( NF_DATE_SYS_DMMMMYYYY, eLang );
492 0 : break;
493 : case SVXDATEFORMAT_E:
494 : // The, 13. February 1996
495 0 : nFormatKey = rFormatter.GetFormatIndex( NF_DATE_SYS_NNDMMMMYYYY, eLang );
496 0 : break;
497 : case SVXDATEFORMAT_F:
498 : // Tuesday, 13. February 1996
499 0 : nFormatKey = rFormatter.GetFormatIndex( NF_DATE_SYS_NNNNDMMMMYYYY, eLang );
500 0 : break;
501 : default:
502 0 : nFormatKey = rFormatter.GetStandardFormat( NUMBERFORMAT_DATE, eLang );
503 : }
504 :
505 60 : double fDiffDate = aDate - *(rFormatter.GetNullDate());
506 60 : OUString aStr;
507 60 : Color* pColor = NULL;
508 60 : rFormatter.GetOutputString( fDiffDate, nFormatKey, aStr, &pColor );
509 60 : return aStr;
510 : }
511 :
512 0 : MetaAction* SvxDateField::createBeginComment() const
513 : {
514 0 : return new MetaCommentAction( "FIELD_SEQ_BEGIN" );
515 : }
516 :
517 198 : SV_IMPL_PERSIST1( SvxURLField, SvxFieldData );
518 :
519 :
520 :
521 0 : SvxURLField::SvxURLField()
522 : {
523 0 : eFormat = SVXURLFORMAT_URL;
524 0 : }
525 :
526 :
527 :
528 46 : SvxURLField::SvxURLField( const OUString& rURL, const OUString& rRepres, SvxURLFormat eFmt )
529 46 : : aURL( rURL ), aRepresentation( rRepres )
530 : {
531 46 : eFormat = eFmt;
532 46 : }
533 :
534 :
535 :
536 770 : SvxFieldData* SvxURLField::Clone() const
537 : {
538 770 : return new SvxURLField( *this );
539 : }
540 :
541 :
542 :
543 0 : bool SvxURLField::operator==( const SvxFieldData& rOther ) const
544 : {
545 0 : if ( rOther.Type() != Type() )
546 0 : return false;
547 :
548 0 : const SvxURLField& rOtherFld = static_cast<const SvxURLField&>(rOther);
549 0 : return ( ( eFormat == rOtherFld.eFormat ) &&
550 0 : ( aURL == rOtherFld.aURL ) &&
551 0 : ( aRepresentation == rOtherFld.aRepresentation ) &&
552 0 : ( aTargetFrame == rOtherFld.aTargetFrame ) );
553 : }
554 :
555 :
556 :
557 0 : static void write_unicode( SvPersistStream & rStm, const OUString& rString )
558 : {
559 0 : sal_uInt16 nL = sal::static_int_cast<sal_uInt16>(rString.getLength());
560 0 : rStm.WriteUInt16( nL );
561 : //endian specific?, yipes!
562 0 : rStm.Write( rString.getStr(), nL*sizeof(sal_Unicode) );
563 0 : }
564 :
565 0 : static OUString read_unicode( SvPersistStream & rStm )
566 : {
567 0 : rtl_uString *pStr = NULL;
568 0 : sal_uInt16 nL = 0;
569 0 : rStm.ReadUInt16( nL );
570 0 : if ( nL )
571 : {
572 0 : pStr = rtl_uString_alloc(nL);
573 : //endian specific?, yipes!
574 0 : rStm.Read(pStr->buffer, nL*sizeof(sal_Unicode));
575 : }
576 : //take ownership of buffer and return, otherwise return empty string
577 0 : return pStr ? OUString(pStr, SAL_NO_ACQUIRE) : OUString();
578 : }
579 :
580 0 : void SvxURLField::Load( SvPersistStream & rStm )
581 : {
582 0 : sal_uInt16 nFormat = 0;
583 :
584 0 : rStm.ReadUInt16( nFormat );
585 0 : eFormat= (SvxURLFormat)nFormat;
586 :
587 0 : aURL = read_unicode( rStm );
588 0 : aRepresentation = read_unicode( rStm );
589 0 : aTargetFrame = read_unicode( rStm );
590 0 : }
591 :
592 :
593 :
594 0 : void SvxURLField::Save( SvPersistStream & rStm )
595 : {
596 0 : rStm.WriteUInt16( eFormat );
597 :
598 0 : write_unicode( rStm, aURL );
599 0 : write_unicode( rStm, aRepresentation );
600 0 : write_unicode( rStm, aTargetFrame );
601 0 : }
602 :
603 0 : MetaAction* SvxURLField::createBeginComment() const
604 : {
605 : // #i46618# Adding target URL to metafile comment
606 : return new MetaCommentAction( "FIELD_SEQ_BEGIN",
607 : 0,
608 0 : reinterpret_cast<const sal_uInt8*>(aURL.getStr()),
609 0 : 2*aURL.getLength() );
610 : }
611 :
612 : //
613 : // SvxPageTitleField methods
614 : //
615 :
616 0 : SV_IMPL_PERSIST1( SvxPageTitleField, SvxFieldData );
617 :
618 0 : SvxPageTitleField::SvxPageTitleField() {}
619 :
620 0 : SvxFieldData* SvxPageTitleField::Clone() const
621 : {
622 0 : return new SvxPageTitleField();
623 : }
624 :
625 0 : bool SvxPageTitleField::operator==( const SvxFieldData& rCmp ) const
626 : {
627 0 : return ( rCmp.Type() == TYPE(SvxPageTitleField) );
628 : }
629 :
630 0 : void SvxPageTitleField::Load( SvPersistStream & /*rStm*/ )
631 : {
632 0 : }
633 :
634 0 : void SvxPageTitleField::Save( SvPersistStream & /*rStm*/ )
635 : {
636 0 : }
637 :
638 0 : MetaAction* SvxPageTitleField::createBeginComment() const
639 : {
640 0 : return new MetaCommentAction( "FIELD_SEQ_BEGIN;PageTitleField" );
641 : }
642 :
643 : //
644 : // SvxPagesField
645 : //
646 : // The fields that were removed from Calc:
647 :
648 :
649 7778 : SV_IMPL_PERSIST1( SvxPageField, SvxFieldData );
650 :
651 42271 : SvxPageField::SvxPageField() {}
652 :
653 38787 : SvxFieldData* SvxPageField::Clone() const
654 : {
655 38787 : return new SvxPageField; // empty
656 : }
657 :
658 0 : bool SvxPageField::operator==( const SvxFieldData& rCmp ) const
659 : {
660 0 : return ( rCmp.Type() == TYPE(SvxPageField) );
661 : }
662 :
663 0 : void SvxPageField::Load( SvPersistStream & /*rStm*/ )
664 : {
665 0 : }
666 :
667 0 : void SvxPageField::Save( SvPersistStream & /*rStm*/ )
668 : {
669 0 : }
670 :
671 0 : MetaAction* SvxPageField::createBeginComment() const
672 : {
673 0 : return new MetaCommentAction( "FIELD_SEQ_BEGIN;PageField" );
674 : }
675 :
676 :
677 636 : SV_IMPL_PERSIST1( SvxPagesField, SvxFieldData );
678 :
679 10084 : SvxPagesField::SvxPagesField() {}
680 :
681 8866 : SvxFieldData* SvxPagesField::Clone() const
682 : {
683 8866 : return new SvxPagesField; // empty
684 : }
685 :
686 0 : bool SvxPagesField::operator==( const SvxFieldData& rCmp ) const
687 : {
688 0 : return ( rCmp.Type() == TYPE(SvxPagesField) );
689 : }
690 :
691 0 : void SvxPagesField::Load( SvPersistStream & /*rStm*/ )
692 : {
693 0 : }
694 :
695 0 : void SvxPagesField::Save( SvPersistStream & /*rStm*/ )
696 : {
697 0 : }
698 :
699 174 : SV_IMPL_PERSIST1( SvxTimeField, SvxFieldData );
700 :
701 7136 : SvxTimeField::SvxTimeField() {}
702 :
703 6178 : SvxFieldData* SvxTimeField::Clone() const
704 : {
705 6178 : return new SvxTimeField; // empty
706 : }
707 :
708 0 : bool SvxTimeField::operator==( const SvxFieldData& rCmp ) const
709 : {
710 0 : return ( rCmp.Type() == TYPE(SvxTimeField) );
711 : }
712 :
713 0 : void SvxTimeField::Load( SvPersistStream & /*rStm*/ )
714 : {
715 0 : }
716 :
717 0 : void SvxTimeField::Save( SvPersistStream & /*rStm*/ )
718 : {
719 0 : }
720 :
721 0 : MetaAction* SvxTimeField::createBeginComment() const
722 : {
723 0 : return new MetaCommentAction( "FIELD_SEQ_BEGIN" );
724 : }
725 :
726 612 : SV_IMPL_PERSIST1( SvxFileField, SvxFieldData );
727 :
728 10372 : SvxFileField::SvxFileField() {}
729 :
730 9150 : SvxFieldData* SvxFileField::Clone() const
731 : {
732 9150 : return new SvxFileField; // empty
733 : }
734 :
735 0 : bool SvxFileField::operator==( const SvxFieldData& rCmp ) const
736 : {
737 0 : return ( rCmp.Type() == TYPE(SvxFileField) );
738 : }
739 :
740 0 : void SvxFileField::Load( SvPersistStream & /*rStm*/ )
741 : {
742 0 : }
743 :
744 0 : void SvxFileField::Save( SvPersistStream & /*rStm*/ )
745 : {
746 0 : }
747 :
748 2408 : SV_IMPL_PERSIST1( SvxTableField, SvxFieldData );
749 :
750 2576 : SvxTableField::SvxTableField() : mnTab(0) {}
751 :
752 21342 : SvxTableField::SvxTableField(int nTab) : mnTab(nTab) {}
753 :
754 0 : void SvxTableField::SetTab(int nTab)
755 : {
756 0 : mnTab = nTab;
757 0 : }
758 :
759 :
760 21338 : SvxFieldData* SvxTableField::Clone() const
761 : {
762 21338 : return new SvxTableField(mnTab);
763 : }
764 :
765 0 : bool SvxTableField::operator==( const SvxFieldData& rCmp ) const
766 : {
767 0 : if (rCmp.Type() != TYPE(SvxTableField))
768 0 : return false;
769 :
770 0 : return mnTab == static_cast<const SvxTableField&>(rCmp).mnTab;
771 : }
772 :
773 0 : void SvxTableField::Load( SvPersistStream & /*rStm*/ )
774 : {
775 0 : }
776 :
777 0 : void SvxTableField::Save( SvPersistStream & /*rStm*/ )
778 : {
779 0 : }
780 :
781 :
782 : // SvxExtTimeField
783 :
784 :
785 562 : SV_IMPL_PERSIST1( SvxExtTimeField, SvxFieldData );
786 :
787 :
788 :
789 266 : SvxExtTimeField::SvxExtTimeField()
790 266 : : m_nFixTime( tools::Time(tools::Time::SYSTEM).GetTime() )
791 : {
792 266 : eType = SVXTIMETYPE_VAR;
793 266 : eFormat = SVXTIMEFORMAT_STANDARD;
794 266 : }
795 :
796 :
797 :
798 0 : SvxExtTimeField::SvxExtTimeField( const tools::Time& rTime, SvxTimeType eT, SvxTimeFormat eF )
799 0 : : m_nFixTime( rTime.GetTime() )
800 : {
801 0 : eType = eT;
802 0 : eFormat = eF;
803 0 : }
804 :
805 :
806 :
807 2934 : SvxFieldData* SvxExtTimeField::Clone() const
808 : {
809 2934 : return new SvxExtTimeField( *this );
810 : }
811 :
812 :
813 :
814 0 : bool SvxExtTimeField::operator==( const SvxFieldData& rOther ) const
815 : {
816 0 : if ( rOther.Type() != Type() )
817 0 : return false;
818 :
819 0 : const SvxExtTimeField& rOtherFld = static_cast<const SvxExtTimeField&>(rOther);
820 0 : return ((m_nFixTime == rOtherFld.m_nFixTime) &&
821 0 : ( eType == rOtherFld.eType ) &&
822 0 : ( eFormat == rOtherFld.eFormat ) );
823 : }
824 :
825 :
826 :
827 0 : void SvxExtTimeField::Load( SvPersistStream & rStm )
828 : {
829 : sal_uInt16 nType, nFormat;
830 :
831 0 : rStm.ReadInt64(m_nFixTime);
832 0 : rStm.ReadUInt16( nType );
833 0 : rStm.ReadUInt16( nFormat );
834 :
835 0 : eType = (SvxTimeType) nType;
836 0 : eFormat= (SvxTimeFormat) nFormat;
837 0 : }
838 :
839 :
840 :
841 0 : void SvxExtTimeField::Save( SvPersistStream & rStm )
842 : {
843 0 : rStm.WriteInt64(m_nFixTime);
844 0 : rStm.WriteUInt16( eType );
845 0 : rStm.WriteUInt16( eFormat );
846 0 : }
847 :
848 :
849 :
850 0 : OUString SvxExtTimeField::GetFormatted( SvNumberFormatter& rFormatter, LanguageType eLang ) const
851 : {
852 0 : tools::Time aTime( tools::Time::EMPTY );
853 0 : if ( eType == SVXTIMETYPE_FIX )
854 0 : aTime.SetTime(m_nFixTime);
855 : else
856 0 : aTime = tools::Time( tools::Time::SYSTEM ); // current time
857 0 : return GetFormatted( aTime, eFormat, rFormatter, eLang );
858 : }
859 :
860 0 : OUString SvxExtTimeField::GetFormatted( tools::Time& aTime, SvxTimeFormat eFormat, SvNumberFormatter& rFormatter, LanguageType eLang )
861 : {
862 0 : switch( eFormat )
863 : {
864 : case SVXTIMEFORMAT_SYSTEM :
865 : OSL_FAIL( "SVXTIMEFORMAT_SYSTEM: not implemented" );
866 0 : eFormat = SVXTIMEFORMAT_STANDARD;
867 0 : break;
868 : case SVXTIMEFORMAT_APPDEFAULT :
869 : OSL_FAIL( "SVXTIMEFORMAT_APPDEFAULT: not implemented" );
870 0 : eFormat = SVXTIMEFORMAT_STANDARD;
871 0 : break;
872 : default: ;//prevent warning
873 : }
874 :
875 : sal_uInt32 nFormatKey;
876 :
877 0 : switch( eFormat )
878 : {
879 : case SVXTIMEFORMAT_12_HM:
880 0 : nFormatKey = rFormatter.GetFormatIndex( NF_TIME_HHMMAMPM, eLang );
881 0 : break;
882 : case SVXTIMEFORMAT_12_HMSH:
883 : {
884 : // no builtin format available, try to insert or reuse
885 0 : OUString aFormatCode( "HH:MM:SS.00 AM/PM" );
886 : sal_Int32 nCheckPos;
887 : short nType;
888 : rFormatter.PutandConvertEntry( aFormatCode, nCheckPos, nType,
889 0 : nFormatKey, LANGUAGE_ENGLISH_US, eLang );
890 : DBG_ASSERT( nCheckPos == 0, "SVXTIMEFORMAT_12_HMSH: could not insert format code" );
891 0 : if ( nCheckPos )
892 : {
893 0 : nFormatKey = rFormatter.GetFormatIndex( NF_TIME_HH_MMSS00, eLang );
894 : }
895 0 : break;
896 : }
897 : case SVXTIMEFORMAT_24_HM:
898 0 : nFormatKey = rFormatter.GetFormatIndex( NF_TIME_HHMM, eLang );
899 0 : break;
900 : case SVXTIMEFORMAT_24_HMSH:
901 0 : nFormatKey = rFormatter.GetFormatIndex( NF_TIME_HH_MMSS00, eLang );
902 0 : break;
903 : case SVXTIMEFORMAT_12_HMS:
904 0 : nFormatKey = rFormatter.GetFormatIndex( NF_TIME_HHMMSSAMPM, eLang );
905 0 : break;
906 : case SVXTIMEFORMAT_24_HMS:
907 0 : nFormatKey = rFormatter.GetFormatIndex( NF_TIME_HHMMSS, eLang );
908 0 : break;
909 : case SVXTIMEFORMAT_STANDARD:
910 : default:
911 0 : nFormatKey = rFormatter.GetStandardFormat( NUMBERFORMAT_TIME, eLang );
912 : }
913 :
914 0 : double fFracTime = aTime.GetTimeInDays();
915 0 : OUString aStr;
916 0 : Color* pColor = NULL;
917 0 : rFormatter.GetOutputString( fFracTime, nFormatKey, aStr, &pColor );
918 0 : return aStr;
919 : }
920 :
921 0 : MetaAction* SvxExtTimeField::createBeginComment() const
922 : {
923 0 : return new MetaCommentAction( "FIELD_SEQ_BEGIN" );
924 : }
925 :
926 :
927 : // SvxExtFileField
928 :
929 :
930 0 : SV_IMPL_PERSIST1( SvxExtFileField, SvxFieldData );
931 :
932 :
933 :
934 0 : SvxExtFileField::SvxExtFileField()
935 : {
936 0 : eType = SVXFILETYPE_VAR;
937 0 : eFormat = SVXFILEFORMAT_FULLPATH;
938 0 : }
939 :
940 :
941 :
942 2 : SvxExtFileField::SvxExtFileField( const OUString& rStr, SvxFileType eT, SvxFileFormat eF )
943 : {
944 2 : aFile = rStr;
945 2 : eType = eT;
946 2 : eFormat = eF;
947 2 : }
948 :
949 :
950 :
951 14 : SvxFieldData* SvxExtFileField::Clone() const
952 : {
953 14 : return new SvxExtFileField( *this );
954 : }
955 :
956 :
957 :
958 0 : bool SvxExtFileField::operator==( const SvxFieldData& rOther ) const
959 : {
960 0 : if ( rOther.Type() != Type() )
961 0 : return false;
962 :
963 0 : const SvxExtFileField& rOtherFld = static_cast<const SvxExtFileField&>(rOther);
964 0 : return ( ( aFile == rOtherFld.aFile ) &&
965 0 : ( eType == rOtherFld.eType ) &&
966 0 : ( eFormat == rOtherFld.eFormat ) );
967 : }
968 :
969 :
970 :
971 0 : void SvxExtFileField::Load( SvPersistStream & rStm )
972 : {
973 : sal_uInt16 nType, nFormat;
974 :
975 : // UNICODE: rStm >> aFile;
976 0 : aFile = rStm.ReadUniOrByteString(rStm.GetStreamCharSet());
977 :
978 0 : rStm.ReadUInt16( nType );
979 0 : rStm.ReadUInt16( nFormat );
980 :
981 0 : eType = (SvxFileType) nType;
982 0 : eFormat= (SvxFileFormat) nFormat;
983 0 : }
984 :
985 :
986 :
987 0 : void SvxExtFileField::Save( SvPersistStream & rStm )
988 : {
989 : // UNICODE: rStm << aFile;
990 0 : rStm.WriteUniOrByteString(aFile, rStm.GetStreamCharSet());
991 :
992 0 : rStm.WriteUInt16( eType );
993 0 : rStm.WriteUInt16( eFormat );
994 0 : }
995 :
996 :
997 :
998 0 : OUString SvxExtFileField::GetFormatted() const
999 : {
1000 0 : OUString aString;
1001 :
1002 0 : INetURLObject aURLObj( aFile );
1003 :
1004 0 : if( INET_PROT_NOT_VALID == aURLObj.GetProtocol() )
1005 : {
1006 : // invalid? try to interpret string as system file name
1007 0 : OUString aURLStr;
1008 :
1009 0 : ::utl::LocalFileHelper::ConvertPhysicalNameToURL( aFile, aURLStr );
1010 :
1011 0 : aURLObj.SetURL( aURLStr );
1012 : }
1013 :
1014 : // #92009# Be somewhat liberate when trying to
1015 : // get formatted content out of the FileField
1016 0 : if( INET_PROT_NOT_VALID == aURLObj.GetProtocol() )
1017 : {
1018 : // still not valid? Then output as is
1019 0 : aString = aFile;
1020 : }
1021 0 : else if( INET_PROT_FILE == aURLObj.GetProtocol() )
1022 : {
1023 0 : switch( eFormat )
1024 : {
1025 : case SVXFILEFORMAT_FULLPATH:
1026 0 : aString = aURLObj.getFSysPath(INetURLObject::FSYS_DETECT);
1027 0 : break;
1028 :
1029 : case SVXFILEFORMAT_PATH:
1030 0 : aURLObj.removeSegment(INetURLObject::LAST_SEGMENT, false);
1031 : // #101742# Leave trailing slash at the pathname
1032 0 : aURLObj.setFinalSlash();
1033 0 : aString = aURLObj.getFSysPath(INetURLObject::FSYS_DETECT);
1034 0 : break;
1035 :
1036 : case SVXFILEFORMAT_NAME:
1037 0 : aString = aURLObj.getBase(INetURLObject::LAST_SEGMENT,true,INetURLObject::DECODE_UNAMBIGUOUS);
1038 0 : break;
1039 :
1040 : case SVXFILEFORMAT_NAME_EXT:
1041 0 : aString = aURLObj.getName(INetURLObject::LAST_SEGMENT,true,INetURLObject::DECODE_UNAMBIGUOUS);
1042 0 : break;
1043 : }
1044 : }
1045 : else
1046 : {
1047 0 : switch( eFormat )
1048 : {
1049 : case SVXFILEFORMAT_FULLPATH:
1050 0 : aString = aURLObj.GetMainURL( INetURLObject::DECODE_TO_IURI );
1051 0 : break;
1052 :
1053 : case SVXFILEFORMAT_PATH:
1054 0 : aURLObj.removeSegment(INetURLObject::LAST_SEGMENT, false);
1055 : // #101742# Leave trailing slash at the pathname
1056 0 : aURLObj.setFinalSlash();
1057 0 : aString = aURLObj.GetMainURL( INetURLObject::DECODE_TO_IURI );
1058 0 : break;
1059 :
1060 : case SVXFILEFORMAT_NAME:
1061 0 : aString = aURLObj.getBase();
1062 0 : break;
1063 :
1064 : case SVXFILEFORMAT_NAME_EXT:
1065 0 : aString = aURLObj.getName();
1066 0 : break;
1067 : }
1068 : }
1069 :
1070 0 : return aString;
1071 : }
1072 :
1073 :
1074 : // SvxAuthorField
1075 :
1076 :
1077 0 : SV_IMPL_PERSIST1( SvxAuthorField, SvxFieldData );
1078 :
1079 :
1080 :
1081 0 : SvxAuthorField::SvxAuthorField()
1082 : {
1083 0 : eType = SVXAUTHORTYPE_VAR;
1084 0 : eFormat = SVXAUTHORFORMAT_FULLNAME;
1085 0 : }
1086 :
1087 :
1088 :
1089 0 : SvxAuthorField::SvxAuthorField( const OUString& rFirstName,
1090 : const OUString& rLastName,
1091 : const OUString& rShortName,
1092 0 : SvxAuthorType eT, SvxAuthorFormat eF )
1093 : {
1094 0 : aName = rLastName;
1095 0 : aFirstName = rFirstName;
1096 0 : aShortName = rShortName;
1097 0 : eType = eT;
1098 0 : eFormat = eF;
1099 0 : }
1100 :
1101 :
1102 :
1103 0 : SvxFieldData* SvxAuthorField::Clone() const
1104 : {
1105 0 : return new SvxAuthorField( *this );
1106 : }
1107 :
1108 :
1109 :
1110 0 : bool SvxAuthorField::operator==( const SvxFieldData& rOther ) const
1111 : {
1112 0 : if ( rOther.Type() != Type() )
1113 0 : return false;
1114 :
1115 0 : const SvxAuthorField& rOtherFld = static_cast<const SvxAuthorField&>(rOther);
1116 0 : return ( ( aName == rOtherFld.aName ) &&
1117 0 : ( aFirstName == rOtherFld.aFirstName ) &&
1118 0 : ( aShortName == rOtherFld.aShortName ) &&
1119 0 : ( eType == rOtherFld.eType ) &&
1120 0 : ( eFormat == rOtherFld.eFormat ) );
1121 : }
1122 :
1123 :
1124 :
1125 0 : void SvxAuthorField::Load( SvPersistStream & rStm )
1126 : {
1127 0 : sal_uInt16 nType = 0, nFormat = 0;
1128 :
1129 0 : aName = read_unicode( rStm );
1130 0 : aFirstName = read_unicode( rStm );
1131 0 : aShortName = read_unicode( rStm );
1132 :
1133 0 : rStm.ReadUInt16( nType );
1134 0 : rStm.ReadUInt16( nFormat );
1135 :
1136 0 : eType = (SvxAuthorType) nType;
1137 0 : eFormat= (SvxAuthorFormat) nFormat;
1138 0 : }
1139 :
1140 :
1141 :
1142 0 : void SvxAuthorField::Save( SvPersistStream & rStm )
1143 : {
1144 0 : write_unicode( rStm, aName );
1145 0 : write_unicode( rStm, aFirstName );
1146 0 : write_unicode( rStm, aShortName );
1147 :
1148 0 : rStm.WriteUInt16( eType );
1149 0 : rStm.WriteUInt16( eFormat );
1150 0 : }
1151 :
1152 :
1153 :
1154 0 : OUString SvxAuthorField::GetFormatted() const
1155 : {
1156 0 : OUString aString;
1157 :
1158 0 : switch( eFormat )
1159 : {
1160 : case SVXAUTHORFORMAT_FULLNAME:
1161 0 : aString = aFirstName + " " + aName;
1162 0 : break;
1163 : case SVXAUTHORFORMAT_NAME:
1164 0 : aString = aName;
1165 0 : break;
1166 :
1167 : case SVXAUTHORFORMAT_FIRSTNAME:
1168 0 : aString = aFirstName;
1169 0 : break;
1170 :
1171 : case SVXAUTHORFORMAT_SHORTNAME:
1172 0 : aString = aShortName;
1173 0 : break;
1174 : }
1175 :
1176 0 : return aString;
1177 : }
1178 :
1179 : static SvClassManager* pClassMgr=0;
1180 :
1181 756 : SvClassManager& SvxFieldItem::GetClassManager()
1182 : {
1183 756 : if ( !pClassMgr )
1184 : {
1185 170 : pClassMgr = new SvClassManager;
1186 170 : pClassMgr->Register(SvxFieldData::StaticClassId(), SvxFieldData::CreateInstance);
1187 170 : pClassMgr->Register(SvxURLField::StaticClassId(), SvxURLField::CreateInstance);
1188 170 : pClassMgr->Register(SvxDateField::StaticClassId(), SvxDateField::CreateInstance);
1189 170 : pClassMgr->Register(SvxPageField::StaticClassId(), SvxPageField::CreateInstance);
1190 170 : pClassMgr->Register(SvxPageTitleField::StaticClassId(), SvxPageTitleField::CreateInstance);
1191 170 : pClassMgr->Register(SvxTimeField::StaticClassId(), SvxTimeField::CreateInstance);
1192 170 : pClassMgr->Register(SvxExtTimeField::StaticClassId(), SvxExtTimeField::CreateInstance);
1193 170 : pClassMgr->Register(SvxExtFileField::StaticClassId(), SvxExtFileField::CreateInstance);
1194 170 : pClassMgr->Register(SvxAuthorField::StaticClassId(), SvxAuthorField::CreateInstance);
1195 : }
1196 :
1197 756 : return *pClassMgr;
1198 : }
1199 :
1200 :
1201 :
1202 3651 : SV_IMPL_PERSIST1( SvxHeaderField, SvxFieldData );
1203 :
1204 11294 : SvxHeaderField::SvxHeaderField() {}
1205 :
1206 10782 : SvxFieldData* SvxHeaderField::Clone() const
1207 : {
1208 10782 : return new SvxHeaderField; // empty
1209 : }
1210 :
1211 0 : bool SvxHeaderField::operator==( const SvxFieldData& rCmp ) const
1212 : {
1213 0 : return ( rCmp.Type() == TYPE(SvxHeaderField) );
1214 : }
1215 :
1216 0 : void SvxHeaderField::Load( SvPersistStream & /*rStm*/ )
1217 : {
1218 0 : }
1219 :
1220 0 : void SvxHeaderField::Save( SvPersistStream & /*rStm*/ )
1221 : {
1222 0 : }
1223 :
1224 :
1225 :
1226 9314 : SV_IMPL_PERSIST1( SvxFooterField, SvxFieldData );
1227 17390 : SvxFooterField::SvxFooterField() {}
1228 :
1229 16568 : SvxFieldData* SvxFooterField::Clone() const
1230 : {
1231 16568 : return new SvxFooterField; // empty
1232 : }
1233 :
1234 0 : bool SvxFooterField::operator==( const SvxFieldData& rCmp ) const
1235 : {
1236 0 : return ( rCmp.Type() == TYPE(SvxFooterField) );
1237 : }
1238 :
1239 0 : void SvxFooterField::Load( SvPersistStream & /*rStm*/ )
1240 : {
1241 0 : }
1242 :
1243 0 : void SvxFooterField::Save( SvPersistStream & /*rStm*/ )
1244 : {
1245 0 : }
1246 :
1247 :
1248 :
1249 12206 : SV_IMPL_PERSIST1( SvxDateTimeField, SvxFieldData );
1250 :
1251 16524 : SvxFieldData* SvxDateTimeField::Clone() const
1252 : {
1253 16524 : return new SvxDateTimeField; // empty
1254 : }
1255 :
1256 0 : bool SvxDateTimeField::operator==( const SvxFieldData& rCmp ) const
1257 : {
1258 0 : return ( rCmp.Type() == TYPE(SvxDateTimeField) );
1259 : }
1260 :
1261 0 : void SvxDateTimeField::Load( SvPersistStream & /*rStm*/ )
1262 : {
1263 0 : }
1264 :
1265 0 : void SvxDateTimeField::Save( SvPersistStream & /*rStm*/ )
1266 : {
1267 0 : }
1268 :
1269 17344 : SvxDateTimeField::SvxDateTimeField() {}
1270 :
1271 0 : OUString SvxDateTimeField::GetFormatted(
1272 : Date& rDate, tools::Time& rTime, int eFormat, SvNumberFormatter& rFormatter, LanguageType eLanguage )
1273 : {
1274 0 : OUString aRet;
1275 :
1276 0 : SvxDateFormat eDateFormat = (SvxDateFormat)(eFormat & 0x0f);
1277 :
1278 0 : if(eDateFormat)
1279 : {
1280 0 : aRet = SvxDateField::GetFormatted( rDate, eDateFormat, rFormatter, eLanguage );
1281 : }
1282 :
1283 0 : SvxTimeFormat eTimeFormat = (SvxTimeFormat)((eFormat >> 4) & 0x0f);
1284 :
1285 0 : if(eTimeFormat)
1286 : {
1287 0 : OUStringBuffer aBuf(aRet);
1288 :
1289 0 : if (!aRet.isEmpty())
1290 0 : aBuf.append(' ');
1291 :
1292 : aBuf.append(
1293 0 : SvxExtTimeField::GetFormatted(rTime, eTimeFormat, rFormatter, eLanguage));
1294 :
1295 0 : aRet = aBuf.makeStringAndClear();
1296 : }
1297 :
1298 0 : return aRet;
1299 669 : }
1300 :
1301 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
