1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_editeng.hxx"
26 #include <vcl/metaact.hxx>
27 #include <svl/zforlist.hxx>
28 #include <tools/urlobj.hxx>
29
30 #define _SVX_FLDITEM_CXX
31 #include <unotools/localfilehelper.hxx>
32
33 #include <editeng/flditem.hxx>
34
35 #include <editeng/measfld.hxx>
36
37 // #90477#
38 #include <tools/tenccvt.hxx>
39
40 #define FRAME_MARKER (sal_uInt32)0x21981357
41 #define CHARSET_MARKER (FRAME_MARKER+1)
42
43 // -----------------------------------------------------------------------
44
45 TYPEINIT1( SvxFieldItem, SfxPoolItem );
46
47 SV_IMPL_PERSIST1( SvxFieldData, SvPersistBase );
48
49 // -----------------------------------------------------------------------
50
SvxFieldData()51 SvxFieldData::SvxFieldData()
52 {
53 }
54
55 // -----------------------------------------------------------------------
56
~SvxFieldData()57 SvxFieldData::~SvxFieldData()
58 {
59 }
60
61 // -----------------------------------------------------------------------
62
Clone() const63 SvxFieldData* SvxFieldData::Clone() const
64 {
65 return new SvxFieldData;
66 }
67
68 // -----------------------------------------------------------------------
69
operator ==(const SvxFieldData & rFld) const70 int SvxFieldData::operator==( const SvxFieldData& rFld ) const
71 {
72 DBG_ASSERT( Type() == rFld.Type(), "==: Verschiedene Typen" );
73 (void)rFld;
74 return sal_True; // Basicklasse immer gleich.
75 }
76
77 // -----------------------------------------------------------------------
78
Load(SvPersistStream &)79 void SvxFieldData::Load( SvPersistStream & /*rStm*/ )
80 {
81 }
82
83 // -----------------------------------------------------------------------
84
Save(SvPersistStream &)85 void SvxFieldData::Save( SvPersistStream & /*rStm*/ )
86 {
87 }
88
89
createBeginComment() const90 MetaAction* SvxFieldData::createBeginComment() const
91 {
92 return new MetaCommentAction( "FIELD_SEQ_BEGIN" );
93 }
94
createEndComment() const95 MetaAction* SvxFieldData::createEndComment() const
96 {
97 return new MetaCommentAction( "FIELD_SEQ_END" );
98 }
99
100 // -----------------------------------------------------------------------
101
SvxFieldItem(SvxFieldData * pFld,const sal_uInt16 nId)102 SvxFieldItem::SvxFieldItem( SvxFieldData* pFld, const sal_uInt16 nId ) :
103 SfxPoolItem( nId )
104 {
105 pField = pFld; // gehoert direkt dem Item
106 }
107
108 // -----------------------------------------------------------------------
109
SvxFieldItem(const SvxFieldData & rField,const sal_uInt16 nId)110 SvxFieldItem::SvxFieldItem( const SvxFieldData& rField, const sal_uInt16 nId ) :
111 SfxPoolItem( nId )
112 {
113 pField = rField.Clone();
114 }
115
116 // -----------------------------------------------------------------------
117
SvxFieldItem(const SvxFieldItem & rItem)118 SvxFieldItem::SvxFieldItem( const SvxFieldItem& rItem ) :
119 SfxPoolItem ( rItem )
120 {
121 pField = rItem.GetField() ? rItem.GetField()->Clone() : 0;
122 }
123
124 // -----------------------------------------------------------------------
125
~SvxFieldItem()126 SvxFieldItem::~SvxFieldItem()
127 {
128 delete pField;
129 }
130
131 // -----------------------------------------------------------------------
132
Clone(SfxItemPool *) const133 SfxPoolItem* SvxFieldItem::Clone( SfxItemPool* ) const
134 {
135 return new SvxFieldItem(*this);
136 }
137
138 // -----------------------------------------------------------------------
139
Create(SvStream & rStrm,sal_uInt16) const140 SfxPoolItem* SvxFieldItem::Create( SvStream& rStrm, sal_uInt16 ) const
141 {
142 SvxFieldData* pData = 0;
143 SvPersistStream aPStrm( GetClassManager(), &rStrm );
144 aPStrm >> pData;
145
146 if( aPStrm.IsEof() )
147 aPStrm.SetError( SVSTREAM_GENERALERROR );
148
149 if ( aPStrm.GetError() == ERRCODE_IO_NOFACTORY )
150 aPStrm.ResetError(); // Eigentlich einen Code, dass nicht alle Attr gelesen wurden...
151
152 return new SvxFieldItem( pData, Which() );
153 }
154
155 // -----------------------------------------------------------------------
156
Store(SvStream & rStrm,sal_uInt16) const157 SvStream& SvxFieldItem::Store( SvStream& rStrm, sal_uInt16 /*nItemVersion*/ ) const
158 {
159 DBG_ASSERT( pField, "SvxFieldItem::Store: Feld?!" );
160 SvPersistStream aPStrm( GetClassManager(), &rStrm );
161 // Das ResetError in der obigen Create-Methode gab es in 3.1 noch nicht,
162 // deshalb duerfen beim 3.x-Export neuere Items nicht gespeichert werden!
163 if ( ( rStrm.GetVersion() <= SOFFICE_FILEFORMAT_31 ) && pField &&
164 pField->GetClassId() == 50 /* SdrMeasureField */ )
165 {
166 // SvxFieldData reicht nicht, weil auch nicht am ClassMgr angemeldet
167 SvxURLField aDummyData;
168 aPStrm << &aDummyData;
169 }
170 else
171 aPStrm << pField;
172
173 return rStrm;
174 }
175
176 // -----------------------------------------------------------------------
177
operator ==(const SfxPoolItem & rItem) const178 int SvxFieldItem::operator==( const SfxPoolItem& rItem ) const
179 {
180 DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal which or type" );
181
182 const SvxFieldData* pOtherFld = ((const SvxFieldItem&)rItem).GetField();
183 if ( !pField && !pOtherFld )
184 return sal_True;
185
186 if ( ( !pField && pOtherFld ) || ( pField && !pOtherFld ) )
187 return sal_False;
188
189 return ( ( pField->Type() == pOtherFld->Type() )
190 && ( *pField == *pOtherFld ) );
191 }
192
193 // =================================================================
194 // Es folgen die Ableitungen von SvxFieldData...
195 // =================================================================
196
197 SV_IMPL_PERSIST1( SvxDateField, SvxFieldData );
198
199 // -----------------------------------------------------------------------
200
SvxDateField()201 SvxDateField::SvxDateField()
202 {
203 nFixDate = Date().GetDate();
204 eType = SVXDATETYPE_VAR;
205 eFormat = SVXDATEFORMAT_STDSMALL;
206 }
207
208 // -----------------------------------------------------------------------
209
SvxDateField(const Date & rDate,SvxDateType eT,SvxDateFormat eF)210 SvxDateField::SvxDateField( const Date& rDate, SvxDateType eT, SvxDateFormat eF )
211 {
212 nFixDate = rDate.GetDate();
213 eType = eT;
214 eFormat = eF;
215 }
216
217 // -----------------------------------------------------------------------
218
Clone() const219 SvxFieldData* SvxDateField::Clone() const
220 {
221 return new SvxDateField( *this );
222 }
223
224 // -----------------------------------------------------------------------
225
operator ==(const SvxFieldData & rOther) const226 int SvxDateField::operator==( const SvxFieldData& rOther ) const
227 {
228 if ( rOther.Type() != Type() )
229 return sal_False;
230
231 const SvxDateField& rOtherFld = (const SvxDateField&) rOther;
232 return ( ( nFixDate == rOtherFld.nFixDate ) &&
233 ( eType == rOtherFld.eType ) &&
234 ( eFormat == rOtherFld.eFormat ) );
235 }
236
237 // -----------------------------------------------------------------------
238
Load(SvPersistStream & rStm)239 void SvxDateField::Load( SvPersistStream & rStm )
240 {
241 sal_uInt16 nType, nFormat;
242
243 rStm >> nFixDate;
244 rStm >> nType;
245 rStm >> nFormat;
246
247 eType = (SvxDateType)nType;
248 eFormat= (SvxDateFormat)nFormat;
249 }
250
251 // -----------------------------------------------------------------------
252
Save(SvPersistStream & rStm)253 void SvxDateField::Save( SvPersistStream & rStm )
254 {
255 rStm << nFixDate;
256 rStm << (sal_uInt16)eType;
257 rStm << (sal_uInt16)eFormat;
258 }
259
260 // -----------------------------------------------------------------------
261
GetFormatted(SvNumberFormatter & rFormatter,LanguageType eLang) const262 String SvxDateField::GetFormatted( SvNumberFormatter& rFormatter, LanguageType eLang ) const
263 {
264 Date aDate; // current date
265 if ( eType == SVXDATETYPE_FIX )
266 aDate.SetDate( nFixDate );
267
268 return GetFormatted( aDate, eFormat, rFormatter, eLang );
269 }
270
GetFormatted(Date & aDate,SvxDateFormat eFormat,SvNumberFormatter & rFormatter,LanguageType eLang)271 String SvxDateField::GetFormatted( Date& aDate, SvxDateFormat eFormat, SvNumberFormatter& rFormatter, LanguageType eLang )
272 {
273 if ( eFormat == SVXDATEFORMAT_SYSTEM )
274 {
275 DBG_ERROR( "SVXDATEFORMAT_SYSTEM nicht implementiert!" );
276 eFormat = SVXDATEFORMAT_STDSMALL;
277 }
278 else if ( eFormat == SVXDATEFORMAT_APPDEFAULT )
279 {
280 DBG_ERROR( "SVXDATEFORMAT_APPDEFAULT: Woher nehmen?" );
281 eFormat = SVXDATEFORMAT_STDSMALL;
282 }
283
284 sal_uLong nFormatKey;
285
286 switch( eFormat )
287 {
288 case SVXDATEFORMAT_STDSMALL:
289 // short
290 nFormatKey = rFormatter.GetFormatIndex( NF_DATE_SYSTEM_SHORT, eLang );
291 break;
292 case SVXDATEFORMAT_STDBIG:
293 // long
294 nFormatKey = rFormatter.GetFormatIndex( NF_DATE_SYSTEM_LONG, eLang );
295 break;
296 case SVXDATEFORMAT_A:
297 // 13.02.96
298 nFormatKey = rFormatter.GetFormatIndex( NF_DATE_SYS_DDMMYY, eLang );
299 break;
300 case SVXDATEFORMAT_B:
301 // 13.02.1996
302 nFormatKey = rFormatter.GetFormatIndex( NF_DATE_SYS_DDMMYYYY, eLang );
303 break;
304 case SVXDATEFORMAT_C:
305 // 13. Feb 1996
306 nFormatKey = rFormatter.GetFormatIndex( NF_DATE_SYS_DMMMYYYY, eLang );
307 break;
308 case SVXDATEFORMAT_D:
309 // 13. Februar 1996
310 nFormatKey = rFormatter.GetFormatIndex( NF_DATE_SYS_DMMMMYYYY, eLang );
311 break;
312 case SVXDATEFORMAT_E:
313 // Die, 13. Februar 1996
314 nFormatKey = rFormatter.GetFormatIndex( NF_DATE_SYS_NNDMMMMYYYY, eLang );
315 break;
316 case SVXDATEFORMAT_F:
317 // Dienstag, 13. Februar 1996
318 nFormatKey = rFormatter.GetFormatIndex( NF_DATE_SYS_NNNNDMMMMYYYY, eLang );
319 break;
320 default:
321 nFormatKey = rFormatter.GetStandardFormat( NUMBERFORMAT_DATE, eLang );
322 }
323
324 double fDiffDate = aDate - *(rFormatter.GetNullDate());
325 String aStr;
326 Color* pColor = NULL;
327 rFormatter.GetOutputString( fDiffDate, nFormatKey, aStr, &pColor );
328 return aStr;
329 }
330
createBeginComment() const331 MetaAction* SvxDateField::createBeginComment() const
332 {
333 return new MetaCommentAction( "FIELD_SEQ_BEGIN" );
334 }
335
336 SV_IMPL_PERSIST1( SvxURLField, SvxFieldData );
337
338 // -----------------------------------------------------------------------
339
SvxURLField()340 SvxURLField::SvxURLField()
341 {
342 eFormat = SVXURLFORMAT_URL;
343 }
344
345 // -----------------------------------------------------------------------
346
SvxURLField(const XubString & rURL,const XubString & rRepres,SvxURLFormat eFmt)347 SvxURLField::SvxURLField( const XubString& rURL, const XubString& rRepres, SvxURLFormat eFmt )
348 : aURL( rURL ), aRepresentation( rRepres )
349 {
350 eFormat = eFmt;
351 }
352
353 // -----------------------------------------------------------------------
354
Clone() const355 SvxFieldData* SvxURLField::Clone() const
356 {
357 return new SvxURLField( *this );
358 }
359
360 // -----------------------------------------------------------------------
361
operator ==(const SvxFieldData & rOther) const362 int SvxURLField::operator==( const SvxFieldData& rOther ) const
363 {
364 if ( rOther.Type() != Type() )
365 return sal_False;
366
367 const SvxURLField& rOtherFld = (const SvxURLField&) rOther;
368 return ( ( eFormat == rOtherFld.eFormat ) &&
369 ( aURL == rOtherFld.aURL ) &&
370 ( aRepresentation == rOtherFld.aRepresentation ) &&
371 ( aTargetFrame == rOtherFld.aTargetFrame ) );
372 }
373
374 // -----------------------------------------------------------------------
375
write_unicode(SvPersistStream & rStm,const String & rString)376 static void write_unicode( SvPersistStream & rStm, const String& rString )
377 {
378 sal_uInt16 nL = rString.Len();
379 rStm << nL;
380 rStm.Write( rString.GetBuffer(), nL*sizeof(sal_Unicode) );
381 }
382
read_unicode(SvPersistStream & rStm,String & rString)383 static void read_unicode( SvPersistStream & rStm, String& rString )
384 {
385 sal_uInt16 nL = 0;
386 rStm >> nL;
387 if ( nL )
388 {
389 rString.AllocBuffer( nL );
390 rStm.Read( rString.GetBufferAccess(), nL*sizeof(sal_Unicode) );
391 rString.ReleaseBufferAccess( nL );
392 }
393 }
394
Load(SvPersistStream & rStm)395 void SvxURLField::Load( SvPersistStream & rStm )
396 {
397 sal_uInt16 nFormat = 0;
398
399 rStm >> nFormat;
400 eFormat= (SvxURLFormat)nFormat;
401
402 read_unicode( rStm, aURL );
403 read_unicode( rStm, aRepresentation );
404 read_unicode( rStm, aTargetFrame );
405 }
406
407 // -----------------------------------------------------------------------
408
Save(SvPersistStream & rStm)409 void SvxURLField::Save( SvPersistStream & rStm )
410 {
411 rStm << (sal_uInt16)eFormat;
412
413 write_unicode( rStm, aURL );
414 write_unicode( rStm, aRepresentation );
415 write_unicode( rStm, aTargetFrame );
416 }
417
createBeginComment() const418 MetaAction* SvxURLField::createBeginComment() const
419 {
420 // #i46618# Adding target URL to metafile comment
421 return new MetaCommentAction( "FIELD_SEQ_BEGIN",
422 0,
423 reinterpret_cast<const sal_uInt8*>(aURL.GetBuffer()),
424 2*aURL.Len() );
425 }
426
427 // =================================================================
428 // Die Felder, die aus Calc ausgebaut wurden:
429 // =================================================================
430
431 SV_IMPL_PERSIST1( SvxPageField, SvxFieldData );
432
Clone() const433 SvxFieldData* __EXPORT SvxPageField::Clone() const
434 {
435 return new SvxPageField; // leer
436 }
437
operator ==(const SvxFieldData & rCmp) const438 int __EXPORT SvxPageField::operator==( const SvxFieldData& rCmp ) const
439 {
440 return ( rCmp.Type() == TYPE(SvxPageField) );
441 }
442
Load(SvPersistStream &)443 void __EXPORT SvxPageField::Load( SvPersistStream & /*rStm*/ )
444 {
445 }
446
Save(SvPersistStream &)447 void __EXPORT SvxPageField::Save( SvPersistStream & /*rStm*/ )
448 {
449 }
450
createBeginComment() const451 MetaAction* SvxPageField::createBeginComment() const
452 {
453 return new MetaCommentAction( "FIELD_SEQ_BEGIN;PageField" );
454 }
455
456
457 SV_IMPL_PERSIST1( SvxPagesField, SvxFieldData );
458
Clone() const459 SvxFieldData* __EXPORT SvxPagesField::Clone() const
460 {
461 return new SvxPagesField; // leer
462 }
463
operator ==(const SvxFieldData & rCmp) const464 int __EXPORT SvxPagesField::operator==( const SvxFieldData& rCmp ) const
465 {
466 return ( rCmp.Type() == TYPE(SvxPagesField) );
467 }
468
Load(SvPersistStream &)469 void __EXPORT SvxPagesField::Load( SvPersistStream & /*rStm*/ )
470 {
471 }
472
Save(SvPersistStream &)473 void __EXPORT SvxPagesField::Save( SvPersistStream & /*rStm*/ )
474 {
475 }
476
477 SV_IMPL_PERSIST1( SvxTimeField, SvxFieldData );
478
Clone() const479 SvxFieldData* __EXPORT SvxTimeField::Clone() const
480 {
481 return new SvxTimeField; // leer
482 }
483
operator ==(const SvxFieldData & rCmp) const484 int __EXPORT SvxTimeField::operator==( const SvxFieldData& rCmp ) const
485 {
486 return ( rCmp.Type() == TYPE(SvxTimeField) );
487 }
488
Load(SvPersistStream &)489 void __EXPORT SvxTimeField::Load( SvPersistStream & /*rStm*/ )
490 {
491 }
492
Save(SvPersistStream &)493 void __EXPORT SvxTimeField::Save( SvPersistStream & /*rStm*/ )
494 {
495 }
496
createBeginComment() const497 MetaAction* SvxTimeField::createBeginComment() const
498 {
499 return new MetaCommentAction( "FIELD_SEQ_BEGIN" );
500 }
501
502 SV_IMPL_PERSIST1( SvxFileField, SvxFieldData );
503
Clone() const504 SvxFieldData* __EXPORT SvxFileField::Clone() const
505 {
506 return new SvxFileField; // leer
507 }
508
operator ==(const SvxFieldData & rCmp) const509 int __EXPORT SvxFileField::operator==( const SvxFieldData& rCmp ) const
510 {
511 return ( rCmp.Type() == TYPE(SvxFileField) );
512 }
513
Load(SvPersistStream &)514 void __EXPORT SvxFileField::Load( SvPersistStream & /*rStm*/ )
515 {
516 }
517
Save(SvPersistStream &)518 void __EXPORT SvxFileField::Save( SvPersistStream & /*rStm*/ )
519 {
520 }
521
522 SV_IMPL_PERSIST1( SvxTableField, SvxFieldData );
523
Clone() const524 SvxFieldData* __EXPORT SvxTableField::Clone() const
525 {
526 return new SvxTableField; // leer
527 }
528
operator ==(const SvxFieldData & rCmp) const529 int __EXPORT SvxTableField::operator==( const SvxFieldData& rCmp ) const
530 {
531 return ( rCmp.Type() == TYPE(SvxTableField) );
532 }
533
Load(SvPersistStream &)534 void __EXPORT SvxTableField::Load( SvPersistStream & /*rStm*/ )
535 {
536 }
537
Save(SvPersistStream &)538 void __EXPORT SvxTableField::Save( SvPersistStream & /*rStm*/ )
539 {
540 }
541
542 //----------------------------------------------------------------------------
543 // SvxExtTimeField
544 //----------------------------------------------------------------------------
545
546 SV_IMPL_PERSIST1( SvxExtTimeField, SvxFieldData );
547
548 //----------------------------------------------------------------------------
549
SvxExtTimeField()550 SvxExtTimeField::SvxExtTimeField()
551 {
552 nFixTime = Time().GetTime();
553 eType = SVXTIMETYPE_VAR;
554 eFormat = SVXTIMEFORMAT_STANDARD;
555 }
556
557 //----------------------------------------------------------------------------
558
SvxExtTimeField(const Time & rTime,SvxTimeType eT,SvxTimeFormat eF)559 SvxExtTimeField::SvxExtTimeField( const Time& rTime, SvxTimeType eT, SvxTimeFormat eF )
560 {
561 nFixTime = rTime.GetTime();
562 eType = eT;
563 eFormat = eF;
564 }
565
566 //----------------------------------------------------------------------------
567
Clone() const568 SvxFieldData* SvxExtTimeField::Clone() const
569 {
570 return new SvxExtTimeField( *this );
571 }
572
573 //----------------------------------------------------------------------------
574
operator ==(const SvxFieldData & rOther) const575 int SvxExtTimeField::operator==( const SvxFieldData& rOther ) const
576 {
577 if ( rOther.Type() != Type() )
578 return sal_False;
579
580 const SvxExtTimeField& rOtherFld = (const SvxExtTimeField&) rOther;
581 return ( ( nFixTime == rOtherFld.nFixTime ) &&
582 ( eType == rOtherFld.eType ) &&
583 ( eFormat == rOtherFld.eFormat ) );
584 }
585
586 //----------------------------------------------------------------------------
587
Load(SvPersistStream & rStm)588 void SvxExtTimeField::Load( SvPersistStream & rStm )
589 {
590 sal_uInt16 nType, nFormat;
591
592 rStm >> nFixTime;
593 rStm >> nType;
594 rStm >> nFormat;
595
596 eType = (SvxTimeType) nType;
597 eFormat= (SvxTimeFormat) nFormat;
598 }
599
600 //----------------------------------------------------------------------------
601
Save(SvPersistStream & rStm)602 void SvxExtTimeField::Save( SvPersistStream & rStm )
603 {
604 rStm << nFixTime;
605 rStm << (sal_uInt16) eType;
606 rStm << (sal_uInt16) eFormat;
607 }
608
609 //----------------------------------------------------------------------------
610
GetFormatted(SvNumberFormatter & rFormatter,LanguageType eLang) const611 String SvxExtTimeField::GetFormatted( SvNumberFormatter& rFormatter, LanguageType eLang ) const
612 {
613 Time aTime; // current time
614 if ( eType == SVXTIMETYPE_FIX )
615 aTime.SetTime( nFixTime );
616 return GetFormatted( aTime, eFormat, rFormatter, eLang );
617 }
618
GetFormatted(Time & aTime,SvxTimeFormat eFormat,SvNumberFormatter & rFormatter,LanguageType eLang)619 String SvxExtTimeField::GetFormatted( Time& aTime, SvxTimeFormat eFormat, SvNumberFormatter& rFormatter, LanguageType eLang )
620 {
621 switch( eFormat )
622 {
623 case SVXTIMEFORMAT_SYSTEM :
624 DBG_ERROR( "SVXTIMEFORMAT_SYSTEM: not implemented" );
625 eFormat = SVXTIMEFORMAT_STANDARD;
626 break;
627 case SVXTIMEFORMAT_APPDEFAULT :
628 DBG_ERROR( "SVXTIMEFORMAT_APPDEFAULT: not implemented" );
629 eFormat = SVXTIMEFORMAT_STANDARD;
630 break;
631 default: ;//prevent warning
632 }
633
634 sal_uInt32 nFormatKey;
635
636 switch( eFormat )
637 {
638 case SVXTIMEFORMAT_12_HM:
639 nFormatKey = rFormatter.GetFormatIndex( NF_TIME_HHMMAMPM, eLang );
640 break;
641 case SVXTIMEFORMAT_12_HMSH:
642 { // no builtin format available, try to insert or reuse
643 String aFormatCode( RTL_CONSTASCII_USTRINGPARAM( "HH:MM:SS.00 AM/PM" ) );
644 xub_StrLen nCheckPos;
645 short nType;
646 /*sal_Bool bInserted = */rFormatter.PutandConvertEntry( aFormatCode,
647 nCheckPos, nType, nFormatKey, LANGUAGE_ENGLISH_US, eLang );
648 DBG_ASSERT( nCheckPos == 0, "SVXTIMEFORMAT_12_HMSH: could not insert format code" );
649 if ( nCheckPos )
650 nFormatKey = rFormatter.GetFormatIndex( NF_TIME_HH_MMSS00, eLang );
651 }
652 break;
653 case SVXTIMEFORMAT_24_HM:
654 nFormatKey = rFormatter.GetFormatIndex( NF_TIME_HHMM, eLang );
655 break;
656 case SVXTIMEFORMAT_24_HMSH:
657 nFormatKey = rFormatter.GetFormatIndex( NF_TIME_HH_MMSS00, eLang );
658 break;
659 case SVXTIMEFORMAT_12_HMS:
660 nFormatKey = rFormatter.GetFormatIndex( NF_TIME_HHMMSSAMPM, eLang );
661 break;
662 case SVXTIMEFORMAT_24_HMS:
663 nFormatKey = rFormatter.GetFormatIndex( NF_TIME_HHMMSS, eLang );
664 break;
665 case SVXTIMEFORMAT_STANDARD:
666 default:
667 nFormatKey = rFormatter.GetStandardFormat( NUMBERFORMAT_TIME, eLang );
668 }
669
670 double fFracTime = aTime.GetTimeInDays();
671 String aStr;
672 Color* pColor = NULL;
673 rFormatter.GetOutputString( fFracTime, nFormatKey, aStr, &pColor );
674 return aStr;
675 }
676
createBeginComment() const677 MetaAction* SvxExtTimeField::createBeginComment() const
678 {
679 return new MetaCommentAction( "FIELD_SEQ_BEGIN" );
680 }
681
682 //----------------------------------------------------------------------------
683 // SvxExtFileField
684 //----------------------------------------------------------------------------
685
686 SV_IMPL_PERSIST1( SvxExtFileField, SvxFieldData );
687
688 //----------------------------------------------------------------------------
689
SvxExtFileField()690 SvxExtFileField::SvxExtFileField()
691 {
692 eType = SVXFILETYPE_VAR;
693 eFormat = SVXFILEFORMAT_FULLPATH;
694 }
695
696 //----------------------------------------------------------------------------
697
SvxExtFileField(const XubString & rStr,SvxFileType eT,SvxFileFormat eF)698 SvxExtFileField::SvxExtFileField( const XubString& rStr, SvxFileType eT, SvxFileFormat eF )
699 {
700 aFile = rStr;
701 eType = eT;
702 eFormat = eF;
703 }
704
705 //----------------------------------------------------------------------------
706
Clone() const707 SvxFieldData* SvxExtFileField::Clone() const
708 {
709 return new SvxExtFileField( *this );
710 }
711
712 //----------------------------------------------------------------------------
713
operator ==(const SvxFieldData & rOther) const714 int SvxExtFileField::operator==( const SvxFieldData& rOther ) const
715 {
716 if ( rOther.Type() != Type() )
717 return sal_False;
718
719 const SvxExtFileField& rOtherFld = (const SvxExtFileField&) rOther;
720 return ( ( aFile == rOtherFld.aFile ) &&
721 ( eType == rOtherFld.eType ) &&
722 ( eFormat == rOtherFld.eFormat ) );
723 }
724
725 //----------------------------------------------------------------------------
726
Load(SvPersistStream & rStm)727 void SvxExtFileField::Load( SvPersistStream & rStm )
728 {
729 sal_uInt16 nType, nFormat;
730
731 // UNICODE: rStm >> aFile;
732 rStm.ReadByteString(aFile);
733
734 rStm >> nType;
735 rStm >> nFormat;
736
737 eType = (SvxFileType) nType;
738 eFormat= (SvxFileFormat) nFormat;
739 }
740
741 //----------------------------------------------------------------------------
742
Save(SvPersistStream & rStm)743 void SvxExtFileField::Save( SvPersistStream & rStm )
744 {
745 // UNICODE: rStm << aFile;
746 rStm.WriteByteString(aFile);
747
748 rStm << (sal_uInt16) eType;
749 rStm << (sal_uInt16) eFormat;
750 }
751
752 //----------------------------------------------------------------------------
753
GetFormatted() const754 XubString SvxExtFileField::GetFormatted() const
755 {
756 XubString aString;
757
758 INetURLObject aURLObj( aFile );
759
760 if( INET_PROT_NOT_VALID == aURLObj.GetProtocol() )
761 {
762 // invalid? try to interpret string as system file name
763 String aURLStr;
764
765 ::utl::LocalFileHelper::ConvertPhysicalNameToURL( aFile, aURLStr );
766
767 aURLObj.SetURL( aURLStr );
768 }
769
770 // #92009# Be somewhat liberate when trying to
771 // get formatted content out of the FileField
772 if( INET_PROT_NOT_VALID == aURLObj.GetProtocol() )
773 {
774 // still not valid? Then output as is
775 aString = aFile;
776 }
777 else if( INET_PROT_FILE == aURLObj.GetProtocol() )
778 {
779 switch( eFormat )
780 {
781 case SVXFILEFORMAT_FULLPATH:
782 aString = aURLObj.getFSysPath(INetURLObject::FSYS_DETECT);
783 break;
784
785 case SVXFILEFORMAT_PATH:
786 aURLObj.removeSegment(INetURLObject::LAST_SEGMENT, false);
787 // #101742# Leave trailing slash at the pathname
788 aURLObj.setFinalSlash();
789 aString = aURLObj.getFSysPath(INetURLObject::FSYS_DETECT);
790 break;
791
792 case SVXFILEFORMAT_NAME:
793 aString = aURLObj.getBase(INetURLObject::LAST_SEGMENT,true,INetURLObject::DECODE_UNAMBIGUOUS);
794 break;
795
796 case SVXFILEFORMAT_NAME_EXT:
797 aString = aURLObj.getName(INetURLObject::LAST_SEGMENT,true,INetURLObject::DECODE_UNAMBIGUOUS);
798 break;
799 }
800 }
801 else
802 {
803 switch( eFormat )
804 {
805 case SVXFILEFORMAT_FULLPATH:
806 aString = aURLObj.GetMainURL( INetURLObject::DECODE_TO_IURI );
807 break;
808
809 case SVXFILEFORMAT_PATH:
810 aURLObj.removeSegment(INetURLObject::LAST_SEGMENT, false);
811 // #101742# Leave trailing slash at the pathname
812 aURLObj.setFinalSlash();
813 aString = aURLObj.GetMainURL( INetURLObject::DECODE_TO_IURI );
814 break;
815
816 case SVXFILEFORMAT_NAME:
817 aString = aURLObj.getBase();
818 break;
819
820 case SVXFILEFORMAT_NAME_EXT:
821 aString = aURLObj.getName();
822 break;
823 }
824 }
825
826 return( aString );
827 }
828
829 //----------------------------------------------------------------------------
830 // SvxAuthorField
831 //----------------------------------------------------------------------------
832
833 SV_IMPL_PERSIST1( SvxAuthorField, SvxFieldData );
834
835 //----------------------------------------------------------------------------
836
SvxAuthorField()837 SvxAuthorField::SvxAuthorField()
838 {
839 eType = SVXAUTHORTYPE_VAR;
840 eFormat = SVXAUTHORFORMAT_FULLNAME;
841 }
842
843 //----------------------------------------------------------------------------
844
SvxAuthorField(const XubString & rFirstName,const XubString & rLastName,const XubString & rShortName,SvxAuthorType eT,SvxAuthorFormat eF)845 SvxAuthorField::SvxAuthorField( const XubString& rFirstName,
846 const XubString& rLastName,
847 const XubString& rShortName,
848 SvxAuthorType eT, SvxAuthorFormat eF )
849 {
850 aName = rLastName;
851 aFirstName = rFirstName;
852 aShortName = rShortName;
853 eType = eT;
854 eFormat = eF;
855 }
856
857 //----------------------------------------------------------------------------
858
Clone() const859 SvxFieldData* SvxAuthorField::Clone() const
860 {
861 return new SvxAuthorField( *this );
862 }
863
864 //----------------------------------------------------------------------------
865
operator ==(const SvxFieldData & rOther) const866 int SvxAuthorField::operator==( const SvxFieldData& rOther ) const
867 {
868 if ( rOther.Type() != Type() )
869 return sal_False;
870
871 const SvxAuthorField& rOtherFld = (const SvxAuthorField&) rOther;
872 return ( ( aName == rOtherFld.aName ) &&
873 ( aFirstName == rOtherFld.aFirstName ) &&
874 ( aShortName == rOtherFld.aShortName ) &&
875 ( eType == rOtherFld.eType ) &&
876 ( eFormat == rOtherFld.eFormat ) );
877 }
878
879 //----------------------------------------------------------------------------
880
Load(SvPersistStream & rStm)881 void SvxAuthorField::Load( SvPersistStream & rStm )
882 {
883 sal_uInt16 nType = 0, nFormat = 0;
884
885 read_unicode( rStm, aName );
886 read_unicode( rStm, aFirstName );
887 read_unicode( rStm, aShortName );
888
889 rStm >> nType;
890 rStm >> nFormat;
891
892 eType = (SvxAuthorType) nType;
893 eFormat= (SvxAuthorFormat) nFormat;
894 }
895
896 //----------------------------------------------------------------------------
897
Save(SvPersistStream & rStm)898 void SvxAuthorField::Save( SvPersistStream & rStm )
899 {
900 write_unicode( rStm, aName );
901 write_unicode( rStm, aFirstName );
902 write_unicode( rStm, aShortName );
903
904 rStm << (sal_uInt16) eType;
905 rStm << (sal_uInt16) eFormat;
906 }
907
908 //----------------------------------------------------------------------------
909
GetFormatted() const910 XubString SvxAuthorField::GetFormatted() const
911 {
912 XubString aString;
913
914 switch( eFormat )
915 {
916 case SVXAUTHORFORMAT_FULLNAME:
917 aString = aFirstName;
918 aString += sal_Unicode(' ');
919 aString += aName;
920 break;
921
922 case SVXAUTHORFORMAT_NAME:
923 aString = aName;
924 break;
925
926 case SVXAUTHORFORMAT_FIRSTNAME:
927 aString = aFirstName;
928 break;
929
930 case SVXAUTHORFORMAT_SHORTNAME:
931 aString = aShortName;
932 break;
933 }
934
935 return( aString );
936 }
937
938 static SvClassManager* pClassMgr=0;
939
GetClassManager()940 SvClassManager& SvxFieldItem::GetClassManager()
941 {
942 if ( !pClassMgr )
943 {
944 pClassMgr = new SvClassManager;
945 pClassMgr->SV_CLASS_REGISTER( SvxFieldData );
946 pClassMgr->SV_CLASS_REGISTER( SvxURLField );
947 pClassMgr->SV_CLASS_REGISTER( SvxDateField );
948 pClassMgr->SV_CLASS_REGISTER( SvxPageField );
949 pClassMgr->SV_CLASS_REGISTER( SvxTimeField );
950 pClassMgr->SV_CLASS_REGISTER( SvxExtTimeField );
951 pClassMgr->SV_CLASS_REGISTER( SvxExtFileField );
952 pClassMgr->SV_CLASS_REGISTER( SvxAuthorField );
953 }
954
955 return *pClassMgr;
956 }
957
958 ///////////////////////////////////////////////////////////////////////
959
960 SV_IMPL_PERSIST1( SvxHeaderField, SvxFieldData );
961
Clone() const962 SvxFieldData* __EXPORT SvxHeaderField::Clone() const
963 {
964 return new SvxHeaderField; // leer
965 }
966
operator ==(const SvxFieldData & rCmp) const967 int __EXPORT SvxHeaderField::operator==( const SvxFieldData& rCmp ) const
968 {
969 return ( rCmp.Type() == TYPE(SvxHeaderField) );
970 }
971
Load(SvPersistStream &)972 void __EXPORT SvxHeaderField::Load( SvPersistStream & /*rStm*/ )
973 {
974 }
975
Save(SvPersistStream &)976 void __EXPORT SvxHeaderField::Save( SvPersistStream & /*rStm*/ )
977 {
978 }
979
980 ///////////////////////////////////////////////////////////////////////
981
982 SV_IMPL_PERSIST1( SvxFooterField, SvxFieldData );
983
Clone() const984 SvxFieldData* __EXPORT SvxFooterField::Clone() const
985 {
986 return new SvxFooterField; // leer
987 }
988
operator ==(const SvxFieldData & rCmp) const989 int __EXPORT SvxFooterField::operator==( const SvxFieldData& rCmp ) const
990 {
991 return ( rCmp.Type() == TYPE(SvxFooterField) );
992 }
993
Load(SvPersistStream &)994 void __EXPORT SvxFooterField::Load( SvPersistStream & /*rStm*/ )
995 {
996 }
997
Save(SvPersistStream &)998 void __EXPORT SvxFooterField::Save( SvPersistStream & /*rStm*/ )
999 {
1000 }
1001
1002 ///////////////////////////////////////////////////////////////////////
1003
1004 SV_IMPL_PERSIST1( SvxDateTimeField, SvxFieldData );
1005
Clone() const1006 SvxFieldData* __EXPORT SvxDateTimeField::Clone() const
1007 {
1008 return new SvxDateTimeField; // leer
1009 }
1010
operator ==(const SvxFieldData & rCmp) const1011 int __EXPORT SvxDateTimeField::operator==( const SvxFieldData& rCmp ) const
1012 {
1013 return ( rCmp.Type() == TYPE(SvxDateTimeField) );
1014 }
1015
Load(SvPersistStream &)1016 void __EXPORT SvxDateTimeField::Load( SvPersistStream & /*rStm*/ )
1017 {
1018 }
1019
Save(SvPersistStream &)1020 void __EXPORT SvxDateTimeField::Save( SvPersistStream & /*rStm*/ )
1021 {
1022 }
1023
GetFormatted(Date & rDate,Time & rTime,int eFormat,SvNumberFormatter & rFormatter,LanguageType eLanguage)1024 String SvxDateTimeField::GetFormatted( Date& rDate, Time& rTime, int eFormat, SvNumberFormatter& rFormatter, LanguageType eLanguage )
1025 {
1026 String aRet;
1027
1028 SvxDateFormat eDateFormat = (SvxDateFormat)(eFormat & 0x0f);
1029
1030 if(eDateFormat)
1031 {
1032 aRet = SvxDateField::GetFormatted( rDate, eDateFormat, rFormatter, eLanguage );
1033 }
1034
1035 SvxTimeFormat eTimeFormat = (SvxTimeFormat)((eFormat >> 4) & 0x0f);
1036
1037 if(eTimeFormat)
1038 {
1039 if(aRet.Len())
1040 aRet += sal_Unicode(' ');
1041
1042 aRet += SvxExtTimeField::GetFormatted( rTime, eTimeFormat, rFormatter, eLanguage );
1043 }
1044
1045 return aRet;
1046 }
1047
1048