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