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 553 : SvxFieldData* SvxFieldData::Create(const uno::Reference<text::XTextContent>& xTextContent)
41 : {
42 553 : uno::Reference<beans::XPropertySet> xPropSet(xTextContent, uno::UNO_QUERY);
43 553 : if (!xPropSet.is())
44 3 : 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 1100 : uno::Any aAny;
49 : try {
50 550 : aAny = xPropSet->getPropertyValue(UNO_TC_PROP_TEXTFIELD_TYPE);
51 550 : if ( !aAny.has<sal_Int32>() )
52 2 : return NULL;
53 :
54 548 : sal_Int32 nFieldType = aAny.get<sal_Int32>();
55 :
56 548 : switch (nFieldType)
57 : {
58 : case text::textfield::Type::TIME:
59 : case text::textfield::Type::EXTENDED_TIME:
60 : case text::textfield::Type::DATE:
61 : {
62 44 : bool bIsDate = false;
63 44 : xPropSet->getPropertyValue(UNO_TC_PROP_IS_DATE) >>= bIsDate;
64 :
65 44 : if (bIsDate)
66 : {
67 44 : util::DateTime aDateTime = xPropSet->getPropertyValue(UNO_TC_PROP_DATE_TIME).get<util::DateTime>();
68 44 : Date aDate(aDateTime.Day, aDateTime.Month, aDateTime.Year);
69 44 : bool bIsFixed = false;
70 44 : xPropSet->getPropertyValue(UNO_TC_PROP_IS_FIXED) >>= bIsFixed;
71 :
72 44 : SvxDateField* pData = new SvxDateField(aDate, bIsFixed ? SVXDATETYPE_FIX : SVXDATETYPE_VAR);
73 44 : sal_Int32 nNumFmt = -1;
74 44 : xPropSet->getPropertyValue(UNO_TC_PROP_NUMFORMAT) >>= nNumFmt;
75 44 : if (nNumFmt >= SVXDATEFORMAT_APPDEFAULT && nNumFmt <= SVXDATEFORMAT_F)
76 44 : pData->SetFormat(static_cast<SvxDateFormat>(nNumFmt));
77 :
78 44 : 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);
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 174 : return new SvxPageField();
118 : case text::textfield::Type::PAGES:
119 0 : return new SvxPagesField();
120 : case text::textfield::Type::PAGE_NAME:
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 5 : SdrMeasureFieldKind eKind = SDRMEASUREFIELD_VALUE;
199 5 : sal_Int16 nTmp = -1;
200 5 : xPropSet->getPropertyValue(UNO_TC_PROP_MEASURE_KIND) >>= nTmp;
201 9 : if (nTmp == static_cast<sal_Int16>(SDRMEASUREFIELD_UNIT) ||
202 4 : nTmp == static_cast<sal_Int16>(SDRMEASUREFIELD_ROTA90BLANCS))
203 4 : eKind = static_cast<SdrMeasureFieldKind>(nTmp);
204 :
205 5 : return new SdrMeasureField(eKind);
206 : }
207 : case text::textfield::Type::PRESENTATION_HEADER:
208 83 : return new SvxHeaderField();
209 : case text::textfield::Type::PRESENTATION_FOOTER:
210 120 : return new SvxFooterField();
211 : case text::textfield::Type::PRESENTATION_DATE_TIME:
212 120 : return new SvxDateTimeField();
213 : default:
214 : ;
215 : };
216 0 : } catch ( const beans::UnknownPropertyException& )
217 : {
218 0 : return NULL;
219 : }
220 :
221 553 : return NULL;
222 : }
223 :
224 147460 : TYPEINIT1( SvxFieldItem, SfxPoolItem );
225 :
226 1594 : SV_IMPL_PERSIST1( SvxFieldData, SvPersistBase );
227 :
228 :
229 :
230 50699 : SvxFieldData::SvxFieldData()
231 : {
232 50699 : }
233 :
234 :
235 :
236 54442 : SvxFieldData::~SvxFieldData()
237 : {
238 54442 : }
239 :
240 :
241 :
242 117 : SvxFieldData* SvxFieldData::Clone() const
243 : {
244 117 : return new SvxFieldData;
245 : }
246 :
247 :
248 :
249 30 : bool SvxFieldData::operator==( const SvxFieldData& rFld ) const
250 : {
251 : DBG_ASSERT( Type() == rFld.Type(), "==: Different Types" );
252 : (void)rFld;
253 30 : 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()
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 10225 : SvxFieldItem::SvxFieldItem( const SvxFieldData& rField, const sal_uInt16 nId ) :
290 10225 : SfxPoolItem( nId )
291 : {
292 10225 : pField = rField.Clone();
293 10225 : }
294 :
295 :
296 :
297 38503 : SvxFieldItem::SvxFieldItem( const SvxFieldItem& rItem ) :
298 38503 : SfxPoolItem ( rItem )
299 : {
300 38503 : pField = rItem.GetField() ? rItem.GetField()->Clone() : 0;
301 38503 : }
302 :
303 :
304 :
305 124278 : SvxFieldItem::~SvxFieldItem()
306 : {
307 44771 : delete pField;
308 79507 : }
309 :
310 :
311 :
312 38293 : SfxPoolItem* SvxFieldItem::Clone( SfxItemPool* ) const
313 : {
314 38293 : 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 426 : SvStream& SvxFieldItem::Store( SvStream& rStrm, sal_uInt16 /*nItemVersion*/ ) const
337 : {
338 : DBG_ASSERT( pField, "SvxFieldItem::Store: Field?!" );
339 426 : 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 852 : if ( ( rStrm.GetVersion() <= SOFFICE_FILEFORMAT_31 ) && pField &&
343 426 : 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 426 : WriteSvPersistBase( aPStrm, pField );
351 :
352 426 : return rStrm;
353 : }
354 :
355 :
356 :
357 32814 : bool SvxFieldItem::operator==( const SfxPoolItem& rItem ) const
358 : {
359 : DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal which or type" );
360 :
361 32814 : const SvxFieldData* pOtherFld = static_cast<const SvxFieldItem&>(rItem).GetField();
362 32814 : if ( !pField && !pOtherFld )
363 0 : return true;
364 :
365 32814 : if ( ( !pField && pOtherFld ) || ( pField && !pOtherFld ) )
366 0 : return false;
367 :
368 32814 : return ( ( pField->Type() == pOtherFld->Type() )
369 32814 : && ( *pField == *pOtherFld ) );
370 : }
371 :
372 :
373 : // The following are the derivatives of SvxFieldData ...
374 :
375 :
376 8086 : SV_IMPL_PERSIST1( SvxDateField, SvxFieldData );
377 :
378 :
379 :
380 177 : SvxDateField::SvxDateField()
381 : {
382 177 : nFixDate = Date( Date::SYSTEM ).GetDate();
383 177 : eType = SVXDATETYPE_VAR;
384 177 : eFormat = SVXDATEFORMAT_STDSMALL;
385 177 : }
386 :
387 :
388 :
389 654 : SvxDateField::SvxDateField( const Date& rDate, SvxDateType eT, SvxDateFormat eF )
390 : {
391 654 : nFixDate = rDate.GetDate();
392 654 : eType = eT;
393 654 : eFormat = eF;
394 654 : }
395 :
396 :
397 :
398 5779 : SvxFieldData* SvxDateField::Clone() const
399 : {
400 5779 : return new SvxDateField( *this );
401 : }
402 :
403 :
404 :
405 70 : bool SvxDateField::operator==( const SvxFieldData& rOther ) const
406 : {
407 70 : if ( rOther.Type() != Type() )
408 0 : return false;
409 :
410 70 : const SvxDateField& rOtherFld = static_cast<const SvxDateField&>(rOther);
411 140 : return ( ( nFixDate == rOtherFld.nFixDate ) &&
412 140 : ( eType == rOtherFld.eType ) &&
413 140 : ( 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 4 : void SvxDateField::Save( SvPersistStream & rStm )
433 : {
434 4 : rStm.WriteUInt32( nFixDate );
435 4 : rStm.WriteUInt16( eType );
436 4 : rStm.WriteUInt16( eFormat );
437 4 : }
438 :
439 :
440 :
441 53 : OUString SvxDateField::GetFormatted( SvNumberFormatter& rFormatter, LanguageType eLang ) const
442 : {
443 53 : Date aDate( Date::EMPTY );
444 53 : if ( eType == SVXDATETYPE_FIX )
445 0 : aDate.SetDate( nFixDate );
446 : else
447 53 : aDate = Date( Date::SYSTEM ); // current date
448 :
449 53 : return GetFormatted( aDate, eFormat, rFormatter, eLang );
450 : }
451 :
452 53 : OUString SvxDateField::GetFormatted( Date& aDate, SvxDateFormat eFormat, SvNumberFormatter& rFormatter, LanguageType eLang )
453 : {
454 53 : if ( eFormat == SVXDATEFORMAT_SYSTEM )
455 : {
456 : OSL_FAIL( "SVXDATEFORMAT_SYSTEM not implemented!" );
457 0 : eFormat = SVXDATEFORMAT_STDSMALL;
458 : }
459 53 : 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 53 : switch( eFormat )
468 : {
469 : case SVXDATEFORMAT_STDSMALL:
470 : // short
471 53 : nFormatKey = rFormatter.GetFormatIndex( NF_DATE_SYSTEM_SHORT, eLang );
472 53 : 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( css::util::NumberFormat::DATE, eLang );
503 : }
504 :
505 53 : double fDiffDate = aDate - *(rFormatter.GetNullDate());
506 53 : OUString aStr;
507 53 : Color* pColor = NULL;
508 53 : rFormatter.GetOutputString( fDiffDate, nFormatKey, aStr, &pColor );
509 53 : return aStr;
510 : }
511 :
512 0 : MetaAction* SvxDateField::createBeginComment() const
513 : {
514 0 : return new MetaCommentAction( "FIELD_SEQ_BEGIN" );
515 : }
516 :
517 3929 : SV_IMPL_PERSIST1( SvxURLField, SvxFieldData );
518 :
519 :
520 :
521 3 : SvxURLField::SvxURLField()
522 : {
523 3 : eFormat = SVXURLFORMAT_URL;
524 3 : }
525 :
526 :
527 :
528 30 : SvxURLField::SvxURLField( const OUString& rURL, const OUString& rRepres, SvxURLFormat eFmt )
529 30 : : aURL( rURL ), aRepresentation( rRepres )
530 : {
531 30 : eFormat = eFmt;
532 30 : }
533 :
534 :
535 :
536 168 : SvxFieldData* SvxURLField::Clone() const
537 : {
538 168 : return new SvxURLField( *this );
539 : }
540 :
541 :
542 :
543 940 : bool SvxURLField::operator==( const SvxFieldData& rOther ) const
544 : {
545 940 : if ( rOther.Type() != Type() )
546 0 : return false;
547 :
548 940 : const SvxURLField& rOtherFld = static_cast<const SvxURLField&>(rOther);
549 1880 : return ( ( eFormat == rOtherFld.eFormat ) &&
550 1201 : ( aURL == rOtherFld.aURL ) &&
551 1378 : ( aRepresentation == rOtherFld.aRepresentation ) &&
552 1117 : ( 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 : const size_t nMaxRecords = rStm.remainingSize() / sizeof(sal_Unicode);
571 0 : if (nL > nMaxRecords)
572 : {
573 : SAL_WARN("editeng", "Parsing error: " << nMaxRecords <<
574 : " max possible entries, but " << nL << " claimed, truncating");
575 0 : nL = nMaxRecords;
576 : }
577 0 : if (nL)
578 : {
579 0 : pStr = rtl_uString_alloc(nL);
580 : //endian specific?, yipes!
581 0 : rStm.Read(pStr->buffer, nL*sizeof(sal_Unicode));
582 : }
583 : //take ownership of buffer and return, otherwise return empty string
584 0 : return pStr ? OUString(pStr, SAL_NO_ACQUIRE) : OUString();
585 : }
586 :
587 0 : void SvxURLField::Load( SvPersistStream & rStm )
588 : {
589 0 : sal_uInt16 nFormat = 0;
590 :
591 0 : rStm.ReadUInt16( nFormat );
592 0 : eFormat= (SvxURLFormat)nFormat;
593 :
594 0 : aURL = read_unicode( rStm );
595 0 : aRepresentation = read_unicode( rStm );
596 0 : aTargetFrame = read_unicode( rStm );
597 0 : }
598 :
599 :
600 :
601 0 : void SvxURLField::Save( SvPersistStream & rStm )
602 : {
603 0 : rStm.WriteUInt16( eFormat );
604 :
605 0 : write_unicode( rStm, aURL );
606 0 : write_unicode( rStm, aRepresentation );
607 0 : write_unicode( rStm, aTargetFrame );
608 0 : }
609 :
610 0 : MetaAction* SvxURLField::createBeginComment() const
611 : {
612 : // #i46618# Adding target URL to metafile comment
613 : return new MetaCommentAction( "FIELD_SEQ_BEGIN",
614 : 0,
615 0 : reinterpret_cast<const sal_uInt8*>(aURL.getStr()),
616 0 : 2*aURL.getLength() );
617 : }
618 :
619 : //
620 : // SvxPageTitleField methods
621 : //
622 :
623 0 : SV_IMPL_PERSIST1( SvxPageTitleField, SvxFieldData );
624 :
625 0 : SvxPageTitleField::SvxPageTitleField() {}
626 :
627 0 : SvxFieldData* SvxPageTitleField::Clone() const
628 : {
629 0 : return new SvxPageTitleField();
630 : }
631 :
632 0 : bool SvxPageTitleField::operator==( const SvxFieldData& rCmp ) const
633 : {
634 0 : return ( rCmp.Type() == TYPE(SvxPageTitleField) );
635 : }
636 :
637 0 : void SvxPageTitleField::Load( SvPersistStream & /*rStm*/ )
638 : {
639 0 : }
640 :
641 0 : void SvxPageTitleField::Save( SvPersistStream & /*rStm*/ )
642 : {
643 0 : }
644 :
645 0 : MetaAction* SvxPageTitleField::createBeginComment() const
646 : {
647 0 : return new MetaCommentAction( "FIELD_SEQ_BEGIN;PageTitleField" );
648 : }
649 :
650 : //
651 : // SvxPagesField
652 : //
653 : // The fields that were removed from Calc:
654 :
655 :
656 23529 : SV_IMPL_PERSIST1( SvxPageField, SvxFieldData );
657 :
658 14790 : SvxPageField::SvxPageField() {}
659 :
660 12324 : SvxFieldData* SvxPageField::Clone() const
661 : {
662 12324 : return new SvxPageField; // empty
663 : }
664 :
665 1551 : bool SvxPageField::operator==( const SvxFieldData& rCmp ) const
666 : {
667 1551 : return ( rCmp.Type() == TYPE(SvxPageField) );
668 : }
669 :
670 0 : void SvxPageField::Load( SvPersistStream & /*rStm*/ )
671 : {
672 0 : }
673 :
674 188 : void SvxPageField::Save( SvPersistStream & /*rStm*/ )
675 : {
676 188 : }
677 :
678 0 : MetaAction* SvxPageField::createBeginComment() const
679 : {
680 0 : return new MetaCommentAction( "FIELD_SEQ_BEGIN;PageField" );
681 : }
682 :
683 :
684 7481 : SV_IMPL_PERSIST1( SvxPagesField, SvxFieldData );
685 :
686 6039 : SvxPagesField::SvxPagesField() {}
687 :
688 5262 : SvxFieldData* SvxPagesField::Clone() const
689 : {
690 5262 : return new SvxPagesField; // empty
691 : }
692 :
693 64 : bool SvxPagesField::operator==( const SvxFieldData& rCmp ) const
694 : {
695 64 : return ( rCmp.Type() == TYPE(SvxPagesField) );
696 : }
697 :
698 0 : void SvxPagesField::Load( SvPersistStream & /*rStm*/ )
699 : {
700 0 : }
701 :
702 8 : void SvxPagesField::Save( SvPersistStream & /*rStm*/ )
703 : {
704 8 : }
705 :
706 5201 : SV_IMPL_PERSIST1( SvxTimeField, SvxFieldData );
707 :
708 4435 : SvxTimeField::SvxTimeField() {}
709 :
710 3823 : SvxFieldData* SvxTimeField::Clone() const
711 : {
712 3823 : return new SvxTimeField; // empty
713 : }
714 :
715 14 : bool SvxTimeField::operator==( const SvxFieldData& rCmp ) const
716 : {
717 14 : return ( rCmp.Type() == TYPE(SvxTimeField) );
718 : }
719 :
720 0 : void SvxTimeField::Load( SvPersistStream & /*rStm*/ )
721 : {
722 0 : }
723 :
724 0 : void SvxTimeField::Save( SvPersistStream & /*rStm*/ )
725 : {
726 0 : }
727 :
728 0 : MetaAction* SvxTimeField::createBeginComment() const
729 : {
730 0 : return new MetaCommentAction( "FIELD_SEQ_BEGIN" );
731 : }
732 :
733 7782 : SV_IMPL_PERSIST1( SvxFileField, SvxFieldData );
734 :
735 6215 : SvxFileField::SvxFileField() {}
736 :
737 5436 : SvxFieldData* SvxFileField::Clone() const
738 : {
739 5436 : return new SvxFileField; // empty
740 : }
741 :
742 67 : bool SvxFileField::operator==( const SvxFieldData& rCmp ) const
743 : {
744 67 : return ( rCmp.Type() == TYPE(SvxFileField) );
745 : }
746 :
747 0 : void SvxFileField::Load( SvPersistStream & /*rStm*/ )
748 : {
749 0 : }
750 :
751 8 : void SvxFileField::Save( SvPersistStream & /*rStm*/ )
752 : {
753 8 : }
754 :
755 13759 : SV_IMPL_PERSIST1( SvxTableField, SvxFieldData );
756 :
757 1646 : SvxTableField::SvxTableField() : mnTab(0) {}
758 :
759 11460 : SvxTableField::SvxTableField(int nTab) : mnTab(nTab) {}
760 :
761 0 : void SvxTableField::SetTab(int nTab)
762 : {
763 0 : mnTab = nTab;
764 0 : }
765 :
766 :
767 11458 : SvxFieldData* SvxTableField::Clone() const
768 : {
769 11458 : return new SvxTableField(mnTab);
770 : }
771 :
772 878 : bool SvxTableField::operator==( const SvxFieldData& rCmp ) const
773 : {
774 878 : if (rCmp.Type() != TYPE(SvxTableField))
775 0 : return false;
776 :
777 878 : return mnTab == static_cast<const SvxTableField&>(rCmp).mnTab;
778 : }
779 :
780 0 : void SvxTableField::Load( SvPersistStream & /*rStm*/ )
781 : {
782 0 : }
783 :
784 218 : void SvxTableField::Save( SvPersistStream & /*rStm*/ )
785 : {
786 218 : }
787 :
788 :
789 : // SvxExtTimeField
790 :
791 :
792 2448 : SV_IMPL_PERSIST1( SvxExtTimeField, SvxFieldData );
793 :
794 :
795 :
796 168 : SvxExtTimeField::SvxExtTimeField()
797 168 : : m_nFixTime( tools::Time(tools::Time::SYSTEM).GetTime() )
798 : {
799 168 : eType = SVXTIMETYPE_VAR;
800 168 : eFormat = SVXTIMEFORMAT_STANDARD;
801 168 : }
802 :
803 :
804 :
805 0 : SvxExtTimeField::SvxExtTimeField( const tools::Time& rTime, SvxTimeType eT, SvxTimeFormat eF )
806 0 : : m_nFixTime( rTime.GetTime() )
807 : {
808 0 : eType = eT;
809 0 : eFormat = eF;
810 0 : }
811 :
812 :
813 :
814 1562 : SvxFieldData* SvxExtTimeField::Clone() const
815 : {
816 1562 : return new SvxExtTimeField( *this );
817 : }
818 :
819 :
820 :
821 50 : bool SvxExtTimeField::operator==( const SvxFieldData& rOther ) const
822 : {
823 50 : if ( rOther.Type() != Type() )
824 0 : return false;
825 :
826 50 : const SvxExtTimeField& rOtherFld = static_cast<const SvxExtTimeField&>(rOther);
827 100 : return ((m_nFixTime == rOtherFld.m_nFixTime) &&
828 100 : ( eType == rOtherFld.eType ) &&
829 100 : ( eFormat == rOtherFld.eFormat ) );
830 : }
831 :
832 :
833 :
834 0 : void SvxExtTimeField::Load( SvPersistStream & rStm )
835 : {
836 : sal_uInt16 nType, nFormat;
837 :
838 0 : rStm.ReadInt64(m_nFixTime);
839 0 : rStm.ReadUInt16( nType );
840 0 : rStm.ReadUInt16( nFormat );
841 :
842 0 : eType = (SvxTimeType) nType;
843 0 : eFormat= (SvxTimeFormat) nFormat;
844 0 : }
845 :
846 :
847 :
848 0 : void SvxExtTimeField::Save( SvPersistStream & rStm )
849 : {
850 0 : rStm.WriteInt64(m_nFixTime);
851 0 : rStm.WriteUInt16( eType );
852 0 : rStm.WriteUInt16( eFormat );
853 0 : }
854 :
855 :
856 :
857 0 : OUString SvxExtTimeField::GetFormatted( SvNumberFormatter& rFormatter, LanguageType eLang ) const
858 : {
859 0 : tools::Time aTime( tools::Time::EMPTY );
860 0 : if ( eType == SVXTIMETYPE_FIX )
861 0 : aTime.SetTime(m_nFixTime);
862 : else
863 0 : aTime = tools::Time( tools::Time::SYSTEM ); // current time
864 0 : return GetFormatted( aTime, eFormat, rFormatter, eLang );
865 : }
866 :
867 0 : OUString SvxExtTimeField::GetFormatted( tools::Time& aTime, SvxTimeFormat eFormat, SvNumberFormatter& rFormatter, LanguageType eLang )
868 : {
869 0 : switch( eFormat )
870 : {
871 : case SVXTIMEFORMAT_SYSTEM :
872 : OSL_FAIL( "SVXTIMEFORMAT_SYSTEM: not implemented" );
873 0 : eFormat = SVXTIMEFORMAT_STANDARD;
874 0 : break;
875 : case SVXTIMEFORMAT_APPDEFAULT :
876 : OSL_FAIL( "SVXTIMEFORMAT_APPDEFAULT: not implemented" );
877 0 : eFormat = SVXTIMEFORMAT_STANDARD;
878 0 : break;
879 : default: ;//prevent warning
880 : }
881 :
882 : sal_uInt32 nFormatKey;
883 :
884 0 : switch( eFormat )
885 : {
886 : case SVXTIMEFORMAT_12_HM:
887 0 : nFormatKey = rFormatter.GetFormatIndex( NF_TIME_HHMMAMPM, eLang );
888 0 : break;
889 : case SVXTIMEFORMAT_12_HMSH:
890 : {
891 : // no builtin format available, try to insert or reuse
892 0 : OUString aFormatCode( "HH:MM:SS.00 AM/PM" );
893 : sal_Int32 nCheckPos;
894 : short nType;
895 : rFormatter.PutandConvertEntry( aFormatCode, nCheckPos, nType,
896 0 : nFormatKey, LANGUAGE_ENGLISH_US, eLang );
897 : DBG_ASSERT( nCheckPos == 0, "SVXTIMEFORMAT_12_HMSH: could not insert format code" );
898 0 : if ( nCheckPos )
899 : {
900 0 : nFormatKey = rFormatter.GetFormatIndex( NF_TIME_HH_MMSS00, eLang );
901 : }
902 0 : break;
903 : }
904 : case SVXTIMEFORMAT_24_HM:
905 0 : nFormatKey = rFormatter.GetFormatIndex( NF_TIME_HHMM, eLang );
906 0 : break;
907 : case SVXTIMEFORMAT_24_HMSH:
908 0 : nFormatKey = rFormatter.GetFormatIndex( NF_TIME_HH_MMSS00, eLang );
909 0 : break;
910 : case SVXTIMEFORMAT_12_HMS:
911 0 : nFormatKey = rFormatter.GetFormatIndex( NF_TIME_HHMMSSAMPM, eLang );
912 0 : break;
913 : case SVXTIMEFORMAT_24_HMS:
914 0 : nFormatKey = rFormatter.GetFormatIndex( NF_TIME_HHMMSS, eLang );
915 0 : break;
916 : case SVXTIMEFORMAT_STANDARD:
917 : default:
918 0 : nFormatKey = rFormatter.GetStandardFormat( css::util::NumberFormat::TIME, eLang );
919 : }
920 :
921 0 : double fFracTime = aTime.GetTimeInDays();
922 0 : OUString aStr;
923 0 : Color* pColor = NULL;
924 0 : rFormatter.GetOutputString( fFracTime, nFormatKey, aStr, &pColor );
925 0 : return aStr;
926 : }
927 :
928 0 : MetaAction* SvxExtTimeField::createBeginComment() const
929 : {
930 0 : return new MetaCommentAction( "FIELD_SEQ_BEGIN" );
931 : }
932 :
933 :
934 : // SvxExtFileField
935 :
936 :
937 1 : SV_IMPL_PERSIST1( SvxExtFileField, SvxFieldData );
938 :
939 :
940 :
941 0 : SvxExtFileField::SvxExtFileField()
942 : {
943 0 : eType = SVXFILETYPE_VAR;
944 0 : eFormat = SVXFILEFORMAT_FULLPATH;
945 0 : }
946 :
947 :
948 :
949 1 : SvxExtFileField::SvxExtFileField( const OUString& rStr, SvxFileType eT, SvxFileFormat eF )
950 : {
951 1 : aFile = rStr;
952 1 : eType = eT;
953 1 : eFormat = eF;
954 1 : }
955 :
956 :
957 :
958 7 : SvxFieldData* SvxExtFileField::Clone() const
959 : {
960 7 : return new SvxExtFileField( *this );
961 : }
962 :
963 :
964 :
965 0 : bool SvxExtFileField::operator==( const SvxFieldData& rOther ) const
966 : {
967 0 : if ( rOther.Type() != Type() )
968 0 : return false;
969 :
970 0 : const SvxExtFileField& rOtherFld = static_cast<const SvxExtFileField&>(rOther);
971 0 : return ( ( aFile == rOtherFld.aFile ) &&
972 0 : ( eType == rOtherFld.eType ) &&
973 0 : ( eFormat == rOtherFld.eFormat ) );
974 : }
975 :
976 :
977 :
978 0 : void SvxExtFileField::Load( SvPersistStream & rStm )
979 : {
980 : sal_uInt16 nType, nFormat;
981 :
982 : // UNICODE: rStm >> aFile;
983 0 : aFile = rStm.ReadUniOrByteString(rStm.GetStreamCharSet());
984 :
985 0 : rStm.ReadUInt16( nType );
986 0 : rStm.ReadUInt16( nFormat );
987 :
988 0 : eType = (SvxFileType) nType;
989 0 : eFormat= (SvxFileFormat) nFormat;
990 0 : }
991 :
992 :
993 :
994 0 : void SvxExtFileField::Save( SvPersistStream & rStm )
995 : {
996 : // UNICODE: rStm << aFile;
997 0 : rStm.WriteUniOrByteString(aFile, rStm.GetStreamCharSet());
998 :
999 0 : rStm.WriteUInt16( eType );
1000 0 : rStm.WriteUInt16( eFormat );
1001 0 : }
1002 :
1003 :
1004 :
1005 0 : OUString SvxExtFileField::GetFormatted() const
1006 : {
1007 0 : OUString aString;
1008 :
1009 0 : INetURLObject aURLObj( aFile );
1010 :
1011 0 : if( INetProtocol::NotValid == aURLObj.GetProtocol() )
1012 : {
1013 : // invalid? try to interpret string as system file name
1014 0 : OUString aURLStr;
1015 :
1016 0 : ::utl::LocalFileHelper::ConvertPhysicalNameToURL( aFile, aURLStr );
1017 :
1018 0 : aURLObj.SetURL( aURLStr );
1019 : }
1020 :
1021 : // #92009# Be somewhat liberate when trying to
1022 : // get formatted content out of the FileField
1023 0 : if( INetProtocol::NotValid == aURLObj.GetProtocol() )
1024 : {
1025 : // still not valid? Then output as is
1026 0 : aString = aFile;
1027 : }
1028 0 : else if( INetProtocol::File == aURLObj.GetProtocol() )
1029 : {
1030 0 : switch( eFormat )
1031 : {
1032 : case SVXFILEFORMAT_FULLPATH:
1033 0 : aString = aURLObj.getFSysPath(INetURLObject::FSYS_DETECT);
1034 0 : break;
1035 :
1036 : case SVXFILEFORMAT_PATH:
1037 0 : aURLObj.removeSegment(INetURLObject::LAST_SEGMENT, false);
1038 : // #101742# Leave trailing slash at the pathname
1039 0 : aURLObj.setFinalSlash();
1040 0 : aString = aURLObj.getFSysPath(INetURLObject::FSYS_DETECT);
1041 0 : break;
1042 :
1043 : case SVXFILEFORMAT_NAME:
1044 0 : aString = aURLObj.getBase(INetURLObject::LAST_SEGMENT,true,INetURLObject::DECODE_UNAMBIGUOUS);
1045 0 : break;
1046 :
1047 : case SVXFILEFORMAT_NAME_EXT:
1048 0 : aString = aURLObj.getName(INetURLObject::LAST_SEGMENT,true,INetURLObject::DECODE_UNAMBIGUOUS);
1049 0 : break;
1050 : }
1051 : }
1052 : else
1053 : {
1054 0 : switch( eFormat )
1055 : {
1056 : case SVXFILEFORMAT_FULLPATH:
1057 0 : aString = aURLObj.GetMainURL( INetURLObject::DECODE_TO_IURI );
1058 0 : break;
1059 :
1060 : case SVXFILEFORMAT_PATH:
1061 0 : aURLObj.removeSegment(INetURLObject::LAST_SEGMENT, false);
1062 : // #101742# Leave trailing slash at the pathname
1063 0 : aURLObj.setFinalSlash();
1064 0 : aString = aURLObj.GetMainURL( INetURLObject::DECODE_TO_IURI );
1065 0 : break;
1066 :
1067 : case SVXFILEFORMAT_NAME:
1068 0 : aString = aURLObj.getBase();
1069 0 : break;
1070 :
1071 : case SVXFILEFORMAT_NAME_EXT:
1072 0 : aString = aURLObj.getName();
1073 0 : break;
1074 : }
1075 : }
1076 :
1077 0 : return aString;
1078 : }
1079 :
1080 :
1081 : // SvxAuthorField
1082 :
1083 :
1084 0 : SV_IMPL_PERSIST1( SvxAuthorField, SvxFieldData );
1085 :
1086 :
1087 :
1088 0 : SvxAuthorField::SvxAuthorField()
1089 : {
1090 0 : eType = SVXAUTHORTYPE_VAR;
1091 0 : eFormat = SVXAUTHORFORMAT_FULLNAME;
1092 0 : }
1093 :
1094 :
1095 :
1096 0 : SvxAuthorField::SvxAuthorField( const OUString& rFirstName,
1097 : const OUString& rLastName,
1098 : const OUString& rShortName,
1099 0 : SvxAuthorType eT, SvxAuthorFormat eF )
1100 : {
1101 0 : aName = rLastName;
1102 0 : aFirstName = rFirstName;
1103 0 : aShortName = rShortName;
1104 0 : eType = eT;
1105 0 : eFormat = eF;
1106 0 : }
1107 :
1108 :
1109 :
1110 0 : SvxFieldData* SvxAuthorField::Clone() const
1111 : {
1112 0 : return new SvxAuthorField( *this );
1113 : }
1114 :
1115 :
1116 :
1117 0 : bool SvxAuthorField::operator==( const SvxFieldData& rOther ) const
1118 : {
1119 0 : if ( rOther.Type() != Type() )
1120 0 : return false;
1121 :
1122 0 : const SvxAuthorField& rOtherFld = static_cast<const SvxAuthorField&>(rOther);
1123 0 : return ( ( aName == rOtherFld.aName ) &&
1124 0 : ( aFirstName == rOtherFld.aFirstName ) &&
1125 0 : ( aShortName == rOtherFld.aShortName ) &&
1126 0 : ( eType == rOtherFld.eType ) &&
1127 0 : ( eFormat == rOtherFld.eFormat ) );
1128 : }
1129 :
1130 :
1131 :
1132 0 : void SvxAuthorField::Load( SvPersistStream & rStm )
1133 : {
1134 0 : sal_uInt16 nType = 0, nFormat = 0;
1135 :
1136 0 : aName = read_unicode( rStm );
1137 0 : aFirstName = read_unicode( rStm );
1138 0 : aShortName = read_unicode( rStm );
1139 :
1140 0 : rStm.ReadUInt16( nType );
1141 0 : rStm.ReadUInt16( nFormat );
1142 :
1143 0 : eType = (SvxAuthorType) nType;
1144 0 : eFormat= (SvxAuthorFormat) nFormat;
1145 0 : }
1146 :
1147 :
1148 :
1149 0 : void SvxAuthorField::Save( SvPersistStream & rStm )
1150 : {
1151 0 : write_unicode( rStm, aName );
1152 0 : write_unicode( rStm, aFirstName );
1153 0 : write_unicode( rStm, aShortName );
1154 :
1155 0 : rStm.WriteUInt16( eType );
1156 0 : rStm.WriteUInt16( eFormat );
1157 0 : }
1158 :
1159 :
1160 :
1161 0 : OUString SvxAuthorField::GetFormatted() const
1162 : {
1163 0 : OUString aString;
1164 :
1165 0 : switch( eFormat )
1166 : {
1167 : case SVXAUTHORFORMAT_FULLNAME:
1168 0 : aString = aFirstName + " " + aName;
1169 0 : break;
1170 : case SVXAUTHORFORMAT_NAME:
1171 0 : aString = aName;
1172 0 : break;
1173 :
1174 : case SVXAUTHORFORMAT_FIRSTNAME:
1175 0 : aString = aFirstName;
1176 0 : break;
1177 :
1178 : case SVXAUTHORFORMAT_SHORTNAME:
1179 0 : aString = aShortName;
1180 0 : break;
1181 : }
1182 :
1183 0 : return aString;
1184 : }
1185 :
1186 : static SvClassManager* pClassMgr=0;
1187 :
1188 934 : SvClassManager& SvxFieldItem::GetClassManager()
1189 : {
1190 934 : if ( !pClassMgr )
1191 : {
1192 114 : pClassMgr = new SvClassManager;
1193 114 : pClassMgr->Register(SvxFieldData::StaticClassId(), SvxFieldData::CreateInstance);
1194 114 : pClassMgr->Register(SvxURLField::StaticClassId(), SvxURLField::CreateInstance);
1195 114 : pClassMgr->Register(SvxDateField::StaticClassId(), SvxDateField::CreateInstance);
1196 114 : pClassMgr->Register(SvxPageField::StaticClassId(), SvxPageField::CreateInstance);
1197 114 : pClassMgr->Register(SvxPageTitleField::StaticClassId(), SvxPageTitleField::CreateInstance);
1198 114 : pClassMgr->Register(SvxTimeField::StaticClassId(), SvxTimeField::CreateInstance);
1199 114 : pClassMgr->Register(SvxExtTimeField::StaticClassId(), SvxExtTimeField::CreateInstance);
1200 114 : pClassMgr->Register(SvxExtFileField::StaticClassId(), SvxExtFileField::CreateInstance);
1201 114 : pClassMgr->Register(SvxAuthorField::StaticClassId(), SvxAuthorField::CreateInstance);
1202 : }
1203 :
1204 934 : return *pClassMgr;
1205 : }
1206 :
1207 :
1208 :
1209 6317 : SV_IMPL_PERSIST1( SvxHeaderField, SvxFieldData );
1210 :
1211 1200 : SvxHeaderField::SvxHeaderField() {}
1212 :
1213 713 : SvxFieldData* SvxHeaderField::Clone() const
1214 : {
1215 713 : return new SvxHeaderField; // empty
1216 : }
1217 :
1218 329 : bool SvxHeaderField::operator==( const SvxFieldData& rCmp ) const
1219 : {
1220 329 : return ( rCmp.Type() == TYPE(SvxHeaderField) );
1221 : }
1222 :
1223 0 : void SvxHeaderField::Load( SvPersistStream & /*rStm*/ )
1224 : {
1225 0 : }
1226 :
1227 0 : void SvxHeaderField::Save( SvPersistStream & /*rStm*/ )
1228 : {
1229 0 : }
1230 :
1231 :
1232 :
1233 13175 : SV_IMPL_PERSIST1( SvxFooterField, SvxFieldData );
1234 1809 : SvxFooterField::SvxFooterField() {}
1235 :
1236 1046 : SvxFieldData* SvxFooterField::Clone() const
1237 : {
1238 1046 : return new SvxFooterField; // empty
1239 : }
1240 :
1241 605 : bool SvxFooterField::operator==( const SvxFieldData& rCmp ) const
1242 : {
1243 605 : return ( rCmp.Type() == TYPE(SvxFooterField) );
1244 : }
1245 :
1246 0 : void SvxFooterField::Load( SvPersistStream & /*rStm*/ )
1247 : {
1248 0 : }
1249 :
1250 0 : void SvxFooterField::Save( SvPersistStream & /*rStm*/ )
1251 : {
1252 0 : }
1253 :
1254 :
1255 :
1256 15868 : SV_IMPL_PERSIST1( SvxDateTimeField, SvxFieldData );
1257 :
1258 1045 : SvxFieldData* SvxDateTimeField::Clone() const
1259 : {
1260 1045 : return new SvxDateTimeField; // empty
1261 : }
1262 :
1263 604 : bool SvxDateTimeField::operator==( const SvxFieldData& rCmp ) const
1264 : {
1265 604 : return ( rCmp.Type() == TYPE(SvxDateTimeField) );
1266 : }
1267 :
1268 0 : void SvxDateTimeField::Load( SvPersistStream & /*rStm*/ )
1269 : {
1270 0 : }
1271 :
1272 0 : void SvxDateTimeField::Save( SvPersistStream & /*rStm*/ )
1273 : {
1274 0 : }
1275 :
1276 1807 : SvxDateTimeField::SvxDateTimeField() {}
1277 :
1278 0 : OUString SvxDateTimeField::GetFormatted(
1279 : Date& rDate, tools::Time& rTime, int eFormat, SvNumberFormatter& rFormatter, LanguageType eLanguage )
1280 : {
1281 0 : OUString aRet;
1282 :
1283 0 : SvxDateFormat eDateFormat = (SvxDateFormat)(eFormat & 0x0f);
1284 :
1285 0 : if(eDateFormat)
1286 : {
1287 0 : aRet = SvxDateField::GetFormatted( rDate, eDateFormat, rFormatter, eLanguage );
1288 : }
1289 :
1290 0 : SvxTimeFormat eTimeFormat = (SvxTimeFormat)((eFormat >> 4) & 0x0f);
1291 :
1292 0 : if(eTimeFormat)
1293 : {
1294 0 : OUStringBuffer aBuf(aRet);
1295 :
1296 0 : if (!aRet.isEmpty())
1297 0 : aBuf.append(' ');
1298 :
1299 : aBuf.append(
1300 0 : SvxExtTimeField::GetFormatted(rTime, eTimeFormat, rFormatter, eLanguage));
1301 :
1302 0 : aRet = aBuf.makeStringAndClear();
1303 : }
1304 :
1305 0 : return aRet;
1306 : }
1307 :
1308 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
