svx/source/items/flditem.cxx

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