mir/libreoffice
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
d68b1b6ae355c92e982ec845216ba459dbdd9e16
libreoffice/sw/source/ui/fldui/fldmgr.cxx

2451 lines
74 KiB
C++
Raw Normal View History

initial import
2000-09-18 16:15:01 +00:00
/*************************************************************************
*
* $RCSfile: fldmgr.cxx,v $
*
* $Revision: 1.1.1.1 $
*
* last change: $Author: hr $ $Date: 2000-09-18 17:14:36 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
*
* - GNU Lesser General Public License Version 2.1
* - Sun Industry Standards Source License Version 1.1
*
* Sun Microsystems Inc., October, 2000
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2000 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
*
* Sun Industry Standards Source License Version 1.1
* =================================================
* The contents of this file are subject to the Sun Industry Standards
* Source License Version 1.1 (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.openoffice.org/license.html.
*
* Software provided under this License is provided on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
* WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
* MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
* See the License for the specific provisions governing your rights and
* obligations concerning the Software.
*
* The Initial Developer of the Original Code is: Sun Microsystems, Inc.
*
* Copyright: 2000 by Sun Microsystems, Inc.
*
* All Rights Reserved.
*
* Contributor(s): _______________________________________
*
*
************************************************************************/
#ifdef PRECOMPILED
#include "ui_pch.hxx"
#endif
#pragma hdrstop
#include "cmdid.h"
#include "view.hxx"
#include "wrtsh.hxx" // Actives Fenster
#include "doc.hxx" // Actives Fenster
#include "docsh.hxx" // Actives Fenster
#include "swmodule.hxx"
#include "hintids.hxx"
#include "charatr.hxx"
#ifdef REPLACE_OFADBMGR
#ifndef _COM_SUN_STAR_LANG_XMULTISERVICEFACTORY_HPP_
#include <com/sun/star/lang/XMultiServiceFactory.hpp>
#endif
#ifndef _COM_SUN_STAR_CONTAINER_XNAMEACCESS_HPP_
#include <com/sun/star/container/XNameAccess.hpp>
#endif
#ifndef _COM_SUN_STAR_SDBC_XDATASOURCE_HPP_
#include <com/sun/star/sdbc/XDataSource.hpp>
#endif
#ifndef _COM_SUN_STAR_SDBC_DATATYPE_HPP_
#include <com/sun/star/sdbc/DataType.hpp>
#endif
#ifndef _COM_SUN_STAR_SDBCX_XTABLESSUPPLIER_HPP_
#include <com/sun/star/sdbcx/XTablesSupplier.hpp>
#endif
#ifndef _COM_SUN_STAR_SDBCX_XCOLUMNSSUPPLIER_HPP_
#include <com/sun/star/sdbcx/XColumnsSupplier.hpp>
#endif
#ifndef _COM_SUN_STAR_SDB_XQUERIESSUPPLIER_HPP_
#include <com/sun/star/sdb/XQueriesSupplier.hpp>
#endif
//#ifndef _COM_SUN_STAR_SDB_XDATABASEACCESS_HPP_
//#include <com/sun/star/sdb/XDatabaseAccess.hpp>
//#endif
#ifndef _COM_SUN_STAR_BEANS_XPROPERTYSET_HPP_
#include <com/sun/star/beans/XPropertySet.hpp>
#endif
#ifndef _UNOTOOLS_PROCESSFACTORY_HXX_
#include <unotools/processfactory.hxx>
#endif
#else
#endif //REPLACE_OFADBMGR
#ifndef _SFXDISPATCH_HXX //autogen
#include <sfx2/dispatch.hxx>
#endif
#ifndef _SFXDOCINF_HXX //autogen
#include <sfx2/docinf.hxx>
#endif
#ifndef _SFX_OBJSH_HXX //autogen
#include <sfx2/objsh.hxx>
#endif
#ifndef _LINKMGR_HXX //autogen
#include <so3/linkmgr.hxx>
#endif
#ifndef _BASMGR_HXX //autogen
#include <basic/basmgr.hxx>
#endif
#ifndef _SVX_LANGITEM_HXX //autogen
#include <svx/langitem.hxx>
#endif
#ifndef _SFXMACITEM_HXX //autogen
#include <svtools/macitem.hxx>
#endif
#ifndef _SB_SBMOD_HXX //autogen
#include <basic/sbmod.hxx>
#endif
#ifndef _FMTRFMRK_HXX //autogen
#include <fmtrfmrk.hxx>
#endif
#ifndef _SFXAPP_HXX //autogen
#include <sfx2/app.hxx>
#endif
#ifndef _SB_SBSTAR_HXX //autogen
#include <basic/sbstar.hxx>
#endif
#ifndef _SB_SBMETH_HXX //autogen
#include <basic/sbmeth.hxx>
#endif
#ifndef _SBXCLASS_HXX //autogen
#include <svtools/sbx.hxx>
#endif
#ifndef _BASOBJ_HXX //autogen
#include <basctl/basobj.hxx>
#endif
#ifndef _ZFORLIST_HXX //autogen
#include <svtools/zforlist.hxx>
#endif
#ifndef _ZFORMAT_HXX //autogen
#include <svtools/zformat.hxx>
#endif
#ifndef _SB_SBMOD_HXX //autogen
#include <basic/sbmod.hxx>
#endif
#ifndef _FMTINFMT_HXX //autogen
#include <fmtinfmt.hxx>
#endif
#ifndef _CELLATR_HXX
#include <cellatr.hxx>
#endif
#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 "fldui.hrc"
#ifdef REPLACE_OFADBMGR
using namespace rtl;
using namespace com::sun::star::uno;
using namespace com::sun::star::container;
using namespace com::sun::star::lang;
using namespace com::sun::star::sdb;
using namespace com::sun::star::sdbc;
using namespace com::sun::star::sdbcx;
using namespace com::sun::star::beans;
#define C2U(cChar) rtl::OUString::createFromAscii(cChar)
#endif
/*--------------------------------------------------------------------
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 + 6,
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 USHORT __FAR_DATA aSetFmt[] =
{
// die Reihenfolge muss zu Beginn mit den ResourceIds fuer FMT_SETVAR_???
// uebereinstimmen
0,
0
};
static const USHORT __FAR_DATA aGetFmt[] =
{
// die Reihenfolge muss zu Beginn mit den ResourceIds fuer FMT_GETVAR_???
// uebereinstimmen
0
};
static const USHORT __FAR_DATA aUsrFmt[] =
{
// die Reihenfolge muss zu Beginn mit den ResourceIds fuer FMT_SETVAR_???
// uebereinstimmen
0,
SUB_CMD
};
static const USHORT __FAR_DATA aDBFmt[] =
{
// die Reihenfolge muss zu Beginn mit den ResourceIds fuer FMT_DBFLD_???
// uebereinstimmen
SUB_OWN_FMT
};
static const USHORT VF_COUNT = sizeof(aGetFmt) / sizeof(USHORT);
static const USHORT VF_USR_COUNT = sizeof(aUsrFmt) / sizeof(USHORT);
static const USHORT VF_DB_COUNT = sizeof(aDBFmt) / sizeof(USHORT);
/*--------------------------------------------------------------------
Beschreibung: Feldtypen und Subtypes
--------------------------------------------------------------------*/
struct SwFldPack
{
USHORT nTypeId;
USHORT nSubTypeStart;
USHORT nSubTypeEnd;
ULONG nFmtBegin;
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_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_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
};
String* SwFldMgr::pDate = 0;
String* SwFldMgr::pTime = 0;
/*--------------------------------------------------------------------
Beschreibung: Zugriff auf die Shell
--------------------------------------------------------------------*/
SwWrtShell* lcl_GetShell()
{
SwView* pView;
if ( 0 != (pView = ::GetActiveView()) )
return pView->GetWrtShellPtr();
return 0;
}
inline USHORT GetPackCount() { return sizeof(aSwFlds) / sizeof(SwFldPack); }
/*--------------------------------------------------------------------
Beschreibung: FieldManager regelt das Einfuegen und Updaten
von Feldern
--------------------------------------------------------------------*/
SwFldMgr::SwFldMgr(SwWrtShell* pSh ) :
bEvalExp(TRUE),
pModule(0),
pMacroItem(0),
pWrtShell(pSh)
{
// aktuelles Feld ermitteln falls vorhanden
GetCurFld();
}
SwFldMgr::~SwFldMgr()
{
aSubLst.DeleteAndDestroy(0, aSubLst.Count());
}
/*--------------------------------------------------------------------
Beschreibung: RefMark ueber Namen organisieren
--------------------------------------------------------------------*/
BOOL SwFldMgr::CanInsertRefMark( const String& rStr )
{
SwWrtShell &rSh = pWrtShell ? *pWrtShell : *lcl_GetShell();
USHORT nCnt = rSh.GetCrsrCnt();
// der letzte Crsr muss keine aufgespannte Selektion
if( 1 < nCnt && !rSh.SwCrsrShell::HasSelection() )
--nCnt;
return 2 > nCnt && 0 == rSh.GetRefMark( rStr );
}
/*--------------------------------------------------------------------
Beschreibung: Alle DBTypes loeschen
--------------------------------------------------------------------*/
void SwFldMgr::RemoveDBTypes()
{
SwWrtShell &rSh = pWrtShell ? *pWrtShell : *lcl_GetShell();
USHORT nCount = rSh.GetFldTypeCount(RES_DBFLD);
for ( USHORT i=0; i < nCount ; ++i )
{
SwFieldType* pType = rSh.GetFldType( i, RES_DBFLD );
if( !pType->GetDepends() )
{
rSh.RemoveFldType( i--, RES_DBFLD );
nCount--;
}
}
}
/*--------------------------------------------------------------------
Beschreibung: Zugriff ueber ResIds
--------------------------------------------------------------------*/
USHORT SwFldMgr::GetFldTypeCount(USHORT nResId) const
{
return pWrtShell ?
pWrtShell->GetFldTypeCount(nResId) :
::lcl_GetShell()->GetFldTypeCount(nResId);
}
SwFieldType* SwFldMgr::GetFldType(USHORT nResId, USHORT nId) const
{
return pWrtShell ?
pWrtShell->GetFldType(nId, nResId) :
::lcl_GetShell()->GetFldType(nId, nResId);
}
SwFieldType* SwFldMgr::GetFldType(USHORT nResId, const String& rName) const
{
return pWrtShell ?
pWrtShell->GetFldType(nResId, rName) :
::lcl_GetShell()->GetFldType(nResId, rName);
}
void SwFldMgr::RemoveFldType(USHORT nResId, USHORT nId)
{
pWrtShell ?
pWrtShell->RemoveFldType(nId, nResId) :
::lcl_GetShell()->RemoveFldType(nId, nResId);
}
void SwFldMgr::RemoveFldType(USHORT nResId, const String& rName )
{
pWrtShell ?
pWrtShell->RemoveFldType(nResId, rName) :
::lcl_GetShell()->RemoveFldType(nResId, rName);
}
/*--------------------------------------------------------------------
Beschreibung: Aktuelles Feld ermitteln
--------------------------------------------------------------------*/
SwField* SwFldMgr::GetCurFld()
{
SwWrtShell *pSh = pWrtShell ? pWrtShell : ::lcl_GetShell();
if ( pSh )
pCurFld = pSh->GetCurFld();
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 USHORT 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(BOOL bHtmlMode, USHORT 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[(USHORT)nGrpId];
else
return aRanges[(USHORT)nGrpId];
}
/*--------------------------------------------------------------------
Beschreibung: GroupId bestimmen
--------------------------------------------------------------------*/
USHORT SwFldMgr::GetGroup(BOOL bHtmlMode, USHORT nTypeId, USHORT 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 (USHORT i = GRP_DOC; i <= GRP_VAR; i++)
{
const SwFldGroupRgn& rRange = GetGroupRange(bHtmlMode, i);
for (USHORT 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_....
--------------------------------------------------------------------*/
USHORT SwFldMgr::GetTypeId(USHORT nPos) const
{
ASSERT(nPos < ::GetPackCount(), "unzulaessige Pos");
return aSwFlds[ nPos ].nTypeId;
}
const String& SwFldMgr::GetTypeStr(USHORT nPos) const
{
ASSERT(nPos < ::GetPackCount(), "unzulaessige TypeId");
USHORT nFldWh = aSwFlds[ nPos ].nTypeId;
// Sonderbehandlung fuer Datum/Zeit Felder (ohne var/fix)
if( TYP_DATEFLD == nFldWh )
{
if( !pDate )
pDate = new SW_RESSTR( STR_DATEFLD );
return *pDate;
}
if( TYP_TIMEFLD == nFldWh )
{
if( !pTime )
pTime = new SW_RESSTR( STR_TIMEFLD );
return *pTime;
}
return *SwFieldType::GetFldNames()->GetObject( nFldWh );
}
/*--------------------------------------------------------------------
Beschreibung: Pos in der Liste bestimmen
--------------------------------------------------------------------*/
USHORT SwFldMgr::GetPos(USHORT nTypeId) const
{
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(USHORT i = 0; i < GetPackCount(); i++)
if(aSwFlds[i].nTypeId == nTypeId)
return i;
return USHRT_MAX;
}
/*--------------------------------------------------------------------
Beschreibung: Subtypen eines Feldes lokalisieren
--------------------------------------------------------------------*/
SvStringsDtor& SwFldMgr::GetSubTypes(USHORT nTypeId)
{
// aSubLst.DeleteAndDestroy(0, aSubLst.Count());
for (USHORT i=0; i < aSubLst.Count(); )
{
String* pStr = aSubLst[i];
DELETEZ(pStr);
aSubLst.Remove(i);
}
const USHORT nPos = GetPos(nTypeId);
switch(nTypeId)
{
case TYP_SETREFFLD:
case TYP_GETREFFLD:
{
// Referenzen sind keine Felder
pWrtShell ?
pWrtShell->GetRefMarks( &aSubLst ) :
::lcl_GetShell()->GetRefMarks( &aSubLst );
break;
}
case TYP_MACROFLD:
{
if (sMacroPath.Len())
{
String sPath = sMacroPath.Copy(sMacroPath.Search('.', 0));
if (pModule)
{
SbxArray* pSbxArray = pModule->GetMethods();
for (USHORT nMethod = 0; nMethod < pSbxArray->Count(); nMethod++)
{
SbMethod* pMethod = (SbMethod*)pSbxArray->Get(nMethod);
DBG_ASSERT( pMethod, "Methode nicht gefunden! (NULL)" );
String* pNew = new String(pMethod->GetName());
*pNew += sPath;
aSubLst.Insert(pNew, aSubLst.Count());
}
}
else
{
String* pNew = new String(sMacroPath);
aSubLst.Insert(pNew, aSubLst.Count());
}
}
break;
}
case TYP_INPUTFLD:
{ String* pNew = new SW_RESSTR(aSwFlds[nPos].nSubTypeStart);
aSubLst.Insert(pNew, aSubLst.Count());
// Weiter bei generischen Typen
}
case TYP_DDEFLD:
case TYP_SEQFLD:
case TYP_FORMELFLD:
case TYP_GETFLD:
case TYP_SETFLD:
case TYP_USERFLD:
{
SwWrtShell &rSh = pWrtShell ? *pWrtShell : *::lcl_GetShell();
const USHORT nCount = rSh.GetFldTypeCount();
for(USHORT i = 0; i < nCount; ++i)
{
SwFieldType* pFldType = rSh.GetFldType( i );
const USHORT 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() & GSE_SEQ)) ||
(nTypeId == TYP_SETFLD && nWhich == RES_SETEXPFLD &&
!(((SwSetExpFieldType*)pFldType)->GetType() & GSE_SEQ)) ||
(nTypeId == TYP_SEQFLD && nWhich == RES_SETEXPFLD &&
(((SwSetExpFieldType*)pFldType)->GetType() & GSE_SEQ)) ||
((nTypeId == TYP_INPUTFLD || nTypeId == TYP_FORMELFLD) &&
(nWhich == RES_USERFLD ||
nWhich == RES_SETEXPFLD &&
!(((SwSetExpFieldType*)pFldType)->GetType() & GSE_SEQ)) ) )
{
String* pNew = new String(pFldType->GetName());
aSubLst.Insert(pNew, aSubLst.Count());
}
}
break;
}
case TYP_DBNEXTSETFLD:
case TYP_DBNUMSETFLD:
case TYP_DBNAMEFLD:
case TYP_DBSETNUMBERFLD:
break;
default:
{
// statische SubTypes
if(nPos != USHRT_MAX)
{
USHORT nCount;
if (nTypeId == TYP_DOCINFOFLD)
nCount = DI_SUBTYPE_END - DI_SUBTYPE_BEGIN;
else
nCount = aSwFlds[nPos].nSubTypeEnd - aSwFlds[nPos].nSubTypeStart;
SwWrtShell &rSh = pWrtShell ? *pWrtShell : *::lcl_GetShell();
for(USHORT i = 0; i < nCount; ++i)
{
String* pNew;
if (nTypeId == TYP_DOCINFOFLD)
{
if (i >= DI_INFO1 && i <= DI_INFO4)
pNew = new String( rSh.GetInfo()->GetUserKey(i-DI_INFO1).GetTitle());
else
pNew = new String(*ViewShell::GetShellRes()->aDocInfoLst[i]);
}
else
pNew = new SW_RESSTR(aSwFlds[nPos].nSubTypeStart + i);
aSubLst.Insert(pNew, aSubLst.Count());
}
}
}
}
return aSubLst;
}
/*--------------------------------------------------------------------
Beschreibung: Format ermitteln
ZUGRIFF ueber TYP_....
--------------------------------------------------------------------*/
USHORT SwFldMgr::GetFormatCount(USHORT nTypeId, BOOL bIsText, BOOL bHtmlMode) const
{
ASSERT(nTypeId < TYP_END, "unzulaessige TypeId");
{
const USHORT nPos = GetPos(nTypeId);
if(nPos == USHRT_MAX || (bHtmlMode && nTypeId == TYP_SETFLD))
return 0;
ULONG nStart = aSwFlds[nPos].nFmtBegin;
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;
}
return (USHORT)(nEnd - nStart);
}
}
/*--------------------------------------------------------------------
Beschreibung: FormatString zu einem Typ ermitteln
--------------------------------------------------------------------*/
String SwFldMgr::GetFormatStr(USHORT nTypeId, ULONG nFormatId) const
{
String aRet;
SwWrtShell *pSh = pWrtShell ? pWrtShell : ::lcl_GetShell();
ASSERT(nTypeId < TYP_END, "unzulaessige TypeId");
const USHORT nPos = GetPos(nTypeId);
if(nPos == USHRT_MAX)
return aRet;
ULONG nStart;
nStart = aSwFlds[nPos].nFmtBegin;
if (nTypeId == TYP_FILENAMEFLD)
nFormatId &= ~FF_FIXED; // Fixed-Flag ausmaskieren
aRet = SW_RESSTR((USHORT)(nStart + nFormatId));
return aRet;
}
/*--------------------------------------------------------------------
Beschreibung: FormatId aus Pseudo-ID ermitteln
--------------------------------------------------------------------*/
USHORT SwFldMgr::GetFormatId(USHORT nTypeId, ULONG nFormatId) const
{
USHORT nId = (USHORT)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:
switch( aSwFlds[ GetPos( nTypeId ) ].nFmtBegin + 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;
}
break;
case TYP_DDEFLD:
switch ( aSwFlds[ GetPos( nTypeId ) ].nFmtBegin + nFormatId )
{
case FMT_DDE_NORMAL: nId = LINKUPDATE_ONCALL; break;
case FMT_DDE_HOT: nId = LINKUPDATE_ALWAYS; break;
}
break;
}
return nId;
}
/*--------------------------------------------------------------------
Beschreibung: Traveling
--------------------------------------------------------------------*/
BOOL SwFldMgr::GoNextPrev( BOOL bNext, SwFieldType* pTyp )
{
SwWrtShell* pSh = pWrtShell ? pWrtShell : ::lcl_GetShell();
if( !pTyp && pCurFld )
{
const USHORT 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, USHRT_MAX, RES_DBFLD );
}
return pTyp && pSh ? pSh->MoveFldType( pTyp, bNext ) : FALSE;
}
/*--------------------------------------------------------------------
Beschreibung: Feldtypen einfuegen
--------------------------------------------------------------------*/
void SwFldMgr::InsertFldType(SwFieldType& rType)
{
pWrtShell ?
pWrtShell->InsertFldType(rType) :
::lcl_GetShell()->InsertFldType(rType);
}
/*--------------------------------------------------------------------
Beschreibung: Aktuelle TypeId ermitteln
--------------------------------------------------------------------*/
USHORT SwFldMgr::GetCurTypeId() const
{
return pCurFld->GetTypeId();
}
/*--------------------------------------------------------------------
Beschreibung: Ueber String Feld einfuegen oder Update
--------------------------------------------------------------------*/
BOOL SwFldMgr::InsertFld(USHORT nType,
USHORT nSubType,
const String& rPar1,
const String& rPar2,
ULONG nFormat,
SwWrtShell* pSh,
sal_Unicode cSeparator)
{
SwField* pFld = 0;
BOOL bExp = FALSE;
BOOL bTbl = FALSE;
BOOL bPageVar = FALSE;
if (pSh == NULL)
pSh = pWrtShell ? pWrtShell : ::lcl_GetShell();
switch(nType)
{ // ACHTUNG dieses Feld wird ueber einen gesonderten Dialog eingefuegt
case TYP_POSTITFLD:
{
SwPostItFieldType* pType =
(SwPostItFieldType*)pSh->GetFldType(0, RES_POSTITFLD);
pFld = new SwPostItField(pType, rPar1, rPar2, Date());
break;
}
case TYP_SCRIPTFLD:
{
SwScriptFieldType* pType =
(SwScriptFieldType*)pSh->GetFldType(0, RES_SCRIPTFLD);
pFld = new SwScriptField(pType, rPar1, rPar2, (BOOL)nFormat);
break;
}
case TYP_AUTHORITY:
{
SwAuthorityFieldType* pType =
(SwAuthorityFieldType*)pSh->GetFldType(0, RES_AUTHORITY);
if(!pType)
{
pType =
(SwAuthorityFieldType*)pSh->InsertFldType(
SwAuthorityFieldType(pSh->GetDoc()));
}
pFld = new SwAuthorityField(pType, rPar1);
}
break;
case TYP_DATEFLD:
case TYP_TIMEFLD:
{
USHORT nSub = (nType == TYP_DATEFLD) ? DATEFLD : TIMEFLD;
nSub |= nSubType == DATE_VAR ? 0 : FIXEDFLD;
SwDateTimeFieldType* pTyp =
(SwDateTimeFieldType*)pSh->GetFldType(0, RES_DATETIMEFLD);
pFld = new SwDateTimeField(pTyp, nSub, nFormat);
pFld->SetPar2(rPar2);
break;
}
case TYP_FILENAMEFLD:
{
SwFileNameFieldType* pTyp =
(SwFileNameFieldType*)pSh->GetFldType(0, RES_FILENAMEFLD);
pFld = new SwFileNameField(pTyp, nFormat);
break;
}
case TYP_TEMPLNAMEFLD:
{
SwTemplNameFieldType* pTyp =
(SwTemplNameFieldType*)pSh->GetFldType(0, RES_TEMPLNAMEFLD);
pFld = new SwTemplNameField(pTyp, nFormat);
break;
}
case TYP_CHAPTERFLD:
{ USHORT nByte = rPar2.ToInt32();
SwChapterFieldType* pTyp =
(SwChapterFieldType*)pSh->GetFldType(0, RES_CHAPTERFLD);
pFld = new SwChapterField(pTyp, nFormat);
nByte = Max(USHORT(1), nByte);
nByte = Min(nByte, USHORT(MAXLEVEL));
nByte -= 1;
((SwChapterField*)pFld)->SetLevel((BYTE)nByte);
break;
}
case TYP_NEXTPAGEFLD:
case TYP_PREVPAGEFLD:
case TYP_PAGENUMBERFLD:
{
short nOff = rPar2.ToInt32();
if(nType == TYP_NEXTPAGEFLD)
{
if( SVX_NUM_CHAR_SPECIAL == nFormat )
nOff = 1;
else
nOff += 1;
nSubType = PG_NEXT;
}
else if(nType == TYP_PREVPAGEFLD)
{
if( SVX_NUM_CHAR_SPECIAL == nFormat )
nOff = -1;
else
nOff -= 1;
nSubType = PG_PREV;
}
else
nSubType = PG_RANDOM;
SwPageNumberFieldType* pTyp =
(SwPageNumberFieldType*)pSh->GetFldType(0, RES_PAGENUMBERFLD);
pFld = new SwPageNumberField(pTyp, nSubType, nFormat, nOff);
if( SVX_NUM_CHAR_SPECIAL == nFormat &&
( PG_PREV == nSubType || PG_NEXT == nSubType ) )
((SwPageNumberField*)pFld)->SetUserString( rPar2 );
break;
}
case TYP_DOCSTATFLD:
{ SwDocStatFieldType* pTyp =
(SwDocStatFieldType*)pSh->GetFldType(0, RES_DOCSTATFLD);
pFld = new SwDocStatField(pTyp, nSubType, nFormat);
break;
}
case TYP_AUTHORFLD:
{ SwAuthorFieldType* pTyp =
(SwAuthorFieldType*)pSh->GetFldType(0, RES_AUTHORFLD);
pFld = new SwAuthorField(pTyp, nFormat);
break;
}
case TYP_CONDTXTFLD:
case TYP_HIDDENTXTFLD:
{
SwHiddenTxtFieldType* pTyp =
(SwHiddenTxtFieldType*)pSh->GetFldType(0, RES_HIDDENTXTFLD);
pFld = new SwHiddenTxtField(pTyp, TRUE, rPar1, rPar2, FALSE, nType);
bExp = TRUE;
break;
}
case TYP_HIDDENPARAFLD:
{
SwHiddenParaFieldType* pTyp =
(SwHiddenParaFieldType*)pSh->GetFldType(0, RES_HIDDENPARAFLD);
pFld = new SwHiddenParaField(pTyp, rPar1);
bExp = TRUE;
break;
}
case TYP_SETREFFLD:
{
if( rPar1.Len() > 0 && CanInsertRefMark( rPar1 ) )
{
pSh->SetAttr( SwFmtRefMark( rPar1 ) );
return TRUE;
}
return FALSE;
}
case TYP_GETREFFLD:
{
SwGetRefFieldType* pTyp =
(SwGetRefFieldType*)pSh->GetFldType(0, RES_GETREFFLD);
USHORT nSeqNo = rPar2.ToInt32();
pFld = new SwGetRefField(pTyp, rPar1, nSubType, nSeqNo, nFormat);
bExp = 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( rPar2 );
USHORT nTmpPos = sCmd.SearchAndReplace( ' ', cTokenSeperator );
sCmd.SearchAndReplace( ' ', cTokenSeperator, nTmpPos );
SwDDEFieldType* pTyp = (SwDDEFieldType*)pSh->InsertFldType(
SwDDEFieldType( rPar1, sCmd, (USHORT)nFormat ));
pFld = new SwDDEField( pTyp );
break;
}
case TYP_MACROFLD:
{
SwMacroFieldType* pTyp =
(SwMacroFieldType*)pSh->GetFldType(0, RES_MACROFLD);
pFld = new SwMacroField(pTyp, rPar1, rPar2);
break;
}
case TYP_INTERNETFLD:
{
SwFmtINetFmt aFmt( rPar1, sCurFrame );
if( pMacroItem )
aFmt.SetMacroTbl( &pMacroItem->GetMacroTable() );
return pSh->InsertURL( aFmt, rPar2 );
}
case TYP_JUMPEDITFLD:
{
SwJumpEditFieldType* pTyp =
(SwJumpEditFieldType*)pSh->GetFldType(0, RES_JUMPEDITFLD);
pFld = new SwJumpEditField(pTyp, nFormat, rPar1, rPar2 );
break;
}
case TYP_DOCINFOFLD:
{
SwDocInfoFieldType* pTyp = (SwDocInfoFieldType*)pSh->GetFldType(
0, RES_DOCINFOFLD );
pFld = new SwDocInfoField(pTyp, nSubType, nFormat);
break;
}
case TYP_EXTUSERFLD:
{
SwExtUserFieldType* pTyp = (SwExtUserFieldType*)pSh->GetFldType(
0, RES_EXTUSERFLD);
pFld = new SwExtUserField(pTyp, nSubType, nFormat);
break;
}
case TYP_DBFLD:
{
String sDBName;
String sPar1;
if (rPar1.Search(DB_DELIM) == STRING_NOTFOUND)
{
sDBName = pSh->GetDBName();
sPar1 = rPar1;
}
else
{
sDBName = rPar1.GetToken(0, DB_DELIM);
sDBName += DB_DELIM;
sDBName += rPar1.GetToken(1, DB_DELIM);
sPar1 = rPar1.GetToken(2, DB_DELIM);
}
if (sDBName.Len() && pSh->GetDBName() != sDBName)
pSh->ChgDBName(sDBName);
SwDBFieldType* pTyp = (SwDBFieldType*)pSh->InsertFldType(
SwDBFieldType(pSh->GetDoc(), sPar1, sDBName) );
pFld = new SwDBField(pTyp);
pFld->SetSubType(nSubType);
if( !(nSubType & SUB_OWN_FMT) ) // Datenbankformat ermitteln
{
#ifdef REPLACE_OFADBMGR
String sSourceName(sDBName.GetToken(0, DB_DELIM));
String sTableName(sDBName.GetToken(1, DB_DELIM));
nFormat = pSh->GetNewDBMgr()->GetColumnFmt( sSourceName, sTableName, sPar1,
pSh->GetNumberFormatter(), GetCurrLanguage() );
#else
nFormat = pSh->GetNewDBMgr()->GetColumnFmt( sDBName, sPar1,
pSh->GetNumberFormatter() );
#endif
}
pFld->ChangeFormat( nFormat );
bExp = TRUE;
break;
}
case TYP_DBSETNUMBERFLD:
case TYP_DBNUMSETFLD:
case TYP_DBNEXTSETFLD:
case TYP_DBNAMEFLD:
{
USHORT nPos, nTablePos, nExpPos;
String sDBName, sPar1;
// DBName aus rPar1 extrahieren. Format: DBName.TableName.ExpStrg
if ((nTablePos = rPar1.Search(DB_DELIM)) != STRING_NOTFOUND)
sDBName = rPar1.Copy(0, nTablePos++);
if ((nExpPos = rPar1.Search(DB_DELIM, nTablePos)) != STRING_NOTFOUND)
{
sDBName += DB_DELIM;
sDBName += rPar1.Copy(nTablePos, nExpPos++ - nTablePos);
}
if (nExpPos != STRING_NOTFOUND)
nPos = nExpPos;
else if (nTablePos != STRING_NOTFOUND)
nPos = nTablePos;
else
nPos = 0;
sPar1 = rPar1.Copy(nPos);
#ifdef REPLACE_OFADBMGR
if (sDBName.Len() && pSh->GetDBName() != sDBName)
#else
if (sDBName.Len() && pSh->GetDBName().ToUpperAscii() != sDBName.ToUpperAscii())
#endif
pSh->ChgDBName(sDBName);
switch(nType)
{
case TYP_DBNAMEFLD:
{
SwDBNameFieldType* pTyp =
(SwDBNameFieldType*)pSh->GetFldType(0, RES_DBNAMEFLD);
pFld = new SwDBNameField(pTyp, sDBName);
break;
}
case TYP_DBNEXTSETFLD:
{
SwDBNextSetFieldType* pTyp = (SwDBNextSetFieldType*)pSh->GetFldType(
0, RES_DBNEXTSETFLD);
pFld = new SwDBNextSetField(pTyp, sPar1, rPar2, sDBName);
bExp = TRUE;
break;
}
case TYP_DBNUMSETFLD:
{
SwDBNumSetFieldType* pTyp = (SwDBNumSetFieldType*)pSh->GetFldType(
0, RES_DBNUMSETFLD);
pFld = new SwDBNumSetField( pTyp, sPar1, rPar2, sDBName);
bExp = TRUE;
break;
}
case TYP_DBSETNUMBERFLD:
{
SwDBSetNumberFieldType* pTyp = (SwDBSetNumberFieldType*)
pSh->GetFldType(0, RES_DBSETNUMBERFLD);
pFld = new SwDBSetNumberField( pTyp, sDBName, nFormat);
bExp = TRUE;
break;
}
}
break;
}
case TYP_USERFLD:
{
SwUserFieldType* pTyp =
(SwUserFieldType*)pSh->GetFldType(RES_USERFLD, rPar1);
// nur wenn vorhanden
if(!pTyp)
{
pTyp = (SwUserFieldType*)pSh->InsertFldType(
SwUserFieldType(pSh->GetDoc(), rPar1));
}
if (pTyp->GetContent(nFormat) != rPar2)
pTyp->SetContent(rPar2, nFormat);
pFld = new SwUserField(pTyp, 0, nFormat);
if (pFld->GetSubType() != nSubType)
pFld->SetSubType(nSubType);
bTbl = TRUE;
break;
}
case TYP_INPUTFLD:
{
if ((nSubType & 0x00ff) == INP_VAR)
{
SwSetExpFieldType* pTyp = (SwSetExpFieldType*)
pSh->GetFldType(RES_SETEXPFLD, rPar1);
// kein Experssion Type mit dem Namen vorhanden -> anlegen
if(pTyp)
{
SwSetExpField* pExpFld =
new SwSetExpField(pTyp, aEmptyStr, nFormat);
// Typ vom SwSetExpFieldType nicht veraendern:
USHORT nOldSubType = pExpFld->GetSubType();
pExpFld->SetSubType(nOldSubType | (nSubType & 0xff00));
pExpFld->SetPromptText(rPar2);
pExpFld->SetInputFlag(TRUE) ;
bExp = TRUE;
pFld = pExpFld;
}
else
return FALSE;
}
else
{
SwInputFieldType* pTyp =
(SwInputFieldType*)pSh->GetFldType(0, RES_INPUTFLD);
SwInputField* pInpFld =
new SwInputField(pTyp, rPar1, rPar2, nSubType|SUB_INVISIBLE, nFormat);
pFld = pInpFld;
}
// Dialog starten
//
pSh->StartInputFldDlg(pFld, FALSE);
break;
}
case TYP_SETFLD:
{
if (!rPar2.Len()) // Leere Variablen sind nicht erlaubt
return FALSE;
SwSetExpFieldType* pTyp = (SwSetExpFieldType*)pSh->InsertFldType(
SwSetExpFieldType(pSh->GetDoc(), rPar1) );
SwSetExpField* pExpFld = new SwSetExpField( pTyp, rPar2, nFormat);
pExpFld->SetSubType(nSubType);
pExpFld->SetPar2(rPar2);
bExp = TRUE;
pFld = pExpFld;
break;
}
case TYP_SEQFLD:
{
SwSetExpFieldType* pTyp = (SwSetExpFieldType*)pSh->InsertFldType(
SwSetExpFieldType(pSh->GetDoc(), rPar1, GSE_SEQ));
BYTE nLevel = nSubType & 0xff;
pTyp->SetOutlineLvl(nLevel);
if (nLevel != 0x7f && cSeparator == 0)
cSeparator = '.';
pTyp->SetDelimiter(cSeparator);
SwSetExpField* pExpFld = new SwSetExpField(pTyp, rPar2, nFormat);
bExp = TRUE;
pFld = pExpFld;
nSubType = GSE_SEQ;
break;
}
case TYP_GETFLD:
{
// gibt es ein entprechendes SetField
SwSetExpFieldType* pSetTyp = (SwSetExpFieldType*)
pSh->GetFldType(RES_SETEXPFLD, rPar1);
if(pSetTyp)
{
SwGetExpFieldType* pTyp = (SwGetExpFieldType*)pSh->GetFldType(
0, RES_GETEXPFLD);
pFld = new SwGetExpField(pTyp, rPar1, pSetTyp->GetType(), nFormat);
pFld->SetSubType(nSubType | pSetTyp->GetType());
bExp = TRUE;
}
else
return FALSE;
break;
}
case TYP_FORMELFLD:
{
if(pSh->GetFrmType(0,FALSE) & FRMTYPE_TABLE)
{
pSh->StartAllAction();
SvNumberFormatter* pFormatter = pSh->GetDoc()->GetNumberFormatter();
const SvNumberformat* pEntry = pFormatter->GetEntry(nFormat);
if (pEntry)
{
SfxStringItem aFormat(FN_NUMBER_FORMAT, pEntry->GetFormatstring());
pSh->GetView().GetViewFrame()->GetDispatcher()->
Execute(FN_NUMBER_FORMAT, SFX_CALLMODE_SYNCHRON, &aFormat, 0L);
}
SfxItemSet aBoxSet( pSh->GetAttrPool(),
RES_BOXATR_FORMULA, RES_BOXATR_FORMULA );
String sFml( rPar2 );
if( sFml.EraseLeadingChars().Len() &&
'=' == sFml.GetChar( 0 ) )
sFml.Erase( 0, 1 );
aBoxSet.Put( SwTblBoxFormula( sFml ));
pSh->SetTblBoxFormulaAttrs( aBoxSet );
pSh->UpdateTable();
pSh->EndAllAction();
return TRUE;
/* // In der Tabelle Tabellenformeln einfuegen
SwTblFieldType* pTyp = (SwTblFieldType*)pSh->GetFldType(
0, RES_TABLEFLD);
pFld = new SwTblField(pTyp, rPar2, GSE_EXPR, nFormat);
bTbl = TRUE;*/
}
else
{
SwGetExpFieldType* pTyp = (SwGetExpFieldType*)
pSh->GetFldType(0, RES_GETEXPFLD);
pFld = new SwGetExpField(pTyp, rPar2, GSE_FORMULA, nFormat);
pFld->SetSubType(nSubType);
bExp = TRUE;
}
break;
}
case TYP_SETREFPAGEFLD:
pFld = new SwRefPageSetField( (SwRefPageSetFieldType*)
pSh->GetFldType( 0, RES_REFPAGESETFLD ),
rPar2.ToInt32(), 0 != nSubType );
bPageVar = TRUE;
break;
case TYP_GETREFPAGEFLD:
pFld = new SwRefPageGetField( (SwRefPageGetFieldType*)
pSh->GetFldType( 0, RES_REFPAGEGETFLD ), nFormat );
bPageVar = TRUE;
break;
default:
{ ASSERT(!this, "Falscher Feldtyp");
return FALSE;
}
}
ASSERT(pFld, "Feld nicht vorhanden");
USHORT nLang = GetCurrLanguage();
// Language
pFld->SetLanguage(nLang);
// Einfuegen
pSh->StartAllAction();
pSh->Insert(*pFld);
if(bExp && bEvalExp)
pSh->UpdateExpFlds(TRUE);
if(bTbl)
{
pSh->Left();
pSh->UpdateFlds(*pFld);
pSh->Right();
}
else if( bPageVar )
((SwRefPageGetFieldType*)pSh->GetFldType( 0, RES_REFPAGEGETFLD ))->UpdateFlds();
else if( TYP_GETREFFLD == nType )
pFld->GetTyp()->Modify( 0, 0 );
// temporaeres Feld loeschen
delete pFld;
pSh->EndAllAction();
return TRUE;
}
/*--------------------------------------------------------------------
Beschreibung: Felder Update
--------------------------------------------------------------------*/
void SwFldMgr::UpdateCurFld(ULONG nFormat,
const String& rPar1,
const String& rPar2)
{
// Format aendern
ASSERT(pCurFld, "kein Feld an der CursorPos");
SwFieldType* pType = pCurFld->GetTyp();
const USHORT nTypeId = pCurFld->GetTypeId();
SwWrtShell &rSh = pWrtShell ? *pWrtShell : *::lcl_GetShell();
rSh.StartAllAction();
BOOL bSetPar2 = 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.
USHORT nTmpPos = sPar2.SearchAndReplace( ' ', cTokenSeperator );
sPar2.SearchAndReplace( ' ', cTokenSeperator, nTmpPos );
break;
}
case TYP_CHAPTERFLD:
{
USHORT nByte = rPar2.ToInt32();
nByte = Max(USHORT(1), nByte);
nByte = Min(nByte, USHORT(MAXLEVEL));
nByte -= 1;
((SwChapterField*)pCurFld)->SetLevel((BYTE)nByte);
bSetPar2 = FALSE;
break;
}
case TYP_SCRIPTFLD:
((SwScriptField*)pCurFld)->SetCodeURL((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 = sPar2.ToInt32();
nOff += 1;
sPar2 = nOff;
}
break;
case TYP_PREVPAGEFLD:
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 = sPar2.ToInt32();
nOff -= 1;
sPar2 = nOff;
}
break;
case TYP_PAGENUMBERFLD:
case TYP_GETREFPAGEFLD:
if( nFormat + 2 == SVX_NUM_PAGEDESC )
nFormat = SVX_NUM_PAGEDESC;
break;
case TYP_GETREFFLD:
{
bSetPar2 = FALSE;
((SwGetRefField*)pCurFld)->SetSubType( rPar2.ToInt32() );
USHORT nPos = rPar2.Search( '|' );
if( STRING_NOTFOUND != nPos )
((SwGetRefField*)pCurFld)->SetSeqNo( rPar2.Copy( nPos + 1 ).ToInt32());
}
break;
}
// Format setzen
// Format wegen NumberFormatter vor SetPar2 einstellen!
pCurFld->ChangeFormat(nFormat);
pCurFld->SetPar1( sPar1 );
if( bSetPar2 )
pCurFld->SetPar2( sPar2 );
// Update anschmeissen
if(nTypeId == TYP_DDEFLD ||
nTypeId == TYP_USERFLD ||
nTypeId == TYP_USRINPFLD)
{
pType->UpdateFlds();
rSh.SetModified();
}
else
rSh.SwEditShell::UpdateFlds(*pCurFld);
rSh.EndAllAction();
}
/*------------------------------------------------------------------------
Beschreibung: Setzen / Erfragen Werte von Benutzerfeldern aus BASIC
------------------------------------------------------------------------*/
BOOL SwFldMgr::SetFieldValue(const String &rFieldName,
const String &rValue)
{
SwWrtShell* pSh = pWrtShell ? pWrtShell : ::lcl_GetShell();
SwUserFieldType* pType = (SwUserFieldType*)pWrtShell->InsertFldType(
SwUserFieldType( pSh->GetDoc(), rFieldName ));
if(pType)
pType->SetContent(rValue);
return 0 != pType;
}
/*------------------------------------------------------------------------
Beschreibung: Wert Datenbankfeld erfragen
------------------------------------------------------------------------*/
String SwFldMgr::GetDataBaseFieldValue(const String &rDBName, const String &rFieldName, SwWrtShell* pSh)
{
String sFieldName(rFieldName);
if (rDBName.Len())
sFieldName = rDBName;
else
sFieldName = pSh->GetDBName();
sFieldName += DB_DELIM;
sFieldName += rFieldName;
SwFieldList aLst(pWrtShell ? pWrtShell : ::lcl_GetShell());
aLst.InsertFields(RES_DBFLD, &sFieldName);
SwField* pFld = aLst.GetLastField();
if(!pFld)
pFld = aLst.GetNextField();
if(pFld)
return pFld->Expand();
return aEmptyStr;
}
/*--------------------------------------------------------------------
Beschreibung: Ist das Datenbankfeld numerisch?
Anm: Im Fehlerfall wird TRUE returnt.
--------------------------------------------------------------------*/
#ifdef REPLACE_OFADBMGR
BOOL SwFldMgr::IsDBNumeric(const String& rDBName, const String& rTblQryName,
BOOL bIsTable, const String& rFldName)
{
BOOL bNumeric = TRUE;
if(!GetDBContext().is() || !xDBContext->hasByName(rDBName))
return bNumeric;
Any aDBSource = xDBContext->getByName(rDBName);
Reference<XDataSource>* pxSource = (Reference<XDataSource>*)aDBSource.getValue();
Reference<XConnection> xConnection;
try
{
OUString sDummy;
xConnection = (*pxSource)->getConnection(sDummy, sDummy);
}
catch(...) {}
Reference<XColumnsSupplier> xColsSupplier;
if(bIsTable)
{
Reference<XTablesSupplier> xTSupplier = Reference<XTablesSupplier>(xConnection, UNO_QUERY);
if(xTSupplier.is())
{
Reference<XNameAccess> xTbls = xTSupplier->getTables();
DBG_ASSERT(xTbls->hasByName(rTblQryName), "table not available anymore?")
try
{
Any aTable = xTbls->getByName(rTblQryName);
Reference<XPropertySet> xPropSet = *(Reference<XPropertySet>*)aTable.getValue();
xColsSupplier = Reference<XColumnsSupplier>(xPropSet, UNO_QUERY);
}
catch(...){}
}
}
else
{
Reference<XQueriesSupplier> xQSupplier = Reference<XQueriesSupplier>(xConnection, UNO_QUERY);
if(xQSupplier.is())
{
Reference<XNameAccess> xQueries = xQSupplier->getQueries();
DBG_ASSERT(xQueries->hasByName(rTblQryName), "table not available anymore?")
try
{
Any aQuery = xQueries->getByName(rTblQryName);
Reference<XPropertySet> xPropSet = *(Reference<XPropertySet>*)aQuery.getValue();
xColsSupplier = Reference<XColumnsSupplier>(xPropSet, UNO_QUERY);
}
catch(...){}
}
}
if(xColsSupplier.is())
{
Reference <XNameAccess> xCols = xColsSupplier->getColumns();
if(xCols.is() && xCols->hasByName(rFldName))
{
Any aCol = xCols->getByName(rFldName);
Reference <XPropertySet> xCol = *(Reference <XPropertySet>*)aCol.getValue();
Any aType = xCol->getPropertyValue(C2S("Type"));
sal_Int32 eDataType;
aType >>= eDataType;
switch(eDataType)
{
case DataType::BIT:
case DataType::TINYINT:
case DataType::SMALLINT:
case DataType::INTEGER:
case DataType::BIGINT:
case DataType::FLOAT:
case DataType::REAL:
case DataType::DOUBLE:
case DataType::NUMERIC:
case DataType::DECIMAL:
case DataType::DATE:
case DataType::TIME:
case DataType::TIMESTAMP:
break;
case DataType::BINARY:
case DataType::VARBINARY:
case DataType::LONGVARBINARY:
case DataType::SQLNULL:
case DataType::OTHER:
case DataType::OBJECT:
case DataType::DISTINCT:
case DataType::STRUCT:
case DataType::ARRAY:
case DataType::BLOB:
case DataType::CLOB:
case DataType::REF:
case DataType::CHAR:
case DataType::VARCHAR:
case DataType::LONGVARCHAR:
default:
bNumeric = FALSE;
}
}
}
return bNumeric;
}
#else
BOOL SwFldMgr::IsDBNumeric(const String& rDBName, USHORT nCol)
{
SwWrtShell *pSh = ::GetActiveView()->GetWrtShellPtr();
String sDBName;
if (!rDBName.Len())
sDBName = pSh->GetDBDesc();
else
sDBName = rDBName;
SwNewDBMgr* pDBMgr = pSh->GetNewDBMgr();
BOOL bRet = TRUE;
if(nCol > 0 && pDBMgr->OpenDB(DBMGR_STD, sDBName, FALSE))
{
short nType = pDBMgr->GetColumnFormatType(DBMGR_STD, nCol);
switch (nType)
{
case dbCurrency:
case dbCounter:
case dbNumeric:
case dbDateTime:
case dbDate:
case dbTime:
case dbBool:
case dbDecimal:
case dbBigInt:
bRet = TRUE;
break;
default:
bRet = FALSE;
break;
}
}
return bRet;
}
BOOL SwFldMgr::IsDBNumeric(const String& rDBName, const String& rFldName)
{
SwWrtShell *pSh = ::GetActiveView()->GetWrtShellPtr();
SwNewDBMgr* pDBMgr = pSh->GetNewDBMgr();
String sDBName;
if (!rDBName.Len())
sDBName = pSh->GetDBDesc();
else
sDBName = rDBName;
if( pDBMgr->OpenDB(DBMGR_STD, sDBName, FALSE))
{
int nCol = pDBMgr->GetColumnPos(DBMGR_STD, rFldName);
if (nCol > 0)
return IsDBNumeric(rDBName, nCol);
}
return TRUE;
}
#endif
/*--------------------------------------------------------------------
Beschreibung: ExpressionFields explizit evaluieren
--------------------------------------------------------------------*/
void SwFldMgr::EvalExpFlds(SwWrtShell* pSh)
{
if (pSh == NULL)
pSh = pWrtShell ? pWrtShell : ::lcl_GetShell();
if(pSh)
{
pSh->StartAllAction();
pSh->UpdateExpFlds(TRUE);
pSh->EndAllAction();
}
}
USHORT SwFldMgr::GetCurrLanguage() const
{
SwWrtShell* pSh = pWrtShell ? pWrtShell : ::lcl_GetShell();
if(pSh)
{
SfxItemSet aSet( pSh->GetAttrPool(), RES_CHRATR_LANGUAGE, RES_CHRATR_LANGUAGE);
pSh->GetAttr(aSet);
return ((const SvxLanguageItem&)aSet.Get( RES_CHRATR_LANGUAGE ) ).GetLanguage();
}
LanguageType eCurLanguage = GetpApp()->GetAppInternational().GetLanguage();
return (USHORT)eCurLanguage;
}
void SwFieldType::_GetFldName()
{
static const USHORT coFldCnt = STR_TYPE_END - STR_TYPE_BEGIN;
static USHORT __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
};
// Infos fuer Felder einfuegen
SwFieldType::pFldNames = new SvStringsDtor( (BYTE)coFldCnt, 2 );
for( USHORT nIdx = 0; nIdx < coFldCnt; ++nIdx )
{
String* pTmp = new SW_RESSTR( coFldNms[ nIdx ] );
pTmp->EraseAllChars('~');
SwFieldType::pFldNames->Insert(pTmp, nIdx );
}
}
BOOL SwFldMgr::SetUserSubType(const String& rName, USHORT nType)
{
BOOL bRet = FALSE;
SwUserFieldType *pType =
(SwUserFieldType *) (pWrtShell ?
pWrtShell->GetFldType(RES_USERFLD, rName) :
::lcl_GetShell()->GetFldType(RES_USERFLD, rName));
if(pType)
{
pType->SetType(nType);
bRet = TRUE;
}
return bRet;
}
BOOL SwFldMgr::InsertURL( const String& rName,
const String& rVal,
const String& rFrame,
const SvxMacroItem* pItem)
{
sCurFrame = rFrame;
pMacroItem = pItem;
BOOL bRet = InsertFld(TYP_INTERNETFLD, 0, rName, rVal, 0);
sCurFrame = aEmptyStr;
pMacroItem = 0;
return bRet;
}
/*--------------------------------------------------------------------
Beschreibung:
--------------------------------------------------------------------*/
BOOL SwFldMgr::ChooseMacro(const String &rSelMacro)
{
String sSelMacro(rSelMacro);
SfxApplication* pSfxApp = SFX_APP();
if (sSelMacro.GetToken(0) == pSfxApp->GetName())
{ // Malte arbeitet (faelschlicherweise) in ChooseMacro mit
// GetTitle statt GetName, daher diese Konvertierung:
sSelMacro.SetToken( 0, ';', Application::GetAppName());
}
else
{
SwWrtShell *pSh = pWrtShell ? pWrtShell : ::lcl_GetShell();
if (pSh)
{
SwDocShell* pDocSh = pSh->GetView().GetDocShell();
if (sSelMacro.GetToken(0) == pDocSh->GetName())
{ // Malte arbeitet (faelschlicherweise) in ChooseMacro mit
// GetTitle statt GetName, daher diese Konvertierung:
sSelMacro.SetToken( 0, ';', pDocSh->GetTitle( SFX_TITLE_FILENAME ));
}
}
}
SbMethod* pMethod = BasicIDE::ChooseMacro(FALSE, TRUE, sSelMacro);
BOOL bRet = FALSE;
if (pMethod)
{
SbModule* pModule = pMethod->GetModule();
SbxObject* pObject = pModule->GetParent();
SetMacroModule(pModule);
ASSERT(pObject->IsA(TYPE(StarBASIC)), "Kein Basic gefunden!");
String sMacro(pMethod->GetName());
sMacro += '.';
sMacro += pModule->GetName();
sMacro += '.';
sMacro += pObject->GetName();
sMacro += '.';
StarBASIC* pLib = (StarBASIC*)pObject;
pSfxApp->EnterBasicCall();
BOOL bFound = FALSE;
BasicManager* pBasicMgr = pSfxApp->GetBasicManager();
SfxObjectShell* pDocShell = 0;
while ( !bFound && pBasicMgr )
{
USHORT nLibs = pBasicMgr->GetLibCount();
for ( USHORT nLib = 0; nLib < nLibs; nLib++ )
{
StarBASIC* pL = pBasicMgr->GetLib( nLib );
if ( pL == pLib )
{
bFound = TRUE;
break;
}
}
if(!bFound)
{
if ( pDocShell )
pDocShell = SfxObjectShell::GetNext( *pDocShell );
else
pDocShell = SfxObjectShell::GetFirst();
}
pBasicMgr = ( pDocShell ? pDocShell->GetBasicManager() : 0 );
}
pSfxApp->LeaveBasicCall();
if(pDocShell)
sMacro += pDocShell->GetName();
else
sMacro += pSfxApp->GetName();
SetMacroPath(sMacro);
bRet = TRUE;
}
return bRet;
}
/*--------------------------------------------------------------------
Beschreibung:
--------------------------------------------------------------------*/
ULONG SwFldMgr::GetDefaultFormat(USHORT nTypeId, 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;
ULONG nNumFmtTime = (ULONG)aTime.GetSec() + (ULONG)aTime.GetMin() * 60L +
(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());
}
#ifdef REPLACE_OFADBMGR
/* -----------------------------23.06.00 17:32--------------------------------
---------------------------------------------------------------------------*/
Reference<XNameAccess> SwFldMgr::GetDBContext()
{
if(!xDBContext.is())
{
Reference< XMultiServiceFactory > xMgr( ::utl::getProcessServiceFactory() );
if( xMgr.is() )
{
Reference<XInterface> xInstance = xMgr->createInstance( C2U( "com.sun.star.sdb.DatabaseContext" ));
xDBContext = Reference<XNameAccess>(xInstance, UNO_QUERY) ;
}
DBG_ASSERT(xDBContext.is(), "com.sun.star.sdb.DataBaseContext: service not available")
}
return xDBContext;
}
#endif
/*************************************************************************
$Log: not supported by cvs2svn $
Revision 1.285 2000/09/18 16:05:29 willem.vandorp
OpenOffice header added.
Revision 1.284 2000/09/07 15:59:23 os
change: SFX_DISPATCHER/SFX_BINDINGS removed
Revision 1.283 2000/09/04 11:43:16 tbe
basicide, isetbrw, si, vcdlged moved from svx to basctl
Revision 1.282 2000/08/15 19:53:15 jp
Bug #76817#: DDE-Field - use the correct format Id's
Revision 1.281 2000/07/18 12:50:08 os
replace ofadbmgr
Revision 1.280 2000/06/30 08:52:52 os
#76541# string assertions removed
Revision 1.279 2000/06/26 13:36:00 os
new DataBase API
Revision 1.278 2000/05/26 07:21:29 os
old SW Basic API Slots removed
Revision 1.277 2000/04/18 15:17:32 os
UNICODE
Revision 1.276 2000/02/11 14:46:35 hr
#70473# changes for unicode ( patched by automated patchtool )
Revision 1.275 1999/10/21 10:50:48 os
SwAuthorityFieldType has SwDoc* member
Revision 1.274 1999/10/11 09:00:11 os
AuthorityField(Type):Import/Export interfaces
Revision 1.273 1999/09/20 09:46:33 os
second param at SwAuthorityField
Revision 1.272 1999/09/15 14:04:02 os
AuthorityField(-Type), RES_AUTHORITY
Revision 1.271 1999/01/12 20:16:08 JP
Bug #60431#: Datenbank Numberformate ggfs. ins Doc uebertragen
Rev 1.270 12 Jan 1999 21:16:08 JP
Bug #60431#: Datenbank Numberformate ggfs. ins Doc uebertragen
Rev 1.269 27 Nov 1998 14:52:16 AMA
Fix #59951#59825#: Unterscheiden zwischen Rahmen-,Seiten- und Bereichsspalten
Rev 1.268 17 Nov 1998 10:50:38 OS
#58263# NumType durch SvxExtNumType ersetzt
Rev 1.267 04 Nov 1998 12:11:08 OM
#58851# Fixe Dateinamenfelder bearbeiten
Rev 1.266 16 Oct 1998 12:55:46 OM
#57970# Zahlenformat Seitenvorlage fuer Statistikfeld
Rev 1.265 15 Oct 1998 16:02:50 OM
#57965# Variablennamen fuer Eingabefeld verwenden
Rev 1.264 15 Sep 1998 16:01:58 OM
#55149# In Dialogen Zahlenformat der Applikation verwenden
Rev 1.263 10 Aug 1998 16:40:00 JP
Bug #54796#: neue NumerierungsTypen (WW97 kompatibel)
Rev 1.262 24 Jul 1998 13:57:04 OM
#53246# Makros vorselektieren
Rev 1.261 07 Jul 1998 17:04:58 OM
#52283# Ueber alle DB-Feldbefehle navigieren
Rev 1.260 18 Jun 1998 11:16:42 OM
Kapitelebenen fuer Nummernkreise
Rev 1.259 20 May 1998 13:24:24 OM
Offset fuer DateTimeFields
Rev 1.258 15 Apr 1998 16:39:34 OM
#47244 SubType nich veraendern
Rev 1.257 26 Mar 1998 17:00:22 OM
Feldbefehl: Seitenanzahl im Html-Mode
Rev 1.256 26 Mar 1998 16:43:06 OM
Feldbefehl: Seitenanzahl im Html-Mode
Rev 1.255 06 Mar 1998 15:31:20 OM
Neue numerische Datenbankformate
Rev 1.254 13 Feb 1998 14:14:50 JP
UpdateFld: TYP_INETFLD gibt es nicht mehr!
Rev 1.253 27 Jan 1998 22:43:52 JP
GetNumDepend durch GetDepends ersetzt
Rev 1.252 13 Jan 1998 15:01:48 OM
Formula-Field wieder unterstuetzt
Rev 1.251 12 Jan 1998 17:10:20 OM
Formelfelder wieder erlauben
Rev 1.250 12 Jan 1998 12:42:58 OM
Nummernkreise nicht doppelt anlegen
Rev 1.249 06 Jan 1998 18:12:56 OM
Felbefehl-Dlg
Rev 1.248 19 Dec 1997 18:24:26 OM
Feldbefehl-bearbeiten Dlg
Rev 1.247 17 Dec 1997 15:23:36 OM
#46218# Korrekte Sprache besorgen
Rev 1.246 16 Dec 1997 17:01:42 OM
Feldbefehle bearbeiten
Rev 1.245 11 Dec 1997 16:58:02 OM
Feldumstellung
Rev 1.244 05 Dec 1997 13:16:38 OM
#45750# DDE-Field Delimiter fuer Basic wandeln
Rev 1.243 28 Nov 1997 19:50:38 MA
includes
Rev 1.242 27 Nov 1997 13:17:18 OM
Variablen-TP
Rev 1.241 25 Nov 1997 12:38:44 OM
Funktionen-TP
Rev 1.240 21 Nov 1997 17:19:44 OM
Feldbefehl-Umstellung: DocInfo
Rev 1.239 18 Nov 1997 14:33:14 OM
Sba-Umstellung 372
Rev 1.238 18 Nov 1997 10:33:12 OM
Neuer Feldbefehldialog
Rev 1.237 14 Nov 1997 11:42:36 OM
Aufgeraeumt
Rev 1.236 30 Oct 1997 14:30:52 OM
Feldbefehl-Umstellung
Rev 1.235 15 Oct 1997 11:57:24 OM
Feldumstellung
Rev 1.234 13 Oct 1997 11:43:16 OM
Feldumstellung
Rev 1.233 09 Oct 1997 16:13:44 OM
Feldumstellung
Rev 1.232 07 Oct 1997 10:51:26 OM
Feldumstellung
Rev 1.231 06 Oct 1997 15:40:44 OM
Feldumstellung
Rev 1.230 02 Oct 1997 15:21:44 OM
Feldumstellung
Rev 1.229 24 Sep 1997 15:18:56 OM
Feldumstellung
Rev 1.228 18 Sep 1997 14:34:02 OM
Feldumstellung
Rev 1.227 02 Sep 1997 09:55:56 OM
SDB-Headeranpassung
Rev 1.226 01 Sep 1997 13:12:40 OS
DLL-Umstellung
Rev 1.225 25 Aug 1997 11:54:20 OS
368-Changes SBA
Rev 1.224 15 Aug 1997 12:11:24 OS
chartar/frmatr/txtatr aufgeteilt
Rev 1.223 09 Aug 1997 13:17:38 OS
paraitem/frmitems/textitem aufgeteilt
Rev 1.222 05 Aug 1997 12:38:24 MH
chg: header
Rev 1.221 09 Jul 1997 17:33:24 HJS
includes
Rev 1.220 29 May 1997 16:16:00 OM
URL in ScriptDialog eingeben
Rev 1.219 29 Apr 1997 16:10:22 OM
Unsichtbare Benutzerfelder
Rev 1.218 28 Apr 1997 16:31:04 JP
SetFldValue: immer einen FldTypen anlegen.
Rev 1.217 08 Apr 1997 10:32:42 MA
includes
Rev 1.216 04 Apr 1997 10:32:28 OM
Datenbanken nach Gebrauch wieder schliessen
Rev 1.215 14 Mar 1997 14:07:22 OM
#37666# GPF beim Bearbeiten alter 3.x DB-Feldbefehlen behoben
Rev 1.214 11 Mar 1997 13:15:12 OM
Datenbank beim Feldeinfuegen am Dok setzen
Rev 1.213 26 Feb 1997 02:22:20 OM
#37068# Feldbefhel-Dlg GPF gefixt
Rev 1.212 25 Feb 1997 20:04:10 OM
GPF in Feldbefehlen behoben
Rev 1.211 24 Feb 1997 20:29:30 OM
Offset-Fehler behoben
Rev 1.210 23 Feb 1997 21:14:42 OM
Aufgeraeumt
Rev 1.209 23 Feb 1997 15:05:54 OS
SetFieldValue liefert BOOL
Rev 1.208 22 Feb 1997 21:22:58 OM
Aufgeraeumt
Rev 1.207 22 Feb 1997 16:43:14 OM
Basic-Umstellung: OpenColumn
Rev 1.206 17 Feb 1997 10:39:18 OM
Neue Feldbefehle im Webmode
Rev 1.205 16 Feb 1997 10:48:20 OM
DBMGR an Ofa verschoben
Rev 1.204 13 Feb 1997 17:37:42 OM
Neu: javaedit
Rev 1.203 11 Feb 1997 16:52:04 OM
Eingabefeld ueber Basic ohne Dialog einfuegen
Rev 1.202 09 Feb 1997 16:34:06 OM
Variable setzen: html_on/off
Rev 1.201 07 Feb 1997 17:19:50 OM
Web-Mode fuer Feldbefehle-Dlg
Rev 1.200 07 Feb 1997 11:34:14 OM
Web-Mode fuer FeldbefehlDlg
Rev 1.199 05 Feb 1997 09:35:56 OM
Verschiebung in den Bereichen behoben
Rev 1.198 03 Feb 1997 17:08:58 OM
InsertURL aus Feldbefehl-Dlg entfernt
Rev 1.197 29 Jan 1997 13:14:18 MA
unbenutzes entfernt
Rev 1.196 17 Dec 1996 15:37:46 OM
Macrofelder editieren
Rev 1.195 11 Dec 1996 10:21:04 MA
Warnings
Rev 1.194 26 Nov 1996 20:39:32 JP
RefFelder werden jetzt mit&nach den ExpFeldern aktualisiert
Rev 1.193 13 Nov 1996 15:00:58 JP
neuer FeldTyp fuer Scripts (z.B. JavaScript)
Rev 1.192 11 Nov 1996 09:55:52 MA
ResMgr
Rev 1.191 08 Nov 1996 14:55:58 JP
ueberfluessiges Include entfernt
Rev 1.190 07 Nov 1996 15:46:56 JP
Bug #33084#: Referenzen nach einfuegen updaten
Rev 1.189 05 Nov 1996 22:45:06 JP
UpdateCurFld..() entfernt - ueberflussig; UpdateFld: GetRefFld sonderbehandelt
Rev 1.188 05 Nov 1996 15:32:42 JP
Umstellungen fuer neue Referenz-Seite
Rev 1.187 01 Nov 1996 03:55:46 MH
add: includes
Rev 1.186 24 Oct 1996 13:36:20 JP
String Umstellung: [] -> GetChar()
Rev 1.185 25 Sep 1996 14:11:48 OM
Neue Datenbanktrenner
Rev 1.184 19 Sep 1996 14:32:30 OM
Datenbank Basicanbindung
Rev 1.183 02 Sep 1996 18:43:00 JP
INetFeld entfernt
Rev 1.182 30 Aug 1996 12:45:42 OS
UpdateGlosPath kann Blockliste aktualisieren
Rev 1.181 28 Aug 1996 12:11:14 OS
includes
Rev 1.180 21 Aug 1996 13:08:52 OS
Manager gfs. mit wrtshell konstruieren
Rev 1.179 20 Aug 1996 17:22:18 JP
Bug #30489#: Mehrfachselektion bei SetRef-Feldern abklemmen
Rev 1.178 16 Aug 1996 11:27:56 OM
Dokinfo aufgegliedert
Rev 1.177 15 Aug 1996 09:56:44 AMA
Fix: Macros am INetFmt setzen.
Rev 1.176 12 Aug 1996 10:50:04 AMA
Chg: SwFmtINetFmt jetzt mit TargetFrame im CTor.
Rev 1.175 08 Aug 1996 15:33:34 AMA
New: Benutze InsertURL (als Textattribut) an der EditShell
Rev 1.174 05 Aug 1996 15:18:24 OM
Datenbankumstellung
Rev 1.173 25 Jul 1996 16:41:54 OM
Umstellung auf Tabellen
Rev 1.172 23 Jul 1996 14:29:40 JP
PageNext/-Prev: mit Offset; InsertField: nach Left auch wieder ein Right rufen
Rev 1.171 10 Jul 1996 17:47:56 OM
LocalizeDBName in Expfld verschoben
*************************************************************************/
Reference in New Issue Copy Permalink