path: root/sw/inc/tox.hxx

/*************************************************************************
 *
 *  $RCSfile: tox.hxx,v $
 *
 *  $Revision: 1.2 $
 *
 *  last change: $Author: jp $ $Date: 2000-10-05 12:04:44 $
 *
 *  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): _______________________________________
 *
 *
 ************************************************************************/
#ifndef _TOX_HXX
#define _TOX_HXX

#ifndef _SVARRAY_HXX //autogen
#include <svtools/svarray.hxx>
#endif

#ifndef _STRING_HXX //autogen
#include <tools/string.hxx>
#endif

#ifndef _SFXPOOLITEM_HXX //autogen
#include <svtools/poolitem.hxx>
#endif

#ifndef _SWTYPES_HXX
#include <swtypes.hxx>
#endif
#ifndef _TOXE_HXX
#include <toxe.hxx>
#endif
#ifndef _CALBCK_HXX
#include <calbck.hxx>
#endif
#ifndef _ERRHDL_HXX
#include <errhdl.hxx>
#endif

class SwTOXType;
class SwTOXMark;
class SwTxtTOXMark;
class SwDoc;

SV_DECL_PTRARR(SwTOXMarks, SwTOXMark*, 0, 10)

/*--------------------------------------------------------------------
     Beschreibung:  Eintrag fuer Inhaltsverzeichnis oder Benutzerverz.
 --------------------------------------------------------------------*/

#define IVER_TOXMARK_STRPOOL ((USHORT)1)
#define IVER_TOXMARK_NEWTOX ((USHORT)2)

class SwTOXMark : public SfxPoolItem, public SwClient
{
    friend void _InitCore();
    friend class SwTxtTOXMark;

    String aAltText;    // Der Text des Eintrages ist unterschiedlich
    String aPrimaryKey, aSecondaryKey;

    SwTxtTOXMark* pTxtAttr;

    USHORT  nLevel;
    BOOL    bAutoGenerated : 1;     // generated using a concordance file
    BOOL    bMainEntry : 1;         // main entry emphasized by character style


    SwTOXMark();                    // for crete the dflt. atr. in _InitCore

public:
    TYPEINFO();   // fuers rtti

    SwTOXMark( const SwTOXType* pTyp );
    SwTOXMark( const SwTOXMark& rCopy );
    virtual ~SwTOXMark();

    // "pure virtual Methoden" vom SfxPoolItem
    virtual int             operator==( const SfxPoolItem& ) const;
    virtual SfxPoolItem*    Clone( SfxItemPool* pPool = 0 ) const;
    virtual SfxPoolItem*    Create(SvStream &, USHORT nVer) const;
    virtual SvStream&       Store(SvStream &, USHORT nIVer) const;
    virtual USHORT          GetVersion( USHORT nFFVer ) const;

    SwTOXMark&              operator=( const SwTOXMark& rCopy );
    String                  GetText() const;

    inline BOOL             IsAlternativeText() const;
    inline const String&    GetAlternativeText() const;

    inline void             SetAlternativeText( const String& rAlt );

    // Inhalts-/Benutzerverzeichnis - spezifisch
    inline void             SetLevel(USHORT nLevel);
    inline USHORT           GetLevel() const;

    // Index - spezifisch
    inline void             SetPrimaryKey(const String& rStr );
    inline void             SetSecondaryKey(const String& rStr);
    inline const String&    GetPrimaryKey() const;
    inline const String&    GetSecondaryKey() const;

    BOOL                    IsAutoGenerated() const {return bAutoGenerated;}
    void                    SetAutoGenerated(BOOL bSet) {bAutoGenerated = bSet;}

    BOOL                    IsMainEntry() const {return bMainEntry;}
    void                    SetMainEntry(BOOL bSet) { bMainEntry = bSet;}

    inline const SwTOXType*    GetTOXType() const;

    const SwTxtTOXMark* GetTxtTOXMark() const   { return pTxtAttr; }
          SwTxtTOXMark* GetTxtTOXMark()         { return pTxtAttr; }
};

/*--------------------------------------------------------------------
     Beschreibung:  Typen einzelner Verzeichnisse
 --------------------------------------------------------------------*/

class SwTOXType : public SwModify
{
public:
    SwTOXType(TOXTypes eTyp, const String& aName);
    SwTOXType(const SwTOXType& rCopy);

    inline  const String&   GetTypeName() const;
    void                    SetTypeName(const String& rName);
    inline TOXTypes         GetType() const;

private:
    String          aName;
    TOXTypes        eType;
};

/*--------------------------------------------------------------------
     Beschreibung:  Muster fuer Zeilen eines Verzeichnisses
 --------------------------------------------------------------------*/

#define FORM_TITLE              0
#define FORM_ALPHA_DELIMITTER   1
#define FORM_PRIMARY_KEY        2
#define FORM_SECONDARY_KEY      3
#define FORM_ENTRY              4

/*
 Pattern structure

 <E#> - entry number                    <E# CharStyleName,PoolId>
 <ET> - entry text                      <ET CharStyleName,PoolId>
 <E>  - entry text and number           <E CharStyleName,PoolId>
 <T>  - tab stop                        <T,,Position,Adjust>
 <C>  - chapter info n = {0, 1, 2, 3, 4 } values of SwChapterFormat <C CharStyleName,PoolId>
 <TX> - text token                      <X CharStyleName,PoolId, TOX_STYLE_DELIMITERTextContentTOX_STYLE_DELIMITER>
 <#>  - Page number                     <# CharStyleName,PoolId>
 <LS> - Link start                      <LS>
 <LE> - Link end                        <LE>
 <A00> - Authority entry field          <A02 CharStyleName, PoolId>
 */

// These enum values are stored and must not change!
enum FormTokenType
{
    TOKEN_ENTRY_NO,
    TOKEN_ENTRY_TEXT,
    TOKEN_ENTRY,
    TOKEN_TAB_STOP,
    TOKEN_TEXT,
    TOKEN_PAGE_NUMS,
    TOKEN_CHAPTER_INFO,
    TOKEN_LINK_START,
    TOKEN_LINK_END,
    TOKEN_AUTHORITY,
    TOKEN_END
};

struct SwFormToken
{
    String          sText;
    String          sCharStyleName;
    SwTwips         nTabStopPosition;
    FormTokenType   eTokenType;
    USHORT          nPoolId;
    USHORT          eTabAlign;
    USHORT          nChapterFormat;     //SwChapterFormat;
    USHORT          nAuthorityField;    //enum ToxAuthorityField
    sal_Unicode     cTabFillChar;

    SwFormToken(FormTokenType eType ) :
        eTokenType(eType),
        nTabStopPosition(ULONG_MAX),
        nPoolId(USHRT_MAX),
        eTabAlign(0 /*SVX_TAB_ADJUST_LEFT*/),
        cTabFillChar(' '),
        nChapterFormat(0 /*CF_NUMBER*/),
        nAuthorityField(0)/*AUTH_FIELD_IDENTIFIER*/{}

    String GetString() const;
};

class SwFormTokenEnumerator
{
    String sPattern;
    xub_StrLen nCurPatternPos;
    xub_StrLen nCurPatternLen;

    FormTokenType _SearchNextToken( xub_StrLen nStt, xub_StrLen& rEnd,
                                    xub_StrLen* pTokenLen = 0 ) const;
    SwFormToken BuildToken( FormTokenType, xub_StrLen ) const;

public:
    SwFormTokenEnumerator( const String& rPattern );
    BOOL            HasNextToken() const
        { return nCurPatternPos + nCurPatternLen < sPattern.Len(); }

    SwFormToken     GetNextToken();
    SwFormToken     GetCurToken() const;

    FormTokenType   GetCurTokenType();
    FormTokenType   GetNextTokenType();
    FormTokenType   GetPrevTokenType();
    void            RemoveCurToken();
    void            InsertToken( const SwFormToken& rToken );
    const String&   GetPattern() const      { return sPattern; }
};

class SwForm
{
    String  aPattern[ AUTH_TYPE_END + 1 ];
    String  aTemplate[ AUTH_TYPE_END + 1 ];
    USHORT  nType, nFormMaxLevel;
    //USHORT    nFirstTabPos; -> Value in tab token
//  BOOL    bHasFirstTabPos : 1;
    BOOL    bGenerateTabPos : 1;
    BOOL    bIsRelTabPos : 1;
    BOOL    bCommaSeparated : 1;

public:
    SwForm( USHORT nType = TOX_CONTENT );
    SwForm( const SwForm& rForm );

    SwForm& operator=( const SwForm& rForm );

    inline void             SetTemplate(USHORT nLevel, const String& rName);
    inline const String&    GetTemplate(USHORT nLevel) const;

    inline void             SetPattern(USHORT nLevel, const String& rName);
    inline const String&    GetPattern(USHORT nLevel) const;

    //convert pattern string from old to new format or vice versa
    static String           ConvertPatternTo51(const String& rSource);
    static String           ConvertPatternFrom51(const String& rSource, TOXTypes eType);

    // fill tab stop positions from template to pattern
    void                    AdjustTabStops(SwDoc& rDoc);

    SwFormTokenEnumerator   CreateTokenEnumerator(USHORT nLevel) const
        {return SwFormTokenEnumerator(GetPattern(nLevel));}

    inline USHORT   GetTOXType() const;
    inline USHORT   GetFormMax() const;

    USHORT GetFirstTabPos() const  ;    //{ return nFirstTabPos; }
    void SetFirstTabPos( USHORT n );    //{ nFirstTabPos = n; }

    BOOL IsFirstTabPosFlag() const  ;   //{ return bHasFirstTabPos; }
    void SetFirstTabPosFlag( BOOL b );  //{ bHasFirstTabPos = b; }

    BOOL IsGenerateTabPos() const       { return bGenerateTabPos; }
    void SetGenerateTabPos( BOOL b )    { bGenerateTabPos = b; }

    BOOL IsRelTabPos() const    {   return bIsRelTabPos; }
    void SetRelTabPos( BOOL b ) {   bIsRelTabPos = b;       }

    BOOL IsCommaSeparated() const       { return bCommaSeparated;}
    void SetCommaSeparated( BOOL b)     { bCommaSeparated = b;}

    static USHORT GetFormMaxLevel( USHORT nType );

    static const sal_Char*  aFormEntry;             // <E>
    static BYTE nFormEntryLen;                      // 3 Zeichen
    static const sal_Char*  aFormTab;               // <T>
    static BYTE nFormTabLen;                        // 3 Zeichen
    static const sal_Char*  aFormPageNums;          // <P>
    static BYTE nFormPageNumsLen;                   // 3 Zeichen
    static const sal_Char* aFormLinkStt;            // <LS>
    static BYTE nFormLinkSttLen;                    // 4 Zeichen
    static const sal_Char* aFormLinkEnd;            // <LE>
    static BYTE nFormLinkEndLen;                    // 4 Zeichen
    static const sal_Char*  aFormEntryNum;          // <E#>
    static BYTE nFormEntryNumLen;                   // 4 Zeichen
    static const sal_Char*  aFormEntryTxt;          // <ET>
    static BYTE nFormEntryTxtLen;                   // 4 Zeichen
    static const sal_Char*  aFormChapterMark;       // <C>
    static BYTE nFormChapterMarkLen;                // 3 Zeichen
    static const sal_Char*  aFormText;              // <TX>
    static BYTE nFormTextLen;                       // 4 Zeichen
    static const sal_Char*  aFormAuth;              // <Axx> xx - decimal enum value
    static BYTE nFormAuthLen;                       // 3 chars
};

/*--------------------------------------------------------------------
     Beschreibung: Inhalte aus denen Verzeichnisse generiert werden
 --------------------------------------------------------------------*/

enum SwTOXElement
{
    TOX_MARK            = 1,
    TOX_OUTLINELEVEL    = 2,
    TOX_TEMPLATE        = 4,
    TOX_OLE             = 8,
    TOX_TABLE           = 16,
    TOX_GRAPHIC         = 32,
    TOX_FRAME           = 64,
    TOX_SEQUENCE        = 128
};

enum SwTOIOptions
{
    TOI_SAME_ENTRY          = 1,
    TOI_FF                  = 2,
    TOI_CASE_SENSITIVE      = 4,
    TOI_KEY_AS_ENTRY        = 8,
    TOI_ALPHA_DELIMITTER    = 16,
    TOI_DASH                = 32,
    TOI_INITIAL_CAPS        = 64
};

//which part of the caption is to be displayed
enum SwCaptionDisplay
{
    CAPTION_COMPLETE,
    CAPTION_NUMBER,
    CAPTION_TEXT
};

enum SwTOOElements
{
    TOO_MATH        = 0x01,
    TOO_CHART       = 0x02,
    TOO_CALC        = 0x08,
    TOO_DRAW_IMPRESS= 0x10,
//  TOO_IMPRESS     = 0x20,

    TOO_OTHER       = 0x80
};

#define TOX_STYLE_DELIMITER ((sal_Unicode)0x01)     //JP 19.07.00: use a control char

/*--------------------------------------------------------------------
     Beschreibung:  Klasse aller  Verzeichnisse
 --------------------------------------------------------------------*/

class SwTOXBase : public SwClient
{
    // not implemented
    SwTOXBase&          operator=(const SwTOXBase& rSource);

//protected:

    SwForm      aForm;              // Aussehen  der Eintragzeile
    String      aName;              // unique name
    String      aTitle;             // Der Verzeichnistitel

    String      sMainEntryCharStyle; // name of the character style applied to main index entries

    String      aStyleNames[MAXLEVEL]; // (additional) style names TOX_CONTENT, TOX_USER
    String      sSequenceName;      // FieldTypeName of a caption sequence

    union {
        USHORT      nLevel;             // Gliederungsebenen beachten
        USHORT      nOptions;           // Optionen fuer Index
    } aData;

    USHORT      nCreateType;        // Quellen aus dem das Verzeichnis generiert wird
    USHORT      nOLEOptions;        // OLE sources
    SwCaptionDisplay eCaptionDisplay;   //
    BOOL        bProtected : 1;         // index protected ?
    BOOL        bFromChapter : 1;       // create from chapter or document
    BOOL        bFromObjectNames : 1;   // create a table or object index
                                    // from the names rather than the caption
    BOOL        bLevelFromChapter : 1; // User index: get the level from the source chapter
public:
    SwTOXBase( const SwTOXType* pTyp, const SwForm& rForm,
               USHORT nCreaType, const String& rTitle );
    SwTOXBase( const SwTOXBase& rCopy, SwDoc* pDoc = 0 );
    virtual ~SwTOXBase();

    virtual BOOL GetInfo( SfxPoolItem& rInfo ) const;

    // a kind of CopyCtor - check if the TOXBase is at TOXType of the doc.
    // If not, so create it an copy all other used things. The return is this
    SwTOXBase& CopyTOXBase( SwDoc*, const SwTOXBase& );

    const SwTOXType*    GetTOXType() const; //

    USHORT              GetCreateType() const;      // Aus Inhaltsformen generieren

    const String&       GetTOXName() const {return aName;}
    void                SetTOXName(const String& rSet) {aName = rSet;}

    const String&       GetTitle() const;           // Titel des Verzeichnisses
    const String&       GetTypeName() const;        // Name des Verzeichnisses
    const SwForm&       GetTOXForm() const;         // Aussehen der Zeile

    void                SetCreate(USHORT);
    void                SetTitle(const String& rTitle);
    void                SetTOXForm(const SwForm& rForm);

    TOXTypes            GetType() const;

    const String&       GetMainEntryCharStyle() const {return sMainEntryCharStyle;}
    void                SetMainEntryCharStyle(const String& rSet)  {sMainEntryCharStyle = rSet;}

    // Inhaltsverzeichnis - spezifisch
    inline void             SetLevel(USHORT);                   // Gliederungsebene beachten
    inline USHORT           GetLevel() const;

    // Index - spezifisch
    inline USHORT           GetOptions() const;                 // Optionen fuer Index
    inline void             SetOptions(USHORT nOpt);

    // index of objects
    USHORT      GetOLEOptions() const {return nOLEOptions;}
    void        SetOLEOptions(USHORT nOpt) {nOLEOptions = nOpt;}

    // index of objects

    // Benutzerverzeichnis - spezifisch
    inline void             SetTemplateName(const String& rName); // Absatzlayout beachten
    inline String           GetTemplateName() const;

    const String&           GetStyleNames(USHORT nLevel) const
                                {
                                DBG_ASSERT( nLevel < MAXLEVEL, "Which level?");
                                return aStyleNames[nLevel];
                                }
    void                    SetStyleNames(const String& rSet, USHORT nLevel)
                                {
                                DBG_ASSERT( nLevel < MAXLEVEL, "Which level?");
                                aStyleNames[nLevel] = rSet;
                                }
    BOOL                    HasAnyStyleNames() const;

    BOOL                    IsFromChapter() const { return bFromChapter;}
    void                    SetFromChapter(BOOL bSet) { bFromChapter = bSet;}

    BOOL                    IsFromObjectNames() const {return bFromObjectNames;}
    void                    SetFromObjectNames(BOOL bSet) {bFromObjectNames = bSet;}

    BOOL                    IsLevelFromChapter() const {return bLevelFromChapter;}
    void                    SetLevelFromChapter(BOOL bSet) {bLevelFromChapter = bSet;}

    BOOL                    IsProtected() const { return bProtected; }
    void                    SetProtected(BOOL bSet) { bProtected = bSet; }

    const String&           GetSequenceName() const {return sSequenceName;}
    void                    SetSequenceName(const String& rSet) {sSequenceName = rSet;}

    SwCaptionDisplay        GetCaptionDisplay() const { return eCaptionDisplay;}
    void                    SetCaptionDisplay(SwCaptionDisplay eSet) {eCaptionDisplay = eSet;}

    BOOL                    IsTOXBaseInReadonly() const;

    const SfxItemSet*       GetAttrSet() const;
    void                    SetAttrSet( const SfxItemSet& );

    static const String&    GetTOXName(TOXTypes eType);           // toxmgr.cxx

};


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

//
//SwTOXMark
//
inline const String& SwTOXMark::GetAlternativeText() const
    {   return aAltText;    }

inline const SwTOXType* SwTOXMark::GetTOXType() const
    { return (SwTOXType*)GetRegisteredIn(); }

inline BOOL SwTOXMark::IsAlternativeText() const
    { return aAltText.Len() > 0; }

inline void SwTOXMark::SetAlternativeText(const String& rAlt)
{
    aAltText = rAlt;
}

inline void SwTOXMark::SetLevel( USHORT nLvl )
{
    ASSERT( !GetTOXType() || GetTOXType()->GetType() != TOX_INDEX, "Falscher Feldtyp");
    nLevel = nLvl;
}

inline void SwTOXMark::SetPrimaryKey( const String& rKey )
{
    ASSERT(GetTOXType()->GetType() == TOX_INDEX, "Falscher Feldtyp");
    aPrimaryKey = rKey;
}

inline void SwTOXMark::SetSecondaryKey( const String& rKey )
{
    ASSERT(GetTOXType()->GetType() == TOX_INDEX, "Falscher Feldtyp");
    aSecondaryKey = rKey;
}

inline USHORT SwTOXMark::GetLevel() const
{
    ASSERT( !GetTOXType() || GetTOXType()->GetType() != TOX_INDEX, "Falscher Feldtyp");
    return nLevel;
}

inline const String& SwTOXMark::GetPrimaryKey() const
{
    ASSERT(GetTOXType()->GetType() == TOX_INDEX, "Falscher Feldtyp");
    return aPrimaryKey;
}

inline const String& SwTOXMark::GetSecondaryKey() const
{
    ASSERT(GetTOXType()->GetType() == TOX_INDEX, "Falscher Feldtyp");
    return aSecondaryKey;
}


//
//SwForm
//
inline void SwForm::SetTemplate(USHORT nLevel, const String& rName)
{
    ASSERT(nLevel < GetFormMax(), "Index >= FORM_MAX");
    aTemplate[nLevel] = rName;
}

inline void SwForm::SetPattern(USHORT nLevel, const String& rName)
{
    ASSERT(nLevel < GetFormMax(), "Index >= FORM_MAX");
    aPattern[nLevel] = rName;
}

inline const String& SwForm::GetPattern(USHORT nLevel) const
{
    ASSERT(nLevel < GetFormMax(), "Index >= FORM_MAX");
    return aPattern[nLevel];
}

inline const String& SwForm::GetTemplate(USHORT nLevel) const
{
    ASSERT(nLevel < GetFormMax(), "Index >= FORM_MAX");
    return aTemplate[nLevel];
}

inline USHORT SwForm::GetTOXType() const
{
    return nType;
}

inline USHORT SwForm::GetFormMax() const
{
    return nFormMaxLevel;
}


//
//SwTOXType
//
inline const String& SwTOXType::GetTypeName() const
    {   return aName;   }

inline void SwTOXType::SetTypeName(const String& rName)
    {   aName = rName;  }

inline TOXTypes SwTOXType::GetType() const
    {   return eType;   }

//
// SwTOXBase
//
inline const SwTOXType* SwTOXBase::GetTOXType() const
    { return (SwTOXType*)GetRegisteredIn(); }

inline USHORT SwTOXBase::GetCreateType() const
    { return nCreateType; }

inline const String& SwTOXBase::GetTitle() const
    { return aTitle; }

inline const String& SwTOXBase::GetTypeName() const
    { return GetTOXType()->GetTypeName();  }

inline const SwForm& SwTOXBase::GetTOXForm() const
    { return aForm; }

inline void SwTOXBase::SetCreate(USHORT nCreate)
    { nCreateType = nCreate; }

inline void SwTOXBase::SetTitle(const String& rTitle)
    {   aTitle = rTitle; }

inline void SwTOXBase::SetTOXForm(const SwForm& rForm)
    {  aForm = rForm; }

inline TOXTypes SwTOXBase::GetType() const
    { return GetTOXType()->GetType(); }

inline void SwTOXBase::SetLevel(USHORT nLev)
{
    ASSERT(GetTOXType()->GetType() != TOX_INDEX, "Falscher Feldtyp");
    aData.nLevel = nLev;
}

inline USHORT SwTOXBase::GetLevel() const
{
    ASSERT(GetTOXType()->GetType() != TOX_INDEX, "Falscher Feldtyp");
    return aData.nLevel;
}

inline void SwTOXBase::SetTemplateName(const String& rName)
{
//  ASSERT(GetTOXType()->GetType() == TOX_USER, "Falscher Feldtyp");
//  ASSERT(aData.pTemplateName, "pTemplateName == 0");
//  (*aData.pTemplateName) = rName;
    DBG_WARNING("SwTOXBase::SetTemplateName obsolete")
    aStyleNames[0] = rName;

}

inline String SwTOXBase::GetTemplateName() const
{
//  ASSERT(GetTOXType()->GetType() == TOX_USER, "Falscher Feldtyp");
//  return *aData.pTemplateName;
    DBG_WARNING("SwTOXBase::GetTemplateName obsolete")
    return aStyleNames[0].GetToken(0, TOX_STYLE_DELIMITER);
}

inline USHORT SwTOXBase::GetOptions() const
{
    ASSERT(GetTOXType()->GetType() == TOX_INDEX, "Falscher Feldtyp");
    return aData.nOptions;
}

inline void SwTOXBase::SetOptions(USHORT nOpt)
{
    ASSERT(GetTOXType()->GetType() == TOX_INDEX, "Falscher Feldtyp");
    aData.nOptions = nOpt;
}


#endif  // _TOX_HXX