/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

/*

 * This file is part of the LibreOffice project.

 *

 * This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/.

 *

 * This file incorporates work covered by the following license notice:

 *

 *   Licensed to the Apache Software Foundation (ASF) under one or more

 *   contributor license agreements. See the NOTICE file distributed

 *   with this work for additional information regarding copyright

 *   ownership. The ASF licenses this file to you under the Apache

 *   License, Version 2.0 (the "License"); you may not use this file

 *   except in compliance with the License. You may obtain a copy of

 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .

 */

#include <osl/diagnose.h>

#include <osl/file.hxx>

#include <utility>

#include <svl/numformat.hxx>

#include <svl/zforlist.hxx>

#include <tools/urlobj.hxx>

#include <editeng/flditem.hxx>

#include <editeng/CustomPropertyField.hxx>

#include <editeng/measfld.hxx>

#include <editeng/unonames.hxx>

#include <tools/debug.hxx>

#include <libxml/xmlwriter.h>

#include <com/sun/star/beans/XPropertySet.hpp>

#include <com/sun/star/text/XTextContent.hpp>

#include <com/sun/star/text/FilenameDisplayFormat.hpp>

#include <com/sun/star/util/DateTime.hpp>

using namespace com::sun::star;

SvxFieldData* SvxFieldData::Create(const uno::Reference<text::XTextContent>& xTextContent)

{

    uno::Reference<beans::XPropertySet> xPropSet(xTextContent, uno::UNO_QUERY);

    if (!xPropSet.is())

        return nullptr;

    // we do not support these fields from Writer, so make sure we do not throw

    // here - see fdo#63436 how to possibly extend Writer to make use of this

    uno::Any aAny;

    try {

        aAny = xPropSet->getPropertyValue(UNO_TC_PROP_TEXTFIELD_TYPE);

        if ( !aAny.has<sal_Int32>() )

            return nullptr;

        sal_Int32 nFieldType = aAny.get<sal_Int32>();

        switch (nFieldType)

        {

            case text::textfield::Type::TIME:

            case text::textfield::Type::EXTENDED_TIME:

            case text::textfield::Type::DATE:

                {

                    bool bIsDate = false;

                    xPropSet->getPropertyValue(UNO_TC_PROP_IS_DATE) >>= bIsDate;

                    if (bIsDate)

                    {

                        util::DateTime aDateTime = xPropSet->getPropertyValue(UNO_TC_PROP_DATE_TIME).get<util::DateTime>();

                        Date aDate(aDateTime.Day, aDateTime.Month, aDateTime.Year);

                        bool bIsFixed = false;

                        xPropSet->getPropertyValue(UNO_TC_PROP_IS_FIXED) >>= bIsFixed;

                        SvxDateField* pData = new SvxDateField(aDate, bIsFixed ? SvxDateType::Fix : SvxDateType::Var);

                        sal_Int32 nNumFmt = -1;

                        xPropSet->getPropertyValue(UNO_TC_PROP_NUMFORMAT) >>= nNumFmt;

                        if (static_cast<SvxDateFormat>(nNumFmt) >= SvxDateFormat::AppDefault &&

                            static_cast<SvxDateFormat>(nNumFmt) <= SvxDateFormat::F)

                            pData->SetFormat(static_cast<SvxDateFormat>(nNumFmt));

                        return pData;

                    }

                    if (nFieldType != text::textfield::Type::TIME)

                    {

                        util::DateTime aDateTime = xPropSet->getPropertyValue(UNO_TC_PROP_DATE_TIME).get<util::DateTime>();

                        tools::Time aTime(aDateTime);

                        bool bIsFixed = false;

                        xPropSet->getPropertyValue(UNO_TC_PROP_IS_FIXED) >>= bIsFixed;

                        SvxExtTimeField* pData = new SvxExtTimeField(aTime, bIsFixed ? SvxTimeType::Fix : SvxTimeType::Var);

                        sal_Int32 nNumFmt = -1;

                        xPropSet->getPropertyValue(UNO_TC_PROP_NUMFORMAT) >>= nNumFmt;

                        if (static_cast<SvxTimeFormat>(nNumFmt) >= SvxTimeFormat::AppDefault &&

                            static_cast<SvxTimeFormat>(nNumFmt) <= SvxTimeFormat::HH12_MM_SS_00_AMPM)

                            pData->SetFormat(static_cast<SvxTimeFormat>(nNumFmt));

                        return pData;

                    }

                    return new SvxTimeField();

                }

            case text::textfield::Type::URL:

                {

                    OUString aRep, aTarget, aURL;

                    sal_Int16 nFmt = -1;

                    xPropSet->getPropertyValue(UNO_TC_PROP_URL_REPRESENTATION) >>= aRep;

                    xPropSet->getPropertyValue(UNO_TC_PROP_URL_TARGET) >>= aTarget;

                    xPropSet->getPropertyValue(UNO_TC_PROP_URL) >>= aURL;

                    xPropSet->getPropertyValue(UNO_TC_PROP_URL_FORMAT) >>= nFmt;

                    SvxURLField* pData = new SvxURLField(aURL, aRep, aRep.isEmpty() ? SvxURLFormat::Url : SvxURLFormat::Repr);

                    pData->SetTargetFrame(aTarget);

                    if (static_cast<SvxURLFormat>(nFmt) >= SvxURLFormat::AppDefault &&

                        static_cast<SvxURLFormat>(nFmt) <= SvxURLFormat::Repr)

                        pData->SetFormat(static_cast<SvxURLFormat>(nFmt));

                    return pData;

                }

            case text::textfield::Type::PAGE:

                return new SvxPageField();

            case text::textfield::Type::PAGES:

                return new SvxPagesField();

            case text::textfield::Type::PAGE_NAME:

                return new SvxPageTitleField();

            case text::textfield::Type::DOCINFO_TITLE:

                return new SvxFileField();

            case text::textfield::Type::TABLE:

                {

                    sal_Int32 nTab = 0;

                    xPropSet->getPropertyValue(UNO_TC_PROP_TABLE_POSITION) >>= nTab;

                    return new SvxTableField(nTab);

                }

            case text::textfield::Type::EXTENDED_FILE:

                {

                    OUString aPresentation;

                    bool bIsFixed = false;

                    sal_Int16 nFmt = text::FilenameDisplayFormat::FULL;

                    xPropSet->getPropertyValue(UNO_TC_PROP_IS_FIXED) >>= bIsFixed;

                    xPropSet->getPropertyValue(UNO_TC_PROP_CURRENT_PRESENTATION) >>= aPresentation;

                    xPropSet->getPropertyValue(UNO_TC_PROP_FILE_FORMAT) >>= nFmt;

                    SvxFileFormat eFmt = SvxFileFormat::NameAndExt;

                    switch (nFmt)

                    {

                        case text::FilenameDisplayFormat::FULL: eFmt = SvxFileFormat::PathFull; break;

                        case text::FilenameDisplayFormat::PATH: eFmt = SvxFileFormat::PathOnly;     break;

                        case text::FilenameDisplayFormat::NAME: eFmt = SvxFileFormat::NameOnly;     break;

                        default:;

                    }

                    // pass fixed attribute to constructor

                    return new SvxExtFileField(

                            aPresentation, bIsFixed ? SvxFileType::Fix : SvxFileType::Var, eFmt);

                }

            case text::textfield::Type::AUTHOR:

                {

                    bool bIsFixed = false;

                    bool bFullName = false;

                    sal_Int16 nFmt = -1;

                    OUString aPresentation, aContent, aFirstName, aLastName;

                    xPropSet->getPropertyValue(UNO_TC_PROP_IS_FIXED) >>= bIsFixed;

                    xPropSet->getPropertyValue(UNO_TC_PROP_AUTHOR_FULLNAME) >>= bFullName;

                    xPropSet->getPropertyValue(UNO_TC_PROP_CURRENT_PRESENTATION) >>= aPresentation;

                    xPropSet->getPropertyValue(UNO_TC_PROP_AUTHOR_CONTENT) >>= aContent;

                    xPropSet->getPropertyValue(UNO_TC_PROP_AUTHOR_FORMAT) >>= nFmt;

                    // do we have CurrentPresentation given?  Mimic behaviour of

                    // writer, which means: prefer CurrentPresentation over Content

                    // if both are given.

                    if (!aPresentation.isEmpty())

                        aContent = aPresentation;

                    sal_Int32 nPos = aContent.lastIndexOf(' ', 0);

                    if (nPos > 0)

                    {

                        aFirstName = aContent.copy(0, nPos);

                        aLastName = aContent.copy(nPos + 1);

                    }

                    else

                    {

                        aLastName = aContent;

                    }

                    // #92009# pass fixed attribute to constructor

                    SvxAuthorField* pData = new SvxAuthorField(

                            aFirstName, aLastName, OUString(), bIsFixed ? SvxAuthorType::Fix : SvxAuthorType::Var);

                    if (!bIsFixed)

                    {

                        if (!bFullName)

                        {

                            pData->SetFormat(SvxAuthorFormat::ShortName);

                        }

                        else if (static_cast<SvxAuthorFormat>(nFmt) >= SvxAuthorFormat::FullName &&

                                 static_cast<SvxAuthorFormat>(nFmt) <= SvxAuthorFormat::ShortName)

                        {

                            pData->SetFormat(static_cast<SvxAuthorFormat>(nFmt));

                        }

                    }

                    return pData;

                }

            case text::textfield::Type::MEASURE:

                {

                    SdrMeasureFieldKind eKind = SdrMeasureFieldKind::Value;

                    sal_Int16 nTmp = -1;

                    xPropSet->getPropertyValue(UNO_TC_PROP_MEASURE_KIND) >>= nTmp;

                    if (nTmp == static_cast<sal_Int16>(SdrMeasureFieldKind::Unit) ||

                            nTmp == static_cast<sal_Int16>(SdrMeasureFieldKind::Rotate90Blanks))

                        eKind = static_cast<SdrMeasureFieldKind>(nTmp);

                    return new SdrMeasureField(eKind);

                }

            case text::textfield::Type::PRESENTATION_HEADER:

                return new SvxHeaderField();

            case text::textfield::Type::PRESENTATION_FOOTER:

                return new SvxFooterField();

            case text::textfield::Type::PRESENTATION_DATE_TIME:

                return new SvxDateTimeField();

            case text::textfield::Type::DOCINFO_CUSTOM:

                {

                    OUString sName;

                    xPropSet->getPropertyValue(UNO_TC_PROP_NAME) >>= sName;

                    OUString sCurrentPresentation;

                    xPropSet->getPropertyValue(UNO_TC_PROP_CURRENT_PRESENTATION) >>= sCurrentPresentation;

                    return new editeng::CustomPropertyField(sName, sCurrentPresentation);

                }

            default:

                ;

        };

    } catch ( const beans::UnknownPropertyException& )

    {

        return nullptr;

    }

    return nullptr;

}

SvxFieldData::SvxFieldData()

{

}

SvxFieldData::~SvxFieldData()

{

}

std::unique_ptr<SvxFieldData> SvxFieldData::Clone() const

{

    return std::make_unique<SvxFieldData>();

}

bool SvxFieldData::operator==( const SvxFieldData& rFld ) const

{

    DBG_ASSERT( typeid(*this) == typeid(rFld), "==: Different Types" );

    (void)rFld;

    return true;    // Basic class is always the same.

}

void SvxFieldData::dumpAsXml(xmlTextWriterPtr pWriter) const

{

    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SvxFieldData"));

    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("classId"), BAD_CAST(OString::number(GetClassId()).getStr()));

    (void)xmlTextWriterEndElement(pWriter);

}

SvxFieldItem::SvxFieldItem( std::unique_ptr<SvxFieldData> pField, const sal_uInt16 nId ) :

    SfxPoolItem( nId )

    , mpField( std::move(pField) )

{

}

SvxFieldItem::SvxFieldItem( const SvxFieldData& rField, const sal_uInt16 nId ) :

    SfxPoolItem( nId )

    , mpField( rField.Clone() )

{

}

SvxFieldItem::SvxFieldItem( const SvxFieldItem& rItem ) :

    SfxPoolItem ( rItem )

    , mpField( rItem.mpField ? rItem.mpField->Clone() : nullptr )

{

}

SvxFieldItem::~SvxFieldItem()

{

}

SvxFieldItem* SvxFieldItem::Clone( SfxItemPool* ) const

{

    return new SvxFieldItem(*this);

}

bool SvxFieldItem::operator==( const SfxPoolItem& rItem ) const

{

    assert(SfxPoolItem::operator==(rItem));

    const SvxFieldData* pOtherFld = static_cast<const SvxFieldItem&>(rItem).GetField();

    if( mpField.get() == pOtherFld )

        return true;

    if( mpField == nullptr || pOtherFld == nullptr )

        return false;

    return ( typeid(*mpField) == typeid(*pOtherFld) )

            && ( *mpField == *pOtherFld );

}

void SvxFieldItem::dumpAsXml(xmlTextWriterPtr pWriter) const

{

    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SvxFieldItem"));

    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));

    if (mpField)

        mpField->dumpAsXml(pWriter);

    (void)xmlTextWriterEndElement(pWriter);

}

// The following are the derivatives of SvxFieldData ...

SvxDateField::SvxDateField()

{

    nFixDate = Date( Date::SYSTEM ).GetDate();

    eType = SvxDateType::Var;

    eFormat = SvxDateFormat::StdSmall;

}

SvxDateField::SvxDateField( const Date& rDate, SvxDateType eT, SvxDateFormat eF )

{

    nFixDate = rDate.GetDate();

    eType = eT;

    eFormat = eF;

}

std::unique_ptr<SvxFieldData> SvxDateField::Clone() const

{

    return std::make_unique<SvxDateField>( *this );

}

bool SvxDateField::operator==( const SvxFieldData& rOther ) const

{

    if ( typeid(rOther) != typeid(*this) )

        return false;

    const SvxDateField& rOtherFld = static_cast<const SvxDateField&>(rOther);

    return ( ( nFixDate == rOtherFld.nFixDate ) &&

                ( eType == rOtherFld.eType ) &&

                ( eFormat == rOtherFld.eFormat ) );

}

OUString SvxDateField::GetFormatted( SvNumberFormatter& rFormatter, LanguageType eLang ) const

{

    Date aDate( Date::EMPTY );

    if ( eType == SvxDateType::Fix )

        aDate.SetDate( nFixDate );

    else

        aDate = Date( Date::SYSTEM ); // current date

    return GetFormatted( aDate, eFormat, rFormatter, eLang );

}

OUString SvxDateField::GetFormatted( Date const & aDate, SvxDateFormat eFormat, SvNumberFormatter& rFormatter, LanguageType eLang )

{

    if ( eFormat == SvxDateFormat::System )

    {

        OSL_FAIL( "SvxDateFormat::System not implemented!" );

        eFormat = SvxDateFormat::StdSmall;

    }

    else if ( eFormat == SvxDateFormat::AppDefault )

    {

        OSL_FAIL( "SvxDateFormat::AppDefault: take them from where? ");

        eFormat = SvxDateFormat::StdSmall;

    }

    sal_uInt32 nFormatKey;

    switch( eFormat )

    {

        case SvxDateFormat::StdSmall:

            // short

            nFormatKey = rFormatter.GetFormatIndex( NF_DATE_SYSTEM_SHORT, eLang );

        break;

        case SvxDateFormat::StdBig:

            // long

            nFormatKey = rFormatter.GetFormatIndex( NF_DATE_SYSTEM_LONG, eLang );

        break;

        case SvxDateFormat::A:

            // 13.02.96

            nFormatKey = rFormatter.GetFormatIndex( NF_DATE_SYS_DDMMYY, eLang );

        break;

        case SvxDateFormat::B:

            // 13.02.1996

            nFormatKey = rFormatter.GetFormatIndex( NF_DATE_SYS_DDMMYYYY, eLang );

        break;

        case SvxDateFormat::C:

            // 13. Feb 1996

            nFormatKey = rFormatter.GetFormatIndex( NF_DATE_SYS_DMMMYYYY, eLang );

        break;

        case SvxDateFormat::D:

            // 13. February 1996

            nFormatKey = rFormatter.GetFormatIndex( NF_DATE_SYS_DMMMMYYYY, eLang );

        break;

        case SvxDateFormat::E:

            // The, 13. February 1996

            nFormatKey = rFormatter.GetFormatIndex( NF_DATE_SYS_NNDMMMMYYYY, eLang );

        break;

        case SvxDateFormat::F:

            // Tuesday, 13. February 1996

            nFormatKey = rFormatter.GetFormatIndex( NF_DATE_SYS_NNNNDMMMMYYYY, eLang );

        break;

        default:

            nFormatKey = rFormatter.GetStandardFormat( SvNumFormatType::DATE, eLang );

    }

    double fDiffDate = aDate - rFormatter.GetNullDate();

    OUString aStr;

    const Color* pColor = nullptr;

    rFormatter.GetOutputString( fDiffDate, nFormatKey, aStr, &pColor );

    return aStr;

}

SvxURLField::SvxURLField()

{

    eFormat = SvxURLFormat::Url;

}

SvxURLField::SvxURLField( OUString _aURL, OUString aRepres, SvxURLFormat eFmt )

    : aURL(std::move( _aURL )), aRepresentation(std::move( aRepres ))

{

    eFormat = eFmt;

}

std::unique_ptr<SvxFieldData> SvxURLField::Clone() const

{

    return std::make_unique<SvxURLField>( *this );

}

bool SvxURLField::operator==( const SvxFieldData& rOther ) const

{

    if ( typeid(rOther) != typeid(*this) )

        return false;

    const SvxURLField& rOtherFld = static_cast<const SvxURLField&>(rOther);

    return ( ( eFormat == rOtherFld.eFormat ) &&

                ( aURL == rOtherFld.aURL ) &&

                ( aRepresentation == rOtherFld.aRepresentation ) &&

                ( aTargetFrame == rOtherFld.aTargetFrame ) );

}

void SvxURLField::dumpAsXml(xmlTextWriterPtr pWriter) const

{

    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SvxURLField"));

    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("classId"), BAD_CAST(OString::number(GetClassId()).getStr()));

    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("format"), BAD_CAST(OString::number(static_cast<int>(eFormat)).getStr()));

    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("url"), BAD_CAST(aURL.toUtf8().getStr()));

    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("representation"), BAD_CAST(aRepresentation.toUtf8().getStr()));

    (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("targetFrame"), BAD_CAST(aTargetFrame.toUtf8().getStr()));

    (void)xmlTextWriterEndElement(pWriter);

}

//

// SvxPageTitleField methods

//

SvxPageTitleField::SvxPageTitleField() {}

std::unique_ptr<SvxFieldData> SvxPageTitleField::Clone() const

{

    return std::make_unique<SvxPageTitleField>();

}

bool SvxPageTitleField::operator==( const SvxFieldData& rCmp ) const

{

    return ( dynamic_cast< const SvxPageTitleField *>(&rCmp) != nullptr );

}

//

// SvxPagesField

//

// The fields that were removed from Calc:

SvxPageField::SvxPageField() {}

std::unique_ptr<SvxFieldData> SvxPageField::Clone() const

{

    return std::make_unique<SvxPageField>();        // empty

}

bool SvxPageField::operator==( const SvxFieldData& rCmp ) const

{

    return ( dynamic_cast< const SvxPageField *>(&rCmp) != nullptr );

}

SvxPagesField::SvxPagesField() {}

std::unique_ptr<SvxFieldData> SvxPagesField::Clone() const

{

    return std::make_unique<SvxPagesField>();   // empty

}

bool SvxPagesField::operator==( const SvxFieldData& rCmp ) const

{

    return ( dynamic_cast< const SvxPagesField *>(&rCmp) != nullptr);

}

SvxTimeField::SvxTimeField() {}

std::unique_ptr<SvxFieldData> SvxTimeField::Clone() const

{

    return std::make_unique<SvxTimeField>();    // empty

}

bool SvxTimeField::operator==( const SvxFieldData& rCmp ) const

{

    return ( dynamic_cast< const SvxTimeField *>(&rCmp) != nullptr);

}

SvxFileField::SvxFileField() {}

std::unique_ptr<SvxFieldData> SvxFileField::Clone() const

{

    return std::make_unique<SvxFileField>();    // empty

}

bool SvxFileField::operator==( const SvxFieldData& rCmp ) const

{

    return ( dynamic_cast< const SvxFileField *>(&rCmp) != nullptr );

}

SvxTableField::SvxTableField() : mnTab(0) {}

SvxTableField::SvxTableField(int nTab) : mnTab(nTab) {}

void SvxTableField::SetTab(int nTab)

{

    mnTab = nTab;

}

std::unique_ptr<SvxFieldData> SvxTableField::Clone() const

{

    return std::make_unique<SvxTableField>(mnTab);

}

bool SvxTableField::operator==( const SvxFieldData& rCmp ) const

{

    if (dynamic_cast<const SvxTableField *>(&rCmp) == nullptr)

        return false;

    return mnTab == static_cast<const SvxTableField&>(rCmp).mnTab;

}

//      SvxExtTimeField

SvxExtTimeField::SvxExtTimeField()

    : m_nFixTime( tools::Time(tools::Time::SYSTEM).GetTime() )

{

    eType = SvxTimeType::Var;

    eFormat = SvxTimeFormat::Standard;

}

SvxExtTimeField::SvxExtTimeField( const tools::Time& rTime, SvxTimeType eT, SvxTimeFormat eF )

    : m_nFixTime( rTime.GetTime() )

{

    eType = eT;

    eFormat = eF;

}

std::unique_ptr<SvxFieldData> SvxExtTimeField::Clone() const

{

    return std::make_unique<SvxExtTimeField>( *this );

}

bool SvxExtTimeField::operator==( const SvxFieldData& rOther ) const

{

    if ( typeid(rOther) != typeid(*this) )

        return false;

    const SvxExtTimeField& rOtherFld = static_cast<const SvxExtTimeField&>(rOther);

    return ((m_nFixTime == rOtherFld.m_nFixTime) &&

                ( eType == rOtherFld.eType ) &&

                ( eFormat == rOtherFld.eFormat ) );

}

OUString SvxExtTimeField::GetFormatted( SvNumberFormatter& rFormatter, LanguageType eLang ) const

{

    tools::Time aTime(eType == SvxTimeType::Fix ? tools::Time::fromEncodedTime(m_nFixTime)

                                                : tools::Time(tools::Time::SYSTEM)); // current time

    return GetFormatted( aTime, eFormat, rFormatter, eLang );

}

OUString SvxExtTimeField::GetFormatted( tools::Time const & aTime, SvxTimeFormat eFormat, SvNumberFormatter& rFormatter, LanguageType eLang )

{

    switch( eFormat )

    {

        case SvxTimeFormat::System :

            OSL_FAIL( "SvxTimeFormat::System: not implemented" );

            eFormat = SvxTimeFormat::Standard;

        break;

        case SvxTimeFormat::AppDefault :

            OSL_FAIL( "SvxTimeFormat::AppDefault: not implemented" );

            eFormat = SvxTimeFormat::Standard;

        break;

        default: ;//prevent warning

    }

    sal_uInt32 nFormatKey;

    switch( eFormat )

    {

        case SvxTimeFormat::HH12_MM:

            nFormatKey = rFormatter.GetFormatIndex( NF_TIME_HHMMAMPM, eLang );

            break;

        case SvxTimeFormat::HH12_MM_SS_00:

        {

            // no builtin format available, try to insert or reuse

            OUString aFormatCode( u"HH:MM:SS.00 AM/PM"_ustr );

            sal_Int32 nCheckPos;

            SvNumFormatType nType;

            rFormatter.PutandConvertEntry( aFormatCode, nCheckPos, nType,

                                           nFormatKey, LANGUAGE_ENGLISH_US, eLang, true);

            DBG_ASSERT( nCheckPos == 0, "SvxTimeFormat::HH12_MM_SS_00: could not insert format code" );

            if ( nCheckPos )

            {

                nFormatKey = rFormatter.GetFormatIndex( NF_TIME_HH_MMSS00, eLang );

            }

            break;

        }

        case SvxTimeFormat::HH24_MM:

            nFormatKey = rFormatter.GetFormatIndex( NF_TIME_HHMM, eLang );

            break;

        case SvxTimeFormat::HH24_MM_SS_00:

            nFormatKey = rFormatter.GetFormatIndex( NF_TIME_HH_MMSS00, eLang );

            break;

        case SvxTimeFormat::HH12_MM_SS:

            nFormatKey = rFormatter.GetFormatIndex( NF_TIME_HHMMSSAMPM, eLang );

            break;

        case SvxTimeFormat::HH24_MM_SS:

            nFormatKey = rFormatter.GetFormatIndex( NF_TIME_HHMMSS, eLang );

            break;

        case SvxTimeFormat::Standard:

        default:

            nFormatKey = rFormatter.GetStandardFormat( SvNumFormatType::TIME, eLang );

    }

    double fFracTime = aTime.GetTimeInDays();

    OUString aStr;

    const Color* pColor = nullptr;

    rFormatter.GetOutputString( fFracTime, nFormatKey, aStr, &pColor );

    return aStr;

}

//      SvxExtFileField

SvxExtFileField::SvxExtFileField()

{

    eType = SvxFileType::Var;

    eFormat = SvxFileFormat::PathFull;

}

SvxExtFileField::SvxExtFileField( const OUString& rStr, SvxFileType eT, SvxFileFormat eF )

{

    aFile = rStr;

    eType = eT;

    eFormat = eF;

}

std::unique_ptr<SvxFieldData> SvxExtFileField::Clone() const

{

    return std::make_unique<SvxExtFileField>( *this );

}

bool SvxExtFileField::operator==( const SvxFieldData& rOther ) const

{

    if ( typeid(rOther) != typeid(*this) )

        return false;

    const SvxExtFileField& rOtherFld = static_cast<const SvxExtFileField&>(rOther);

    return ( ( aFile == rOtherFld.aFile ) &&

                ( eType == rOtherFld.eType ) &&

                ( eFormat == rOtherFld.eFormat ) );

}

OUString SvxExtFileField::GetFormatted() const

{

    OUString aString;

    INetURLObject aURLObj( aFile );

    if( INetProtocol::NotValid == aURLObj.GetProtocol() )

    {

        // invalid? try to interpret string as system file name

        OUString aURLStr;

        osl::FileBase::getFileURLFromSystemPath( aFile, aURLStr );

        aURLObj.SetURL( aURLStr );

    }

    // #92009# Be somewhat liberate when trying to

    // get formatted content out of the FileField

    if( INetProtocol::NotValid == aURLObj.GetProtocol() )

    {

        // still not valid? Then output as is

        aString = aFile;

    }

    else if( INetProtocol::File == aURLObj.GetProtocol() )

    {

        switch( eFormat )

        {

            case SvxFileFormat::PathFull:

                aString = aURLObj.getFSysPath(FSysStyle::Detect);

            break;

            case SvxFileFormat::PathOnly:

                aURLObj.removeSegment(INetURLObject::LAST_SEGMENT, false);

                // #101742# Leave trailing slash at the pathname

                aURLObj.setFinalSlash();

                aString = aURLObj.getFSysPath(FSysStyle::Detect);

            break;

            case SvxFileFormat::NameOnly:

                aString = aURLObj.getBase(INetURLObject::LAST_SEGMENT,true,INetURLObject::DecodeMechanism::Unambiguous);

            break;

            case SvxFileFormat::NameAndExt:

                aString = aURLObj.getName(INetURLObject::LAST_SEGMENT,true,INetURLObject::DecodeMechanism::Unambiguous);

            break;

        }

    }

    else

    {

        switch( eFormat )

        {

            case SvxFileFormat::PathFull:

                aString = aURLObj.GetMainURL( INetURLObject::DecodeMechanism::ToIUri );

            break;

            case SvxFileFormat::PathOnly:

                aURLObj.removeSegment(INetURLObject::LAST_SEGMENT, false);

                // #101742# Leave trailing slash at the pathname

                aURLObj.setFinalSlash();

                aString = aURLObj.GetMainURL( INetURLObject::DecodeMechanism::ToIUri );

            break;

            case SvxFileFormat::NameOnly:

                aString = aURLObj.getBase();

            break;

            case SvxFileFormat::NameAndExt:

                aString = aURLObj.getName();

            break;

        }

    }

    return aString;

}

//      SvxAuthorField

SvxAuthorField::SvxAuthorField( const OUString& rFirstName,

                                const OUString& rLastName,

                                const OUString& rShortName,

                                    SvxAuthorType eT, SvxAuthorFormat eF )

{

    aName      = rLastName;

    aFirstName = rFirstName;

    aShortName = rShortName;

    eType   = eT;

    eFormat = eF;

}

std::unique_ptr<SvxFieldData> SvxAuthorField::Clone() const

{

    return std::make_unique<SvxAuthorField>( *this );

}

bool SvxAuthorField::operator==( const SvxFieldData& rOther ) const

{

    if ( typeid(rOther) != typeid(*this) )

        return false;

    const SvxAuthorField& rOtherFld = static_cast<const SvxAuthorField&>(rOther);

    return ( ( aName == rOtherFld.aName ) &&

                ( aFirstName == rOtherFld.aFirstName ) &&

                ( aShortName == rOtherFld.aShortName ) &&

                ( eType == rOtherFld.eType ) &&

                ( eFormat == rOtherFld.eFormat ) );

}

OUString SvxAuthorField::GetFormatted() const

{

    OUString aString;

    switch( eFormat )

    {

        case SvxAuthorFormat::FullName:

            aString = aFirstName + " " + aName;

        break;

        case SvxAuthorFormat::LastName:

            aString = aName;

        break;

        case SvxAuthorFormat::FirstName:

            aString = aFirstName;

        break;

        case SvxAuthorFormat::ShortName:

            aString = aShortName;

        break;

    }

    return aString;

}

SvxHeaderField::SvxHeaderField() {}

std::unique_ptr<SvxFieldData> SvxHeaderField::Clone() const

{

    return std::make_unique<SvxHeaderField>();      // empty

}

bool SvxHeaderField::operator==( const SvxFieldData& rCmp ) const

{

    return ( dynamic_cast< const SvxHeaderField *>(&rCmp) != nullptr );

}

SvxFooterField::SvxFooterField() {}

std::unique_ptr<SvxFieldData> SvxFooterField::Clone() const

{

    return std::make_unique<SvxFooterField>();      // empty

}

bool SvxFooterField::operator==( const SvxFieldData& rCmp ) const

{

    return ( dynamic_cast< const SvxFooterField *>(&rCmp) != nullptr );

}

std::unique_ptr<SvxFieldData> SvxDateTimeField::Clone() const

{

    return std::make_unique<SvxDateTimeField>();        // empty

}

bool SvxDateTimeField::operator==( const SvxFieldData& rCmp ) const

{

    return ( dynamic_cast< const SvxDateTimeField *>(&rCmp) != nullptr );

}

SvxDateTimeField::SvxDateTimeField() {}

OUString SvxDateTimeField::GetFormatted(

    Date const & rDate, tools::Time const & rTime,

    SvxDateFormat eDateFormat, SvxTimeFormat eTimeFormat,

    SvNumberFormatter& rFormatter, LanguageType eLanguage )

{

    OUString aRet;

    if(eDateFormat != SvxDateFormat::AppDefault)

    {

        aRet = SvxDateField::GetFormatted( rDate, eDateFormat, rFormatter, eLanguage );

    }

    if(eTimeFormat != SvxTimeFormat::AppDefault)

    {

        OUStringBuffer aBuf(aRet);

        if (!aRet.isEmpty())

            aBuf.append(' ');

        aBuf.append(

            SvxExtTimeField::GetFormatted(rTime, eTimeFormat, rFormatter, eLanguage));

        aRet = aBuf.makeStringAndClear();

    }

    return aRet;

}

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */