xref: /aoo41x/main/sw/source/ui/fldui/fldmgr.cxx (revision dec99bbd)

/**************************************************************
 *
 * 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
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sw.hxx"

#include <cmdid.h>
#include <hintids.hxx>
#include <svl/stritem.hxx>
#include <com/sun/star/lang/XMultiServiceFactory.hpp>
#include <com/sun/star/container/XNameAccess.hpp>
#include <com/sun/star/text/XDefaultNumberingProvider.hpp>
#include <com/sun/star/text/XNumberingTypeInfo.hpp>
#include <com/sun/star/style/NumberingType.hpp>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <com/sun/star/sdbc/XConnection.hpp>
#include <com/sun/star/sdbc/XDataSource.hpp>
#include <com/sun/star/uri/XUriReferenceFactory.hpp>
#include <com/sun/star/uri/XVndSunStarScriptUrl.hpp>
#include <comphelper/processfactory.hxx>
#include <editeng/unolingu.hxx>
#include <unotools/localedatawrapper.hxx>
#include <sfx2/dispatch.hxx>
#include <sfx2/objsh.hxx>
#include <sfx2/linkmgr.hxx>
#include <sfx2/app.hxx>
#include <basic/basmgr.hxx>
#include <editeng/langitem.hxx>
#include <svl/macitem.hxx>
#include <basic/sbmod.hxx>
#include <fmtrfmrk.hxx>
#include <basic/sbmeth.hxx>
#include <basic/sbx.hxx>
#include <svl/zforlist.hxx>
#include <svl/zformat.hxx>
#include <vcl/mnemonic.hxx>
#include <view.hxx>
#include <wrtsh.hxx>		// Actives Fenster
#include <doc.hxx>		// Actives Fenster
#include <docsh.hxx>		// Actives Fenster
#include <swmodule.hxx>
#include <charatr.hxx>
#include <fmtinfmt.hxx>
#include <cellatr.hxx>
#include <dbmgr.hxx>
#include <shellres.hxx>
#include <fldbas.hxx>
#include <docufld.hxx>
#include <chpfld.hxx>
#include <ddefld.hxx>
#include <expfld.hxx>
#include <reffld.hxx>
#include <usrfld.hxx>
#include <dbfld.hxx>
#include <authfld.hxx>
#include <flddat.hxx>
#include <fldmgr.hxx>
#include <crsskip.hxx>
#include <flddropdown.hxx>
#include <fldui.hrc>
#include <tox.hxx>

using rtl::OUString;
using namespace com::sun::star::uno;
using namespace com::sun::star::container;
using namespace com::sun::star::lang;
using namespace com::sun::star::beans;
using namespace com::sun::star::text;
using namespace com::sun::star::style;
using namespace com::sun::star::sdbc;
using namespace ::com::sun::star;
using namespace nsSwDocInfoSubType;

/*--------------------------------------------------------------------
	Beschreibung: Gruppen der Felder
 --------------------------------------------------------------------*/
enum
{
	GRP_DOC_BEGIN	=  0,
	GRP_DOC_END   	=  GRP_DOC_BEGIN + 11,

	GRP_FKT_BEGIN 	=  GRP_DOC_END,
    GRP_FKT_END     =  GRP_FKT_BEGIN + 8,

	GRP_REF_BEGIN 	=  GRP_FKT_END,
	GRP_REF_END   	=  GRP_REF_BEGIN + 2,

	GRP_REG_BEGIN 	=  GRP_REF_END,
	GRP_REG_END     =  GRP_REG_BEGIN + 1,

	GRP_DB_BEGIN  	=  GRP_REG_END,
	GRP_DB_END    	=  GRP_DB_BEGIN  + 5,

	GRP_VAR_BEGIN 	=  GRP_DB_END,
	GRP_VAR_END   	=  GRP_VAR_BEGIN + 9
};

enum
{
	GRP_WEB_DOC_BEGIN	=  0,
	GRP_WEB_DOC_END   	=  GRP_WEB_DOC_BEGIN + 9,

	GRP_WEB_FKT_BEGIN 	=  GRP_WEB_DOC_END + 2,
	GRP_WEB_FKT_END   	=  GRP_WEB_FKT_BEGIN + 0,	// Die Gruppe ist leer!

	GRP_WEB_REF_BEGIN 	=  GRP_WEB_FKT_END + 6,		// Die Gruppe ist leer!
	GRP_WEB_REF_END   	=  GRP_WEB_REF_BEGIN + 0,

	GRP_WEB_REG_BEGIN 	=  GRP_WEB_REF_END + 2,
	GRP_WEB_REG_END     =  GRP_WEB_REG_BEGIN + 1,

	GRP_WEB_DB_BEGIN  	=  GRP_WEB_REG_END,			// Die Gruppe ist leer!
	GRP_WEB_DB_END    	=  GRP_WEB_DB_BEGIN  + 0,

	GRP_WEB_VAR_BEGIN 	=  GRP_WEB_DB_END + 5,
	GRP_WEB_VAR_END   	=  GRP_WEB_VAR_BEGIN + 1
};

/*--------------------------------------------------------------------
	Beschreibung: Formate in der richtigen Reihenfolge
 --------------------------------------------------------------------*/
static const sal_uInt16 __FAR_DATA aSetFmt[] =
{
// die Reihenfolge muss zu Beginn mit den ResourceIds fuer FMT_SETVAR_???
// uebereinstimmen
	0,
	0
};

static const sal_uInt16 __FAR_DATA aGetFmt[] =
{
// die Reihenfolge muss zu Beginn mit den ResourceIds fuer FMT_GETVAR_???
// uebereinstimmen
	0
};

static const sal_uInt16 __FAR_DATA aUsrFmt[] =
{
// die Reihenfolge muss zu Beginn mit den ResourceIds fuer FMT_SETVAR_???
// uebereinstimmen
	0,
	nsSwExtendedSubType::SUB_CMD
};

static const sal_uInt16 __FAR_DATA aDBFmt[] =
{
// die Reihenfolge muss zu Beginn mit den ResourceIds fuer FMT_DBFLD_???
// uebereinstimmen
	nsSwExtendedSubType::SUB_OWN_FMT
};

static const sal_uInt16 VF_COUNT		= sizeof(aGetFmt) / sizeof(sal_uInt16);
static const sal_uInt16 VF_USR_COUNT	= sizeof(aUsrFmt) / sizeof(sal_uInt16);
static const sal_uInt16 VF_DB_COUNT		= sizeof(aDBFmt)  / sizeof(sal_uInt16);

/*--------------------------------------------------------------------
	Beschreibung: Feldtypen und Subtypes
 --------------------------------------------------------------------*/
struct SwFldPack
{
	sal_uInt16  nTypeId;

	sal_uInt16	nSubTypeStart;
	sal_uInt16  nSubTypeEnd;

	sal_uLong	nFmtBegin;
	sal_uLong	nFmtEnd;
};

/*--------------------------------------------------------------------
	Beschreibung: Strings und Formate
 --------------------------------------------------------------------*/
static const SwFldPack __FAR_DATA aSwFlds[] =
{
	// Dokument
	{ TYP_EXTUSERFLD,	 	FLD_EU_BEGIN,	 	FLD_EU_END,	    0,     				0 },
	{ TYP_AUTHORFLD,	 	0,					0,				FMT_AUTHOR_BEGIN,	FMT_AUTHOR_END },
	{ TYP_DATEFLD,			FLD_DATE_BEGIN,		FLD_DATE_END,	0,					0 },
	{ TYP_TIMEFLD,			FLD_TIME_BEGIN,		FLD_TIME_END,	0,					0 },
	{ TYP_PAGENUMBERFLD,	0,					0,				FMT_NUM_BEGIN,   	FMT_NUM_END-1 },
	{ TYP_NEXTPAGEFLD,		0,					0,				FMT_NUM_BEGIN,		FMT_NUM_END },
	{ TYP_PREVPAGEFLD,		0,					0,				FMT_NUM_BEGIN,		FMT_NUM_END },
	{ TYP_FILENAMEFLD,		0,					0,				FMT_FF_BEGIN,    	FMT_FF_END },
	{ TYP_DOCSTATFLD,	 	FLD_STAT_BEGIN,		FLD_STAT_END,	FMT_NUM_BEGIN,		FMT_NUM_END-1 },

	{ TYP_CHAPTERFLD,	 	0,					0,				FMT_CHAPTER_BEGIN, 	FMT_CHAPTER_END },
	{ TYP_TEMPLNAMEFLD,		0,					0,				FMT_FF_BEGIN,    	FMT_FF_END },

	// Funktion
	{ TYP_CONDTXTFLD,	 	0,					0,				0,					0 },
    { TYP_DROPDOWN,       	0,                  0,              0,                  0 },
	{ TYP_INPUTFLD,			FLD_INPUT_BEGIN,	FLD_INPUT_END,	0,   				0 },
	{ TYP_MACROFLD,			0,					0,				0,					0 },
	{ TYP_JUMPEDITFLD, 		0,					0,				FMT_MARK_BEGIN,		FMT_MARK_END },
	{ TYP_COMBINED_CHARS,	0,					0,				0,					0 },
	{ TYP_HIDDENTXTFLD,		0,					0,				0,					0 },
	{ TYP_HIDDENPARAFLD, 	0,			   		0,				0,					0 },

	// Referenzen
	{ TYP_SETREFFLD,	 	0,					0,				0,					0 },
	{ TYP_GETREFFLD,	 	0,					0,				FMT_REF_BEGIN,		FMT_REF_END },

	// Ablage
	{ TYP_DOCINFOFLD,	 	0,					0,				FMT_REG_BEGIN, 		FMT_REG_END },

	// Datenbank
	{ TYP_DBFLD,		 	0,					0,				FMT_DBFLD_BEGIN,	FMT_DBFLD_END },
	{ TYP_DBNEXTSETFLD,		0,					0,				0,					0 },
	{ TYP_DBNUMSETFLD,		0,					0,				0,					0 },
	{ TYP_DBSETNUMBERFLD, 	0,					0,				FMT_NUM_BEGIN,	    FMT_NUM_END-2 },
	{ TYP_DBNAMEFLD, 	 	0,					0,				0,					0 },

	// Variablen
	{ TYP_SETFLD,		 	0,					0,				FMT_SETVAR_BEGIN,   FMT_SETVAR_END },

	{ TYP_GETFLD,		 	0,					0, 				FMT_GETVAR_BEGIN,	FMT_GETVAR_END },
	{ TYP_DDEFLD,		 	0,					0,				FMT_DDE_BEGIN, 		FMT_DDE_END },
	{ TYP_FORMELFLD,  		0,					0,				FMT_GETVAR_BEGIN,	FMT_GETVAR_END },
	{ TYP_INPUTFLD,			FLD_INPUT_BEGIN,	FLD_INPUT_END,	0,   				0 },
	{ TYP_SEQFLD,		 	0,					0,				FMT_NUM_BEGIN,		FMT_NUM_END-2 },
	{ TYP_SETREFPAGEFLD,	FLD_PAGEREF_BEGIN,	FLD_PAGEREF_END,0,   				0 },
	{ TYP_GETREFPAGEFLD,	0,					0,				FMT_NUM_BEGIN,   	FMT_NUM_END-1 },
	{ TYP_USERFLD,			0,					0,				FMT_USERVAR_BEGIN,	FMT_USERVAR_END }
};

/*--------------------------------------------------------------------
	Beschreibung: Zugriff auf die Shell
 --------------------------------------------------------------------*/

static SwWrtShell* lcl_GetShell()
{
	SwView* pView;
	if ( 0 != (pView = ::GetActiveView()) )
		return pView->GetWrtShellPtr();
	DBG_ERROR("no current shell found!");
	return 0;
}

inline sal_uInt16 GetPackCount() {	return sizeof(aSwFlds) / sizeof(SwFldPack); }

/*--------------------------------------------------------------------
	Beschreibung: FieldManager regelt das Einfuegen und Updaten
				  von Feldern
 --------------------------------------------------------------------*/

SwFldMgr::SwFldMgr(SwWrtShell* pSh ) :
	pModule(0),
	pMacroItem(0),
    pWrtShell(pSh),
    bEvalExp(sal_True)
{
	// aktuelles Feld ermitteln falls vorhanden
	GetCurFld();
}


SwFldMgr::~SwFldMgr()
{
}

/*--------------------------------------------------------------------
	Beschreibung: RefMark ueber Namen organisieren
 --------------------------------------------------------------------*/

sal_Bool  SwFldMgr::CanInsertRefMark( const String& rStr )
{
    sal_Bool bRet = sal_False;
    SwWrtShell *pSh = pWrtShell ? pWrtShell : lcl_GetShell();
    DBG_ASSERT(pSh, "no SwWrtShell found");
    if(pSh)
    {
        sal_uInt16 nCnt = pSh->GetCrsrCnt();

        // der letzte Crsr muss keine aufgespannte Selektion
        if( 1 < nCnt && !pSh->SwCrsrShell::HasSelection() )
            --nCnt;

        bRet =  2 > nCnt && 0 == pSh->GetRefMark( rStr );
    }
    return bRet;
}

/*--------------------------------------------------------------------
	Beschreibung: Zugriff ueber ResIds
 --------------------------------------------------------------------*/

void SwFldMgr::RemoveFldType(sal_uInt16 nResId, const String& rName )
{
    SwWrtShell * pSh = pWrtShell ? pWrtShell : lcl_GetShell();
    DBG_ASSERT(pSh, "no SwWrtShell found");
    if( pSh )
        pSh->RemoveFldType(nResId, rName);
}

sal_uInt16 SwFldMgr::GetFldTypeCount(sal_uInt16 nResId) const
{
    SwWrtShell * pSh = pWrtShell ? pWrtShell : lcl_GetShell();
    DBG_ASSERT(pSh, "no SwWrtShell found");
    return pSh ? pSh->GetFldTypeCount(nResId) : 0;
}


SwFieldType* SwFldMgr::GetFldType(sal_uInt16 nResId, sal_uInt16 nId) const
{
    SwWrtShell * pSh = pWrtShell ? pWrtShell : lcl_GetShell();
    DBG_ASSERT(pSh, "no SwWrtShell found");
    return pSh ? pSh->GetFldType(nId, nResId) : 0;
}


SwFieldType* SwFldMgr::GetFldType(sal_uInt16 nResId, const String& rName) const
{
    SwWrtShell * pSh = pWrtShell ? pWrtShell : lcl_GetShell();
    DBG_ASSERT(pSh, "no SwWrtShell found");
    return pSh ? pSh->GetFldType(nResId, rName) : 0;
}


/*--------------------------------------------------------------------
	Beschreibung: Aktuelles Feld ermitteln
 --------------------------------------------------------------------*/
SwField* SwFldMgr::GetCurFld()
{
	SwWrtShell *pSh = pWrtShell ? pWrtShell : ::lcl_GetShell();
	if ( pSh )
		pCurFld = pSh->GetCurFld( true );
	else
		pCurFld = NULL;

	// Strings und Format initialisieren
	//
	aCurPar1.Erase();
	aCurPar2.Erase();
	sCurFrame.Erase();
	nCurFmt = 0;

	if(!pCurFld)
		return 0;

	// Aktuelle Werte aufbereiten Parameter 1 und Parameter 2
	// als auch das Format ermitteln
	//
	const sal_uInt16 nTypeId = pCurFld->GetTypeId();

	nCurFmt  	= pCurFld->GetFormat();
	aCurPar1 	= pCurFld->GetPar1();
	aCurPar2 	= pCurFld->GetPar2();

	switch( nTypeId )
	{
		case TYP_PAGENUMBERFLD:
		case TYP_NEXTPAGEFLD:
		case TYP_PREVPAGEFLD:
		case TYP_GETREFPAGEFLD:
			if( nCurFmt == SVX_NUM_PAGEDESC )
				nCurFmt -= 2;
			break;
	}
	return pCurFld;
}

/*--------------------------------------------------------------------
	Beschreibung: Gruppen-Bereich liefern
 --------------------------------------------------------------------*/


const SwFldGroupRgn& SwFldMgr::GetGroupRange(sal_Bool bHtmlMode, sal_uInt16 nGrpId) const
{
static SwFldGroupRgn __READONLY_DATA aRanges[] =
{
	{ /* Dokument	*/ 	GRP_DOC_BEGIN, 	GRP_DOC_END },
	{ /* Funktionen	*/ 	GRP_FKT_BEGIN,  GRP_FKT_END },
	{ /* Referenzen	*/ 	GRP_REF_BEGIN,  GRP_REF_END },
	{ /* Ablage		*/ 	GRP_REG_BEGIN,  GRP_REG_END },
	{ /* DB			*/	GRP_DB_BEGIN,	GRP_DB_END },
	{ /* User		*/	GRP_VAR_BEGIN,	GRP_VAR_END }
};
static SwFldGroupRgn __READONLY_DATA aWebRanges[] =
{
	{ /* Dokument	*/ 	GRP_WEB_DOC_BEGIN, 	GRP_WEB_DOC_END },
	{ /* Funktionen	*/ 	GRP_WEB_FKT_BEGIN,  GRP_WEB_FKT_END },
	{ /* Referenzen	*/ 	GRP_WEB_REF_BEGIN,  GRP_WEB_REF_END },
	{ /* Ablage		*/ 	GRP_WEB_REG_BEGIN,  GRP_WEB_REG_END },
	{ /* DB			*/	GRP_WEB_DB_BEGIN,	GRP_WEB_DB_END },
	{ /* User		*/	GRP_WEB_VAR_BEGIN,	GRP_WEB_VAR_END }
};

	if (bHtmlMode)
		return aWebRanges[(sal_uInt16)nGrpId];
	else
		return aRanges[(sal_uInt16)nGrpId];
}

/*--------------------------------------------------------------------
	Beschreibung: GroupId bestimmen
 --------------------------------------------------------------------*/

sal_uInt16 SwFldMgr::GetGroup(sal_Bool bHtmlMode, sal_uInt16 nTypeId, sal_uInt16 nSubType) const
{
	if (nTypeId == TYP_SETINPFLD)
		nTypeId = TYP_SETFLD;

	if (nTypeId == TYP_INPUTFLD && (nSubType & INP_USR))
		nTypeId = TYP_USERFLD;

	if (nTypeId == TYP_FIXDATEFLD)
		nTypeId = TYP_DATEFLD;

	if (nTypeId == TYP_FIXTIMEFLD)
		nTypeId = TYP_TIMEFLD;

	for (sal_uInt16 i = GRP_DOC; i <= GRP_VAR; i++)
	{
		const SwFldGroupRgn& rRange = GetGroupRange(bHtmlMode, i);
		for (sal_uInt16 nPos = rRange.nStart; nPos < rRange.nEnd; nPos++)
		{
			if (aSwFlds[nPos].nTypeId == nTypeId)
				return i;
		}
	}
	return USHRT_MAX;
}

/*--------------------------------------------------------------------
	Beschreibung: Namen zur TypeId ermitteln
				  ZUGRIFF ueber TYP_....
 --------------------------------------------------------------------*/


sal_uInt16 SwFldMgr::GetTypeId(sal_uInt16 nPos)
{
	ASSERT(nPos < ::GetPackCount(), "unzulaessige Pos");
	return aSwFlds[ nPos ].nTypeId;
}


const String& SwFldMgr::GetTypeStr(sal_uInt16 nPos)
{
	ASSERT(nPos < ::GetPackCount(), "unzulaessige TypeId");

	sal_uInt16 nFldWh = aSwFlds[ nPos ].nTypeId;

	// Sonderbehandlung fuer Datum/Zeit Felder (ohne var/fix)
	if( TYP_DATEFLD == nFldWh )
	{
		static String g_aDate( SW_RES( STR_DATEFLD ) );
		return g_aDate;
	}
	if( TYP_TIMEFLD == nFldWh )
	{
		static String g_aTime( SW_RES( STR_TIMEFLD ) );
		return g_aTime;
	}

	return SwFieldType::GetTypeStr( nFldWh );
}

/*--------------------------------------------------------------------
	Beschreibung: Pos in der Liste bestimmen
 --------------------------------------------------------------------*/


sal_uInt16 SwFldMgr::GetPos(sal_uInt16 nTypeId)
{
	switch( nTypeId )
	{
		case TYP_FIXDATEFLD:		nTypeId = TYP_DATEFLD;		break;
		case TYP_FIXTIMEFLD:      	nTypeId = TYP_TIMEFLD;		break;
		case TYP_SETINPFLD:      	nTypeId = TYP_SETFLD;		break;
		case TYP_USRINPFLD:      	nTypeId = TYP_USERFLD;		break;
	}

	for(sal_uInt16 i = 0; i < GetPackCount(); i++)
		if(aSwFlds[i].nTypeId == nTypeId)
			return i;

	return USHRT_MAX;
}

/*--------------------------------------------------------------------
	Beschreibung: Subtypen eines Feldes lokalisieren
 --------------------------------------------------------------------*/

sal_Bool SwFldMgr::GetSubTypes(sal_uInt16 nTypeId, SvStringsDtor& rToFill)
{
    sal_Bool bRet = sal_False;
    SwWrtShell *pSh = pWrtShell ? pWrtShell : lcl_GetShell();
    DBG_ASSERT(pSh, "no SwWrtShell found");
    if(pSh)
    {
        const sal_uInt16 nPos = GetPos(nTypeId);

        switch(nTypeId)
        {
            case TYP_SETREFFLD:
            case TYP_GETREFFLD:
            {
                // Referenzen sind keine Felder
                pSh->GetRefMarks( &rToFill );
                break;
            }
            case TYP_MACROFLD:
            {
                break;
            }
            case TYP_INPUTFLD:
            {   String* pNew = new SW_RESSTR(aSwFlds[nPos].nSubTypeStart);
                rToFill.Insert(pNew, rToFill.Count());
                // Weiter bei generischen Typen
            }
            case TYP_DDEFLD:
            case TYP_SEQFLD:
            case TYP_FORMELFLD:
            case TYP_GETFLD:
            case TYP_SETFLD:
            case TYP_USERFLD:
            {

                const sal_uInt16 nCount = pSh->GetFldTypeCount();
                for(sal_uInt16 i = 0; i < nCount; ++i)
                {
                    SwFieldType* pFldType = pSh->GetFldType( i );
                    const sal_uInt16 nWhich = pFldType->Which();

                    if((nTypeId == TYP_DDEFLD && pFldType->Which() == RES_DDEFLD) ||

                       (nTypeId == TYP_USERFLD && nWhich == RES_USERFLD) ||

                       (nTypeId == TYP_GETFLD && nWhich == RES_SETEXPFLD &&
                        !(((SwSetExpFieldType*)pFldType)->GetType() & nsSwGetSetExpType::GSE_SEQ)) ||

                       (nTypeId == TYP_SETFLD && nWhich == RES_SETEXPFLD &&
                        !(((SwSetExpFieldType*)pFldType)->GetType() & nsSwGetSetExpType::GSE_SEQ)) ||

                       (nTypeId == TYP_SEQFLD && nWhich == RES_SETEXPFLD  &&
                       (((SwSetExpFieldType*)pFldType)->GetType() & nsSwGetSetExpType::GSE_SEQ)) ||

                       ((nTypeId == TYP_INPUTFLD || nTypeId == TYP_FORMELFLD) &&
                         (nWhich == RES_USERFLD ||
                          (nWhich == RES_SETEXPFLD &&
                          !(((SwSetExpFieldType*)pFldType)->GetType() & nsSwGetSetExpType::GSE_SEQ))) ) )
                    {
                        String* pNew = new String(pFldType->GetName());
                        rToFill.Insert(pNew, rToFill.Count());
                    }
                }
                break;
            }
            case TYP_DBNEXTSETFLD:
            case TYP_DBNUMSETFLD:
            case TYP_DBNAMEFLD:
            case TYP_DBSETNUMBERFLD:
                break;

            default:
            {
                // statische SubTypes
                if(nPos != USHRT_MAX)
                {
                    sal_uInt16 nCount;
                    if (nTypeId == TYP_DOCINFOFLD)
                        nCount = DI_SUBTYPE_END - DI_SUBTYPE_BEGIN;
                    else
                        nCount = aSwFlds[nPos].nSubTypeEnd - aSwFlds[nPos].nSubTypeStart;

                    for(sal_uInt16 i = 0; i < nCount; ++i)
                    {
                        String* pNew;
                        if (nTypeId == TYP_DOCINFOFLD)
                        {
                            if ( i == DI_CUSTOM )
                                pNew = new String( String(SW_RES( STR_CUSTOM )) );
							else
                                pNew = new String(*ViewShell::GetShellRes()->aDocInfoLst[i]);
                        }
                        else
                            pNew = new SW_RESSTR(aSwFlds[nPos].nSubTypeStart + i);

                        rToFill.Insert(pNew, rToFill.Count());
                    }
                }
            }
        }
        bRet = sal_True;
    }
    return bRet;
}

/*--------------------------------------------------------------------
	Beschreibung: Format ermitteln
				  ZUGRIFF ueber TYP_....
 --------------------------------------------------------------------*/


sal_uInt16 SwFldMgr::GetFormatCount(sal_uInt16 nTypeId, sal_Bool bIsText, sal_Bool bHtmlMode) const
{
	ASSERT(nTypeId < TYP_END, "unzulaessige TypeId");

	{
		const sal_uInt16 nPos = GetPos(nTypeId);

		if(nPos == USHRT_MAX || (bHtmlMode && nTypeId == TYP_SETFLD))
			return 0;

		sal_uLong nStart = aSwFlds[nPos].nFmtBegin;
		sal_uLong nEnd   = aSwFlds[nPos].nFmtEnd;

		if (bIsText && nEnd - nStart >= 2)
			return 2;

		if (nTypeId == TYP_FILENAMEFLD)
			nEnd -= 2;	// Kein Bereich oder Vorlage

		switch(nStart)
		{
			case FMT_GETVAR_BEGIN:
			case FMT_SETVAR_BEGIN:	return VF_COUNT;
			case FMT_USERVAR_BEGIN:	return VF_USR_COUNT;
			case FMT_DBFLD_BEGIN:	return VF_DB_COUNT;
			case FMT_NUM_BEGIN:
			{
				sal_uInt16 nCount = (sal_uInt16)(nEnd - nStart);
				GetNumberingInfo();
                if(xNumberingInfo.is())
				{
					Sequence<sal_Int16> aTypes = xNumberingInfo->getSupportedNumberingTypes();
					const sal_Int16* pTypes = aTypes.getConstArray();
					for(sal_Int32 nType = 0; nType < aTypes.getLength(); nType++)
					{
						sal_Int16 nCurrent = pTypes[nType];
						//skip all values below or equal to CHARS_LOWER_LETTER_N
						if(nCurrent > NumberingType::CHARS_LOWER_LETTER_N)
						{
                            // #i28073# it's not necessarily a sorted sequence
                            ++nCount;
						}
					}
				}
				return nCount;
			}

		}
		return (sal_uInt16)(nEnd - nStart);
	}
}

/*--------------------------------------------------------------------
	Beschreibung:	FormatString zu einem Typ ermitteln
 --------------------------------------------------------------------*/


String SwFldMgr::GetFormatStr(sal_uInt16 nTypeId, sal_uLong nFormatId) const
{
	String aRet;
	ASSERT(nTypeId < TYP_END, "unzulaessige TypeId");

	const sal_uInt16 nPos = GetPos(nTypeId);

	if(nPos == USHRT_MAX)
		return aRet;

	sal_uLong nStart;

	nStart = aSwFlds[nPos].nFmtBegin;

	if (TYP_AUTHORFLD == nTypeId|| TYP_FILENAMEFLD == nTypeId)
		nFormatId &= ~FF_FIXED;		// Fixed-Flag ausmaskieren

	if((nStart + nFormatId) < aSwFlds[nPos].nFmtEnd)
		aRet = SW_RESSTR((sal_uInt16)(nStart + nFormatId));
	else if( FMT_NUM_BEGIN == nStart)
	{
		if(xNumberingInfo.is())
		{
			Sequence<sal_Int16> aTypes = xNumberingInfo->getSupportedNumberingTypes();
			const sal_Int16* pTypes = aTypes.getConstArray();
            sal_Int32 nOffset = aSwFlds[nPos].nFmtEnd - nStart;
            sal_Int32 nValidEntry = 0;
            for(sal_Int32 nType = 0; nType < aTypes.getLength(); nType++)
			{
				sal_Int16 nCurrent = pTypes[nType];
				if(nCurrent > NumberingType::CHARS_LOWER_LETTER_N)
				{
                    if(nValidEntry == ((sal_Int32)nFormatId) - nOffset)
                    {
                        aRet = xNumberingInfo->getNumberingIdentifier( pTypes[nType] );
                        break;
                    }
                    ++nValidEntry;
				}
			}
		}
	}

	return aRet;
}

/*--------------------------------------------------------------------
	Beschreibung:	FormatId aus Pseudo-ID ermitteln
 --------------------------------------------------------------------*/

sal_uInt16 SwFldMgr::GetFormatId(sal_uInt16 nTypeId, sal_uLong nFormatId) const
{
	sal_uInt16 nId = (sal_uInt16)nFormatId;

	switch( nTypeId )
	{
	case TYP_DOCINFOFLD:
		switch( aSwFlds[ GetPos( nTypeId ) ].nFmtBegin + nFormatId )
		{
		case FMT_REG_AUTHOR:	nId = DI_SUB_AUTHOR;	break;
		case FMT_REG_TIME:		nId = DI_SUB_TIME;		break;
		case FMT_REG_DATE:		nId = DI_SUB_DATE;		break;
		}
		break;

	case TYP_PAGENUMBERFLD:
	case TYP_NEXTPAGEFLD:
	case TYP_PREVPAGEFLD:
	case TYP_DOCSTATFLD:
	case TYP_DBSETNUMBERFLD:
	case TYP_SEQFLD:
	case TYP_GETREFPAGEFLD:
	{
		sal_uInt16 nPos = GetPos( nTypeId );
		sal_uLong nBegin = aSwFlds[ nPos ].nFmtBegin;
		sal_uLong nEnd = aSwFlds[nPos].nFmtEnd;
		if((nBegin + nFormatId) < nEnd)
		{
			switch( nBegin + nFormatId )
			{
			case FMT_NUM_ABC:				nId = SVX_NUM_CHARS_UPPER_LETTER;	break;
			case FMT_NUM_SABC:				nId = SVX_NUM_CHARS_LOWER_LETTER;	break;
			case FMT_NUM_ROMAN:             nId = SVX_NUM_ROMAN_UPPER;			break;
			case FMT_NUM_SROMAN:			nId = SVX_NUM_ROMAN_LOWER;			break;
			case FMT_NUM_ARABIC:            nId = SVX_NUM_ARABIC;				break;
			case FMT_NUM_PAGEDESC: 			nId = SVX_NUM_PAGEDESC; 			break;
			case FMT_NUM_PAGESPECIAL:		nId = SVX_NUM_CHAR_SPECIAL;			break;
			case FMT_NUM_ABC_N:				nId = SVX_NUM_CHARS_UPPER_LETTER_N; break;
			case FMT_NUM_SABC_N:			nId = SVX_NUM_CHARS_LOWER_LETTER_N;	break;
			}
		}
		else if(xNumberingInfo.is())
		{
			Sequence<sal_Int16> aTypes = xNumberingInfo->getSupportedNumberingTypes();
			const sal_Int16* pTypes = aTypes.getConstArray();
            sal_Int32 nOffset = nEnd - nBegin;
            sal_Int32 nValidEntry = 0;
            for(sal_Int32 nType = 0; nType < aTypes.getLength(); nType++)
            {
                sal_Int16 nCurrent = pTypes[nType];
                if(nCurrent > NumberingType::CHARS_LOWER_LETTER_N)
                {
                    if(nValidEntry == ((sal_Int32)nFormatId) - nOffset)
                    {
                        nId = pTypes[nType];
                        break;
                    }
                    ++nValidEntry;
                }
            }
        }
	}
	break;
	case TYP_DDEFLD:
		switch ( aSwFlds[ GetPos( nTypeId ) ].nFmtBegin + nFormatId )
		{
        case FMT_DDE_NORMAL:    nId = sfx2::LINKUPDATE_ONCALL; break;
        case FMT_DDE_HOT:       nId = sfx2::LINKUPDATE_ALWAYS; break;
		}
		break;
	}

	return nId;

}

/*--------------------------------------------------------------------
	Beschreibung: Traveling
 --------------------------------------------------------------------*/


sal_Bool SwFldMgr::GoNextPrev( sal_Bool bNext, SwFieldType* pTyp )
{
	SwWrtShell* pSh = pWrtShell ? pWrtShell : ::lcl_GetShell();
    if(!pSh)
        return sal_False;

	if( !pTyp && pCurFld )
	{
		const sal_uInt16 nTypeId = pCurFld->GetTypeId();
		if( TYP_SETINPFLD == nTypeId || TYP_USRINPFLD == nTypeId )
			pTyp = pSh->GetFldType( 0, RES_INPUTFLD );
		else
			pTyp = pCurFld->GetTyp();
	}

	if (pTyp && pTyp->Which() == RES_DBFLD)
	{
		// Fuer Feldbefehl-bearbeiten (alle DB-Felder anspringen)
		return pSh->MoveFldType( 0, (bNext ? true : false), RES_DBFLD );
	}

    return (pTyp && pSh)
           ? pSh->MoveFldType( pTyp, (bNext ? true : false) )
           : sal_False;
}

/*--------------------------------------------------------------------
	Beschreibung: Feldtypen einfuegen
 --------------------------------------------------------------------*/


void SwFldMgr::InsertFldType(SwFieldType& rType)
{
    SwWrtShell* pSh = pWrtShell ? pWrtShell : ::lcl_GetShell();
    DBG_ASSERT(pSh, "no SwWrtShell found");
    if(pSh)
        pSh->InsertFldType(rType);
}

/*--------------------------------------------------------------------
	Beschreibung: Aktuelle TypeId ermitteln
 --------------------------------------------------------------------*/


sal_uInt16 SwFldMgr::GetCurTypeId() const
{
    return pCurFld ? pCurFld->GetTypeId() : USHRT_MAX;
}

/*--------------------------------------------------------------------
	Beschreibung: Ueber String  Feld einfuegen oder Update
 --------------------------------------------------------------------*/


sal_Bool SwFldMgr::InsertFld(
    const SwInsertFld_Data& rData )
{
    SwField* pFld   = 0;
    sal_Bool bExp = sal_False;
    sal_Bool bTbl = sal_False;
    sal_Bool bPageVar = sal_False;
    sal_uLong nFormatId = rData.nFormatId;
    sal_uInt16 nSubType = rData.nSubType;
    sal_Unicode cSeparator = rData.cSeparator;
    SwWrtShell* pCurShell = rData.pSh;
    if(!pCurShell)
        pCurShell = pWrtShell ? pWrtShell : ::lcl_GetShell();
    DBG_ASSERT(pCurShell, "no SwWrtShell found");
    if(!pCurShell)
        return sal_False;

    switch(rData.nTypeId)
    {
    case TYP_POSTITFLD:
        {
            SwPostItFieldType* pType = (SwPostItFieldType*)pCurShell->GetFldType(0, RES_POSTITFLD);
            SwPostItField* pPostItField =
                new SwPostItField(
                    pType,
                    rData.sPar2, // content
                    rData.sPar1, // author
                    aEmptyStr, // author's initials
                    aEmptyStr, // name
                    DateTime() );
            pFld = pPostItField;
        }
        break;

    case TYP_SCRIPTFLD:
        {
            SwScriptFieldType* pType =
                (SwScriptFieldType*)pCurShell->GetFldType(0, RES_SCRIPTFLD);
            pFld = new SwScriptField(pType, rData.sPar1, rData.sPar2, (sal_Bool)nFormatId);
            break;
        }

    case TYP_COMBINED_CHARS:
        {
            SwCombinedCharFieldType* pType = (SwCombinedCharFieldType*)
                pCurShell->GetFldType( 0, RES_COMBINED_CHARS );
            pFld = new SwCombinedCharField( pType, rData.sPar1 );
        }
        break;

    case TYP_AUTHORITY:
        {
            SwAuthorityFieldType* pType =
                (SwAuthorityFieldType*)pCurShell->GetFldType(0, RES_AUTHORITY);
            if(!pType)
            {
                pType =
                    (SwAuthorityFieldType*)pCurShell->InsertFldType(
                    SwAuthorityFieldType(pCurShell->GetDoc()));
            }
            pFld = new SwAuthorityField(pType, rData.sPar1);
        }
        break;

    case TYP_DATEFLD:
    case TYP_TIMEFLD:
        {
            sal_uInt16 nSub = static_cast< sal_uInt16 >(rData.nTypeId == TYP_DATEFLD ? DATEFLD : TIMEFLD);
            nSub |= nSubType == DATE_VAR ? 0 : FIXEDFLD;

            SwDateTimeFieldType* pTyp =
                (SwDateTimeFieldType*)pCurShell->GetFldType(0, RES_DATETIMEFLD);
            pFld = new SwDateTimeField(pTyp, nSub, nFormatId);
            pFld->SetPar2(rData.sPar2);
            break;
        }

    case TYP_FILENAMEFLD:
        {
            SwFileNameFieldType* pTyp =
                (SwFileNameFieldType*)pCurShell->GetFldType(0, RES_FILENAMEFLD);
            pFld = new SwFileNameField(pTyp, nFormatId);
            break;
        }

    case TYP_TEMPLNAMEFLD:
        {
            SwTemplNameFieldType* pTyp =
                (SwTemplNameFieldType*)pCurShell->GetFldType(0, RES_TEMPLNAMEFLD);
            pFld = new SwTemplNameField(pTyp, nFormatId);
            break;
        }

    case TYP_CHAPTERFLD:
        {
            sal_uInt16 nByte = (sal_uInt16)rData.sPar2.ToInt32();
            SwChapterFieldType* pTyp =
                (SwChapterFieldType*)pCurShell->GetFldType(0, RES_CHAPTERFLD);
            pFld = new SwChapterField(pTyp, nFormatId);
            nByte = Max(sal_uInt16(1), nByte);
            nByte = Min(nByte, sal_uInt16(MAXLEVEL));
            nByte -= 1;
            ((SwChapterField*)pFld)->SetLevel((sal_uInt8)nByte);
            break;
        }

    case TYP_NEXTPAGEFLD:
    case TYP_PREVPAGEFLD:
    case TYP_PAGENUMBERFLD:
        {
            short nOff  = (short)rData.sPar2.ToInt32();

            if(rData.nTypeId == TYP_NEXTPAGEFLD)
            {
                if( SVX_NUM_CHAR_SPECIAL == nFormatId )
                    nOff = 1;
                else
                    nOff += 1;
                nSubType = PG_NEXT;
            }
            else if(rData.nTypeId == TYP_PREVPAGEFLD)
            {
                if( SVX_NUM_CHAR_SPECIAL == nFormatId )
                    nOff = -1;
                else
                    nOff -= 1;
                nSubType =  PG_PREV;
            }
            else
                nSubType = PG_RANDOM;

            SwPageNumberFieldType* pTyp =
                (SwPageNumberFieldType*)pCurShell->GetFldType(0, RES_PAGENUMBERFLD);
            pFld = new SwPageNumberField(pTyp, nSubType, nFormatId, nOff);

            if( SVX_NUM_CHAR_SPECIAL == nFormatId &&
                ( PG_PREV == nSubType || PG_NEXT == nSubType ) )
                ((SwPageNumberField*)pFld)->SetUserString( rData.sPar2 );
            break;
        }

    case TYP_DOCSTATFLD:
        {
            SwDocStatFieldType* pTyp =
                (SwDocStatFieldType*)pCurShell->GetFldType(0, RES_DOCSTATFLD);
            pFld = new SwDocStatField(pTyp, nSubType, nFormatId);
            break;
        }

    case TYP_AUTHORFLD:
        {
            SwAuthorFieldType* pTyp =
                (SwAuthorFieldType*)pCurShell->GetFldType(0, RES_AUTHORFLD);
            pFld = new SwAuthorField(pTyp, nFormatId);
            break;
        }

    case TYP_CONDTXTFLD:
    case TYP_HIDDENTXTFLD:
        {
            SwHiddenTxtFieldType* pTyp =
                (SwHiddenTxtFieldType*)pCurShell->GetFldType(0, RES_HIDDENTXTFLD);
            pFld = new SwHiddenTxtField(pTyp, sal_True, rData.sPar1, rData.sPar2, sal_False, rData.nTypeId);
            bExp = sal_True;
            break;
        }

    case TYP_HIDDENPARAFLD:
        {
            SwHiddenParaFieldType* pTyp =
                (SwHiddenParaFieldType*)pCurShell->GetFldType(0, RES_HIDDENPARAFLD);
            pFld = new SwHiddenParaField(pTyp, rData.sPar1);
            bExp = sal_True;
            break;
        }

    case TYP_SETREFFLD:
        {
            if( rData.sPar1.Len() > 0 && CanInsertRefMark( rData.sPar1 ) )
            {
                pCurShell->SetAttrItem( SwFmtRefMark( rData.sPar1 ) );
                return sal_True;
            }
            return sal_False;
        }

    case TYP_GETREFFLD:
        {
            SwGetRefFieldType* pTyp =
                (SwGetRefFieldType*)pCurShell->GetFldType(0, RES_GETREFFLD);
            sal_uInt16 nSeqNo = (sal_uInt16)rData.sPar2.ToInt32();
            pFld = new SwGetRefField(pTyp, rData.sPar1, nSubType, nSeqNo, nFormatId);
            bExp = sal_True;
            break;
        }

    case TYP_DDEFLD:
        {
            //JP 28.08.95: DDE-Topics/-Items koennen Blanks in ihren
            //				Namen haben! Wird hier noch nicht beachtet.
            String sCmd( rData.sPar2 );
            sal_uInt16 nTmpPos = sCmd.SearchAndReplace( ' ', sfx2::cTokenSeperator );
            sCmd.SearchAndReplace( ' ', sfx2::cTokenSeperator, nTmpPos );

            SwDDEFieldType aType( rData.sPar1, sCmd, (sal_uInt16) nFormatId );
            SwDDEFieldType* pTyp = (SwDDEFieldType*) pCurShell->InsertFldType( aType );
            pFld = new SwDDEField( pTyp );
            break;
        }

    case TYP_MACROFLD:
        {
            SwMacroFieldType* pTyp =
                (SwMacroFieldType*)pCurShell->GetFldType(0, RES_MACROFLD);

            pFld = new SwMacroField(pTyp, rData.sPar1, rData.sPar2);

            break;
        }

    case TYP_INTERNETFLD:
        {
            SwFmtINetFmt aFmt( rData.sPar1, sCurFrame );
            if( pMacroItem )
                aFmt.SetMacroTbl( &pMacroItem->GetMacroTable() );
            return pCurShell->InsertURL( aFmt, rData.sPar2 );
        }

    case TYP_JUMPEDITFLD:
        {
            SwJumpEditFieldType* pTyp =
                (SwJumpEditFieldType*)pCurShell->GetFldType(0, RES_JUMPEDITFLD);

            pFld = new SwJumpEditField(pTyp, nFormatId, rData.sPar1, rData.sPar2 );
            break;
        }

    case TYP_DOCINFOFLD:
        {
            SwDocInfoFieldType* pTyp = (SwDocInfoFieldType*)pCurShell->GetFldType(
                0, RES_DOCINFOFLD );
            pFld = new SwDocInfoField(pTyp, nSubType, rData.sPar1, nFormatId);
            break;
        }

    case TYP_EXTUSERFLD:
        {
            SwExtUserFieldType* pTyp = (SwExtUserFieldType*)pCurShell->GetFldType(
                0, RES_EXTUSERFLD);
            pFld = new SwExtUserField(pTyp, nSubType, nFormatId);
            break;
        }

    case TYP_DBFLD:
        {
            SwDBData aDBData;
            String sPar1;

            if (rData.sPar1.Search(DB_DELIM) == STRING_NOTFOUND)
            {
                aDBData = pCurShell->GetDBData();
                sPar1 = rData.sPar1;
            }
            else
            {
                aDBData.sDataSource = rData.sPar1.GetToken(0, DB_DELIM);
                aDBData.sCommand = rData.sPar1.GetToken(1, DB_DELIM);
                aDBData.nCommandType = rData.sPar1.GetToken(2, DB_DELIM).ToInt32();
                sPar1 = rData.sPar1.GetToken(3, DB_DELIM);
            }

            if(aDBData.sDataSource.getLength() && pCurShell->GetDBData() != aDBData)
                pCurShell->ChgDBData(aDBData);

            SwDBFieldType* pTyp = (SwDBFieldType*)pCurShell->InsertFldType(
                SwDBFieldType(pCurShell->GetDoc(), sPar1, aDBData) );
            pFld = new SwDBField(pTyp);
            pFld->SetSubType(nSubType);

            if( !(nSubType & nsSwExtendedSubType::SUB_OWN_FMT) ) // Datenbankformat ermitteln
            {
                Reference< XDataSource> xSource;
                rData.aDBDataSource >>= xSource;
                Reference<XConnection> xConnection;
                rData.aDBConnection >>= xConnection;
                Reference<XPropertySet> xColumn;
                rData.aDBColumn >>= xColumn;
                if(xColumn.is())
                {
                    nFormatId = pCurShell->GetNewDBMgr()->GetColumnFmt(xSource, xConnection, xColumn,
                        pCurShell->GetNumberFormatter(), GetCurrLanguage() );
                }
                else
                    nFormatId = pCurShell->GetNewDBMgr()->GetColumnFmt(
                    aDBData.sDataSource, aDBData.sCommand, sPar1,
                    pCurShell->GetNumberFormatter(), GetCurrLanguage() );
            }
            pFld->ChangeFormat( nFormatId );

            bExp = sal_True;
            break;
        }

    case TYP_DBSETNUMBERFLD:
    case TYP_DBNUMSETFLD:
    case TYP_DBNEXTSETFLD:
    case TYP_DBNAMEFLD:
        {
            sal_uInt16 nPos, nTablePos, nCmdTypePos, nExpPos;
            String sPar1;
            SwDBData aDBData;

            // DBName aus rData.sPar1 extrahieren. Format: DBName.TableName.CommandType.ExpStrg
            if ((nTablePos = rData.sPar1.Search(DB_DELIM)) != STRING_NOTFOUND)
                aDBData.sDataSource = rData.sPar1.Copy(0, nTablePos++);
            if ((nCmdTypePos = rData.sPar1.Search(DB_DELIM, nTablePos)) != STRING_NOTFOUND)
            {
                aDBData.sCommand = rData.sPar1.Copy(nTablePos, nCmdTypePos++ - nTablePos);
            }
            if ((nExpPos = rData.sPar1.Search(DB_DELIM, nCmdTypePos)) != STRING_NOTFOUND)
            {
                aDBData.nCommandType = rData.sPar1.Copy(nCmdTypePos, nExpPos++ - nCmdTypePos).ToInt32();
            }
            if (nExpPos != STRING_NOTFOUND)
                nPos = nExpPos;
            else if (nTablePos != STRING_NOTFOUND)
                nPos = nTablePos;
            else
                nPos = 0;
            sPar1 = rData.sPar1.Copy(nPos);

            if (aDBData.sDataSource.getLength() && pCurShell->GetDBData() != aDBData)
                pCurShell->ChgDBData(aDBData);

            switch(rData.nTypeId)
            {
            case TYP_DBNAMEFLD:
                {
                    SwDBNameFieldType* pTyp =
                        (SwDBNameFieldType*)pCurShell->GetFldType(0, RES_DBNAMEFLD);
                    pFld = new SwDBNameField(pTyp, aDBData);

                    break;
                }
            case TYP_DBNEXTSETFLD:
                {
                    SwDBNextSetFieldType* pTyp = (SwDBNextSetFieldType*)pCurShell->GetFldType(
                        0, RES_DBNEXTSETFLD);
                    pFld = new SwDBNextSetField(pTyp, sPar1, rData.sPar2, aDBData);
                    bExp = sal_True;
                    break;
                }
            case TYP_DBNUMSETFLD:
                {
                    SwDBNumSetFieldType* pTyp = (SwDBNumSetFieldType*)pCurShell->GetFldType(
                        0, RES_DBNUMSETFLD);
                    pFld = new SwDBNumSetField( pTyp, sPar1, rData.sPar2, aDBData);
                    bExp = sal_True;
                    break;
                }
            case TYP_DBSETNUMBERFLD:
                {
                    SwDBSetNumberFieldType* pTyp = (SwDBSetNumberFieldType*)
                        pCurShell->GetFldType(0, RES_DBSETNUMBERFLD);
                    pFld = new SwDBSetNumberField( pTyp, aDBData, nFormatId);
                    bExp = sal_True;
                    break;
                }
            }
            break;
        }

    case TYP_USERFLD:
        {
            SwUserFieldType* pTyp =
                (SwUserFieldType*)pCurShell->GetFldType(RES_USERFLD, rData.sPar1);

            // nur wenn vorhanden
            if(!pTyp)
            {
                pTyp = (SwUserFieldType*)pCurShell->InsertFldType(
                    SwUserFieldType(pCurShell->GetDoc(), rData.sPar1));
            }
            if (pTyp->GetContent(nFormatId) != rData.sPar2)
                pTyp->SetContent(rData.sPar2, nFormatId);
            pFld = new SwUserField(pTyp, 0, nFormatId);
            if (pFld->GetSubType() != nSubType)
                pFld->SetSubType(nSubType);
            bTbl = sal_True;
            break;
        }

    case TYP_INPUTFLD:
        {
            if ((nSubType & 0x00ff) == INP_VAR)
            {
                SwSetExpFieldType* pTyp = (SwSetExpFieldType*)
                    pCurShell->GetFldType(RES_SETEXPFLD, rData.sPar1);

                // kein Experssion Type mit dem Namen vorhanden -> anlegen
                if(pTyp)
                {
                    SwSetExpField* pExpFld =
                        new SwSetExpField(pTyp, aEmptyStr, nFormatId);

                    // Typ vom SwSetExpFieldType nicht veraendern:
                    sal_uInt16 nOldSubType = pExpFld->GetSubType();
                    pExpFld->SetSubType(nOldSubType | (nSubType & 0xff00));

                    pExpFld->SetPromptText(rData.sPar2);
                    pExpFld->SetInputFlag(sal_True) ;
                    bExp = sal_True;
                    pFld = pExpFld;
                }
                else
                    return sal_False;
            }
            else
            {
                SwInputFieldType* pTyp =
                    (SwInputFieldType*)pCurShell->GetFldType(0, RES_INPUTFLD);

                SwInputField* pInpFld =
                    new SwInputField( pTyp, rData.sPar1, rData.sPar2, nSubType|nsSwExtendedSubType::SUB_INVISIBLE, nFormatId);
                pFld = pInpFld;
            }

            // Dialog starten
            //
            pCurShell->StartInputFldDlg(pFld, sal_False, rData.pParent);
            break;
        }

    case TYP_SETFLD:
        {
            if (!rData.sPar2.Len())   // Leere Variablen sind nicht erlaubt
                return sal_False;

            SwSetExpFieldType* pTyp = (SwSetExpFieldType*)pCurShell->InsertFldType(
                SwSetExpFieldType(pCurShell->GetDoc(), rData.sPar1) );

            SwSetExpField* pExpFld = new SwSetExpField( pTyp, rData.sPar2, nFormatId);
            pExpFld->SetSubType(nSubType);
            pExpFld->SetPar2(rData.sPar2);
            bExp = sal_True;
            pFld = pExpFld;
            break;
        }

    case TYP_SEQFLD:
        {
            SwSetExpFieldType* pTyp = (SwSetExpFieldType*)pCurShell->InsertFldType(
                SwSetExpFieldType(pCurShell->GetDoc(), rData.sPar1, nsSwGetSetExpType::GSE_SEQ));

            sal_uInt8 nLevel = static_cast< sal_uInt8 >(nSubType & 0xff);

            pTyp->SetOutlineLvl(nLevel);
            if (nLevel != 0x7f && cSeparator == 0)
                cSeparator = '.';

            pTyp->SetDelimiter(cSeparator);
            SwSetExpField* pExpFld = new SwSetExpField(pTyp, rData.sPar2, nFormatId);
            bExp = sal_True;
            pFld = pExpFld;
            nSubType = nsSwGetSetExpType::GSE_SEQ;
            break;
        }

    case TYP_GETFLD:
        {
            // gibt es ein entprechendes SetField
            SwSetExpFieldType* pSetTyp = (SwSetExpFieldType*)
                pCurShell->GetFldType(RES_SETEXPFLD, rData.sPar1);

            if(pSetTyp)
            {
                SwGetExpFieldType* pTyp = (SwGetExpFieldType*)pCurShell->GetFldType(
                    0, RES_GETEXPFLD);
                pFld = new SwGetExpField(pTyp, rData.sPar1, pSetTyp->GetType(), nFormatId);
                pFld->SetSubType(nSubType | pSetTyp->GetType());
                bExp = sal_True;
            }
            else
                return sal_False;
            break;
        }

    case TYP_FORMELFLD:
        {
            if(pCurShell->GetFrmType(0,sal_False) & FRMTYPE_TABLE)
            {
                pCurShell->StartAllAction();

                SvNumberFormatter* pFormatter = pCurShell->GetDoc()->GetNumberFormatter();
                const SvNumberformat* pEntry = pFormatter->GetEntry(nFormatId);

                if (pEntry)
                {
                    SfxStringItem aFormat(FN_NUMBER_FORMAT, pEntry->GetFormatstring());
                    pCurShell->GetView().GetViewFrame()->GetDispatcher()->
                        Execute(FN_NUMBER_FORMAT, SFX_CALLMODE_SYNCHRON, &aFormat, 0L);
                }

                SfxItemSet aBoxSet( pCurShell->GetAttrPool(),
                    RES_BOXATR_FORMULA, RES_BOXATR_FORMULA );

                String sFml( rData.sPar2 );
                if( sFml.EraseLeadingChars().Len() &&
                    '=' == sFml.GetChar( 0 ) )
                    sFml.Erase( 0, 1 );

                aBoxSet.Put( SwTblBoxFormula( sFml ));
                pCurShell->SetTblBoxFormulaAttrs( aBoxSet );
                pCurShell->UpdateTable();

                pCurShell->EndAllAction();
                return sal_True;

                /*				// In der Tabelle Tabellenformeln einfuegen
                SwTblFieldType* pTyp = (SwTblFieldType*)pCurShell->GetFldType(
                0, RES_TABLEFLD);
                pFld = new SwTblField(pTyp, rData.sPar2, nsSwGetSetExpType::GSE_EXPR, nFormatId);
                bTbl = sal_True;*/
            }
            else
            {
                SwGetExpFieldType* pTyp = (SwGetExpFieldType*)
                    pCurShell->GetFldType(0, RES_GETEXPFLD);
                pFld = new SwGetExpField(pTyp, rData.sPar2, nsSwGetSetExpType::GSE_FORMULA, nFormatId);
                pFld->SetSubType(nSubType);
                bExp = sal_True;
            }
            break;
        }

    case TYP_SETREFPAGEFLD:
        pFld = new SwRefPageSetField( (SwRefPageSetFieldType*)
            pCurShell->GetFldType( 0, RES_REFPAGESETFLD ),
            (short)rData.sPar2.ToInt32(), 0 != nSubType  );
        bPageVar = sal_True;
        break;

    case TYP_GETREFPAGEFLD:
        pFld = new SwRefPageGetField( (SwRefPageGetFieldType*)
            pCurShell->GetFldType( 0, RES_REFPAGEGETFLD ), nFormatId );
        bPageVar = sal_True;
        break;

    case TYP_DROPDOWN :
        {
            pFld = new SwDropDownField(pCurShell->GetFldType( 0, RES_DROPDOWN ));
            xub_StrLen nTokenCount = rData.sPar2.Len() ? rData.sPar2.GetTokenCount(DB_DELIM) : 0;
            Sequence<OUString> aEntries(nTokenCount);
            OUString* pArray = aEntries.getArray();
            for(xub_StrLen nToken = 0; nToken < nTokenCount; nToken++)
                pArray[nToken] = rData.sPar2.GetToken(nToken, DB_DELIM);
            ((SwDropDownField*)pFld)->SetItems(aEntries);
            ((SwDropDownField*)pFld)->SetName(rData.sPar1);
        }
        break;

    default:
        {
            ASSERT(!this, "Falscher Feldtyp");
            return sal_False;
        }
    }
    ASSERT(pFld, "Feld nicht vorhanden");


    //the auto language flag has to be set prior to the language!
    pFld->SetAutomaticLanguage(rData.bIsAutomaticLanguage);
    sal_uInt16 nLang = GetCurrLanguage();
    pFld->SetLanguage(nLang);

    // Einfuegen
    pCurShell->StartAllAction();

    pCurShell->Insert( *pFld );

    if(bExp && bEvalExp)
        pCurShell->UpdateExpFlds(sal_True);

    if(bTbl)
    {
        pCurShell->Left(CRSR_SKIP_CHARS, sal_False, 1, sal_False );
        pCurShell->UpdateFlds(*pFld);
        pCurShell->Right(CRSR_SKIP_CHARS, sal_False, 1, sal_False );
    }
    else if( bPageVar )
        ((SwRefPageGetFieldType*)pCurShell->GetFldType( 0, RES_REFPAGEGETFLD ))->UpdateFlds();
    else if( TYP_GETREFFLD == rData.nTypeId )
        pFld->GetTyp()->ModifyNotification( 0, 0 );

    // temporaeres Feld loeschen
    delete pFld;

    pCurShell->EndAllAction();
    return sal_True;
}

/*--------------------------------------------------------------------
	Beschreibung: Felder Update
 --------------------------------------------------------------------*/


void SwFldMgr::UpdateCurFld(sal_uLong nFormat,
							const String& rPar1,
							const String& rPar2,
                            SwField * _pTmpFld) // #111840#
{
	// Format aendern
	ASSERT(pCurFld, "kein Feld an der CursorPos");

    bool bDelete = false;
    SwField *pTmpFld;		// mb: fixed memory leak
    if (NULL != _pTmpFld)
    {
        pTmpFld = _pTmpFld;
    }
    else
    {
        pTmpFld = pCurFld->CopyField();
        bDelete = true;
    }

	SwFieldType* pType   = pTmpFld->GetTyp();
	const sal_uInt16 nTypeId = pTmpFld->GetTypeId();

    SwWrtShell* pSh = pWrtShell ? pWrtShell : ::lcl_GetShell();
    DBG_ASSERT(pSh, "no SwWrtShell found");
    if(!pSh)
        return;
    pSh->StartAllAction();

	sal_Bool bSetPar2 = sal_True;
	sal_Bool bSetPar1 = sal_True;
	String sPar1( rPar1 );
	String sPar2( rPar2 );

	// Order to Format
	switch( nTypeId )
	{
		case TYP_DDEFLD:
		{
			//JP 28.08.95: DDE-Topics/-Items koennen Blanks in ihren
			//				Namen haben! Wird hier noch nicht beachtet.
            sal_uInt16 nTmpPos = sPar2.SearchAndReplace( ' ', sfx2::cTokenSeperator );
            sPar2.SearchAndReplace( ' ', sfx2::cTokenSeperator, nTmpPos );
			break;
		}

		case TYP_CHAPTERFLD:
		{
            sal_uInt16 nByte = (sal_uInt16)rPar2.ToInt32();
			nByte = Max(sal_uInt16(1), nByte);
			nByte = Min(nByte, sal_uInt16(MAXLEVEL));
			nByte -= 1;
			((SwChapterField*)pTmpFld)->SetLevel((sal_uInt8)nByte);
			bSetPar2 = sal_False;
			break;
		}

		case TYP_SCRIPTFLD:
			((SwScriptField*)pTmpFld)->SetCodeURL((sal_Bool)nFormat);
			break;

		case TYP_NEXTPAGEFLD:
			if( SVX_NUM_CHAR_SPECIAL == nFormat )
			{
				((SwPageNumberField*)pCurFld)->SetUserString( sPar2 );
				sPar2 = '1';
			}
			else
			{
				if( nFormat + 2 == SVX_NUM_PAGEDESC )
					nFormat = SVX_NUM_PAGEDESC;
                short nOff = (short)sPar2.ToInt32();
				nOff += 1;
				sPar2 = String::CreateFromInt32(nOff);
			}
			break;

		case TYP_PREVPAGEFLD:
			if( SVX_NUM_CHAR_SPECIAL == nFormat )
			{
				((SwPageNumberField*)pCurFld)->SetUserString( sPar2 );
				sPar2 = String::CreateFromAscii(
                    RTL_CONSTASCII_STRINGPARAM("-1"));
			}
			else
			{
				if( nFormat + 2 == SVX_NUM_PAGEDESC )
					nFormat = SVX_NUM_PAGEDESC;
                short nOff = (short)sPar2.ToInt32();
				nOff -= 1;
				sPar2 = String::CreateFromInt32(nOff);
			}
			break;

		case TYP_PAGENUMBERFLD:
		case TYP_GETREFPAGEFLD:
			if( nFormat + 2 == SVX_NUM_PAGEDESC )
				nFormat = SVX_NUM_PAGEDESC;
			break;

		case TYP_GETREFFLD:
			{
				bSetPar2 = sal_False;
                ((SwGetRefField*)pTmpFld)->SetSubType( (sal_uInt16)rPar2.ToInt32() );
				sal_uInt16 nPos = rPar2.Search( '|' );
				if( STRING_NOTFOUND != nPos )
                    ((SwGetRefField*)pTmpFld)->SetSeqNo( (sal_uInt16)rPar2.Copy( nPos + 1 ).ToInt32());
			}
			break;
		case TYP_DROPDOWN:
		{
            xub_StrLen nTokenCount = sPar2.Len() ? sPar2.GetTokenCount(DB_DELIM) : 0;
            Sequence<OUString> aEntries(nTokenCount);
            OUString* pArray = aEntries.getArray();
            for(xub_StrLen nToken = 0; nToken < nTokenCount; nToken++)
                pArray[nToken] = sPar2.GetToken(nToken, DB_DELIM);
            ((SwDropDownField*)pTmpFld)->SetItems(aEntries);
            ((SwDropDownField*)pTmpFld)->SetName(sPar1);
			bSetPar1 = bSetPar2 = sal_False;
		}
		break;
        case TYP_AUTHORITY :
        {
            //#i99069# changes to a bibliography field should change the field type
            SwAuthorityField* pAuthorityField = static_cast<SwAuthorityField*>(pTmpFld);
            SwAuthorityFieldType* pAuthorityType = static_cast<SwAuthorityFieldType*>(pType);
            SwAuthEntry aTempEntry;
            for( sal_uInt16 i = 0; i < AUTH_FIELD_END; ++i )
                aTempEntry.SetAuthorField( (ToxAuthorityField)i,
                                rPar1.GetToken( i, TOX_STYLE_DELIMITER ));
            if( pAuthorityType->ChangeEntryContent( &aTempEntry ) )
            {
                pType->UpdateFlds();
                pSh->SetModified();
            }

            if( aTempEntry.GetAuthorField( AUTH_FIELD_IDENTIFIER ) ==
                pAuthorityField->GetFieldText( AUTH_FIELD_IDENTIFIER ) )
                bSetPar1 = sal_False; //otherwise it's a new or changed entry, the field needs to be updated
            bSetPar2 = sal_False;
        }
        break;
	}

	// Format setzen
	// Format wegen NumberFormatter vor SetPar2 einstellen!
	pTmpFld->ChangeFormat(nFormat);

	if(bSetPar1)
		pTmpFld->SetPar1( sPar1 );
	if( bSetPar2 )
		pTmpFld->SetPar2( sPar2 );

	// Update anschmeissen
	if(nTypeId == TYP_DDEFLD ||
	   nTypeId == TYP_USERFLD ||
	   nTypeId == TYP_USRINPFLD)
	{
		pType->UpdateFlds();
        pSh->SetModified();
	}
	else {
		// mb: #32157
        pSh->SwEditShell::UpdateFlds(*pTmpFld);
		GetCurFld();
	}

    if (bDelete)
        delete pTmpFld;

    pSh->EndAllAction();
}

/*--------------------------------------------------------------------
	Beschreibung: ExpressionFields explizit evaluieren
 --------------------------------------------------------------------*/
void SwFldMgr::EvalExpFlds(SwWrtShell* pSh)
{
	if (pSh == NULL)
		pSh = pWrtShell ? pWrtShell : ::lcl_GetShell();

	if(pSh)
	{
		pSh->StartAllAction();
		pSh->UpdateExpFlds(sal_True);
		pSh->EndAllAction();
	}
}
sal_uInt16 SwFldMgr::GetCurrLanguage() const
{
	SwWrtShell* pSh = pWrtShell ? pWrtShell : ::lcl_GetShell();
	if( pSh )
		return pSh->GetCurLang();
	return SvxLocaleToLanguage( SvtSysLocale().GetLocaleData().getLocale() );
}

void SwFieldType::_GetFldName()
{
	// mba: this is an awful mess; a fix is available, but too much for 3.4 -> applay plaster
	static const sal_uInt16 coFldCnt = 43;

	static sal_uInt16 __READONLY_DATA coFldNms[ coFldCnt ] = {
		FLD_DATE_STD,
		FLD_TIME_STD,
		STR_FILENAMEFLD,
		STR_DBNAMEFLD,
		STR_CHAPTERFLD,
		STR_PAGENUMBERFLD,
		STR_DOCSTATFLD,
		STR_AUTHORFLD,
		STR_SETFLD,
		STR_GETFLD,
		STR_FORMELFLD,
		STR_HIDDENTXTFLD,
		STR_SETREFFLD,
		STR_GETREFFLD,
		STR_DDEFLD,
		STR_MACROFLD,
		STR_INPUTFLD,
		STR_HIDDENPARAFLD,
		STR_DOCINFOFLD,
		STR_DBFLD,
		STR_USERFLD,
		STR_POSTITFLD,
		STR_TEMPLNAMEFLD,
		STR_SEQFLD,
		STR_DBNEXTSETFLD,
		STR_DBNUMSETFLD,
		STR_DBSETNUMBERFLD,
		STR_CONDTXTFLD,
		STR_NEXTPAGEFLD,
		STR_PREVPAGEFLD,
		STR_EXTUSERFLD,
		FLD_DATE_FIX,
		FLD_TIME_FIX,
		STR_SETINPUTFLD,
		STR_USRINPUTFLD,
		STR_SETREFPAGEFLD,
		STR_GETREFPAGEFLD,
		STR_INTERNETFLD,
		STR_JUMPEDITFLD,
		STR_SCRIPTFLD,
		STR_AUTHORITY,
        STR_COMBINED_CHARS,
        STR_DROPDOWN
	};

	// Infos fuer Felder einfuegen
	SwFieldType::pFldNames = new SvStringsDtor( (sal_uInt8)coFldCnt, 2 );
	for( sal_uInt16 nIdx = 0; nIdx < coFldCnt; ++nIdx )
	{
		String* pTmp = new SW_RESSTR( coFldNms[ nIdx ] );
        pTmp->Assign( MnemonicGenerator::EraseAllMnemonicChars( *pTmp ) );
		SwFieldType::pFldNames->Insert(pTmp, nIdx );
	}
}

/*--------------------------------------------------------------------
	Beschreibung:
 --------------------------------------------------------------------*/

sal_Bool SwFldMgr::ChooseMacro(const String&)
{
    sal_Bool bRet = sal_False;

    // choose script dialog
    ::rtl::OUString aScriptURL = SfxApplication::ChooseScript();

    // the script selector dialog returns a valid script URL
    if ( aScriptURL.getLength() != 0 )
    {
        SetMacroPath( aScriptURL );
        bRet = sal_True;
    }

    return bRet;
}

void SwFldMgr::SetMacroPath(const String& rPath)
{
    sMacroPath = rPath;
    sMacroName = rPath;

    // try to set sMacroName member variable by parsing the macro path
    // using the new URI parsing services

    Reference< XMultiServiceFactory > xSMgr =
        ::comphelper::getProcessServiceFactory();

    Reference< uri::XUriReferenceFactory >
        xFactory( xSMgr->createInstance(
            ::rtl::OUString::createFromAscii(
                "com.sun.star.uri.UriReferenceFactory" ) ), UNO_QUERY );

    if ( xFactory.is() )
    {
        Reference< uri::XVndSunStarScriptUrl >
            xUrl( xFactory->parse( sMacroPath ), UNO_QUERY );

        if ( xUrl.is() )
        {
            sMacroName = xUrl->getName();
        }
    }
}

/*--------------------------------------------------------------------
	Beschreibung:
 --------------------------------------------------------------------*/

sal_uLong SwFldMgr::GetDefaultFormat(sal_uInt16 nTypeId, sal_Bool bIsText, SvNumberFormatter* pFormatter, double* pVal)
{
	double fValue;
	short  nDefFormat;

	switch (nTypeId)
	{
		case TYP_TIMEFLD:
		case TYP_DATEFLD:
		{
			Date aDate;
			Date* pNullDate = pFormatter->GetNullDate();

			fValue = aDate - *pNullDate;

			Time aTime;

			sal_uLong nNumFmtTime = (sal_uLong)aTime.GetSec() + (sal_uLong)aTime.GetMin() * 60L +
						  (sal_uLong)aTime.GetHour() * 3600L;

			fValue += (double)nNumFmtTime / 86400.0;

			nDefFormat = (nTypeId == TYP_DATEFLD) ? NUMBERFORMAT_DATE : NUMBERFORMAT_TIME;
		}
		break;

		default:
			if (bIsText)
			{
				fValue = 0.0;
				nDefFormat = NUMBERFORMAT_TEXT;
			}
			else
			{
				fValue = 0.0;
				nDefFormat = NUMBERFORMAT_ALL;
			}
			break;
	}

	if (pVal)
		*pVal = fValue;

	return pFormatter->GetStandardFormat(nDefFormat, GetCurrLanguage());
}

/* -----------------------------01.03.01 16:46--------------------------------

 ---------------------------------------------------------------------------*/
Reference<XNumberingTypeInfo> SwFldMgr::GetNumberingInfo() const
{
	if(!xNumberingInfo.is())
	{
		Reference< XMultiServiceFactory > xMSF = ::comphelper::getProcessServiceFactory();
		Reference < XInterface > xI = xMSF->createInstance(
			::rtl::OUString::createFromAscii(
							"com.sun.star.text.DefaultNumberingProvider" ));
		Reference<XDefaultNumberingProvider> xDefNum(xI, UNO_QUERY);
		DBG_ASSERT(xDefNum.is(), "service missing: \"com.sun.star.text.DefaultNumberingProvider\"");
		((SwFldMgr*)this)->xNumberingInfo = Reference<XNumberingTypeInfo>(xDefNum, UNO_QUERY);
	}
	return xNumberingInfo;
}