editeng/source/items/flditem.cxx

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