xref: /trunk/main/sw/source/ui/index/cnttab.cxx (revision d05a678705c51acd00d01d5f3bcd5d62d773da66)

/**************************************************************
 *
 * 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"
#ifdef SW_DLLIMPLEMENTATION
#undef SW_DLLIMPLEMENTATION
#endif


#include <rsc/rscsfx.hxx>
#include <vcl/msgbox.hxx>
#include <vcl/help.hxx>
#include <svl/stritem.hxx>
#include <svl/urihelper.hxx>
#include <unotools/pathoptions.hxx>
#include <sfx2/request.hxx>
#include <sfx2/viewfrm.hxx>
#include <sfx2/dispatch.hxx>
#include <sfx2/docfile.hxx>
#include <svx/dialogs.hrc>
#include <svx/svxdlg.hxx>
#include <svx/flagsdef.hxx>
#include <svx/simptabl.hxx>
#include <com/sun/star/ui/dialogs/TemplateDescription.hpp>
#include <com/sun/star/ui/dialogs/XFilePicker.hpp>
#include <com/sun/star/ui/dialogs/XFilterManager.hpp>
#include <svtools/indexentryres.hxx>
#include <editeng/unolingu.hxx>
#include <column.hxx>
#include <fmtfsize.hxx>
#include <shellio.hxx>
#include <authfld.hxx>
#include <swtypes.hxx>
#include <wrtsh.hxx>
#ifndef _VIEW_HXX
#include <view.hxx>
#endif
#ifndef _BASESH_HXX
#include <basesh.hxx>
#endif
#include <outline.hxx>
#include <cnttab.hxx>
#include <swuicnttab.hxx>
#include <formedt.hxx>
#include <poolfmt.hxx>
#ifndef _POOLFMT_HRC
#include <poolfmt.hrc>
#endif
#include <uitool.hxx>
#include <fmtcol.hxx>
#include <fldbas.hxx>
#include <expfld.hxx>
#include <unotools.hxx>
#include <unotxdoc.hxx>
#include <docsh.hxx>
#include <swmodule.hxx>
#include <modcfg.hxx>

#ifndef _CMDID_H
#include <cmdid.h>
#endif
#ifndef _HELPID_H
#include <helpid.h>
#endif
#ifndef _UTLUI_HRC
#include <utlui.hrc>
#endif
#ifndef _INDEX_HRC
#include <index.hrc>
#endif
#ifndef _CNTTAB_HRC
#include <cnttab.hrc>
#endif
#ifndef _GLOBALS_HRC
#include <globals.hrc>
#endif
#include <SwStyleNameMapper.hxx>
#include <sfx2/filedlghelper.hxx>
#ifndef _TOXHLP_HXX
#include <toxwrap.hxx>
#endif
#include <chpfld.hxx>

#ifndef _UTLUI_HRC
#include "utlui.hrc"
#endif

#include <sfx2/app.hxx>

#include <unomid.h>
using namespace ::com::sun::star;
using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::uno;
using namespace com::sun::star::ui::dialogs;
using ::rtl::OUString;
using namespace ::sfx2;
#include <svtools/editbrowsebox.hxx>

static const sal_Unicode aDeliStart = '['; //fuer die form
static const sal_Unicode aDeliEnd    = ']'; //fuer die form

#define POS_GRF     0
#define POS_OLE     1
#define POS_TABLE   2
#define POS_FRAME   3

#define IDX_FILE_EXTENSION String::CreateFromAscii( \
                            RTL_CONSTASCII_STRINGPARAM( "*.sdi" ))


/* -----------------14.06.99 13:10-------------------

 --------------------------------------------------*/
String lcl_CreateAutoMarkFileDlg( const String& rURL,
                                const String& rFileString, sal_Bool bOpen )
{
    String sRet;

    FileDialogHelper aDlgHelper( bOpen ?
                TemplateDescription::FILEOPEN_SIMPLE : TemplateDescription::FILESAVE_AUTOEXTENSION, 0 );
    uno::Reference < XFilePicker > xFP = aDlgHelper.GetFilePicker();

    uno::Reference<XFilterManager> xFltMgr(xFP, UNO_QUERY);
    String sCurFltr( IDX_FILE_EXTENSION );
    xFltMgr->appendFilter( rFileString, sCurFltr );
    xFltMgr->setCurrentFilter( rFileString ) ;

    String& rLastSaveDir = (String&)SFX_APP()->GetLastSaveDirectory();
    String sSaveDir = rLastSaveDir;

    if( rURL.Len() )
        xFP->setDisplayDirectory( rURL );
    else
    {
        SvtPathOptions aPathOpt;
        xFP->setDisplayDirectory( aPathOpt.GetUserConfigPath() );
    }

    if( aDlgHelper.Execute() == ERRCODE_NONE )
    {
        sRet = xFP->getFiles().getConstArray()[0];
    }
    rLastSaveDir = sSaveDir;
    return sRet;
}
/* -----------------------------19.01.00 11:09--------------------------------

 ---------------------------------------------------------------------------*/
struct AutoMarkEntry
{
    String sSearch;
    String sAlternative;
    String sPrimKey;
    String sSecKey;
    String sComment;
    sal_Bool    bCase;
    sal_Bool    bWord;

    AutoMarkEntry() :
        bCase(sal_False),
        bWord(sal_False){}
};
typedef AutoMarkEntry* AutoMarkEntryPtr;
SV_DECL_PTRARR_DEL(AutoMarkEntryArr, AutoMarkEntryPtr, 0, 4)
SV_IMPL_PTRARR(AutoMarkEntryArr, AutoMarkEntryPtr);

typedef ::svt::EditBrowseBox SwEntryBrowseBox_Base;
class SwEntryBrowseBox : public SwEntryBrowseBox_Base
{
    Edit                    aCellEdit;
    ::svt::CheckBoxControl  aCellCheckBox;

    String  sSearch;
    String  sAlternative;
    String  sPrimKey;
    String  sSecKey;
    String  sComment;
    String  sCaseSensitive;
    String  sWordOnly;
    String  sYes;
    String  sNo;

    AutoMarkEntryArr    aEntryArr;

    ::svt::CellControllerRef    xController;
    ::svt::CellControllerRef    xCheckController;

    long    nCurrentRow;
    sal_Bool    bModified;


    void                        SetModified() {bModified = sal_True;}

protected:
    virtual sal_Bool                SeekRow( long nRow );
//  virtual void                PaintField( OutputDevice& rDev, const awt::Rectangle& rRect,
//                                          sal_uInt16 nColumnId ) const;
    virtual void                    PaintCell(OutputDevice& rDev, const Rectangle& rRect, sal_uInt16 nColId) const;
    virtual void                    InitController(::svt::CellControllerRef& rController, long nRow, sal_uInt16 nCol);
    virtual ::svt::CellController*  GetController(long nRow, sal_uInt16 nCol);
    virtual sal_Bool                SaveModified();

public:
                    SwEntryBrowseBox(Window* pParent, const ResId& rId,
                               BrowserMode nMode = 0 );
    void    ReadEntries(SvStream& rInStr);
    void    WriteEntries(SvStream& rOutStr);

    sal_Bool                        IsModified()const;

    virtual String GetCellText( long nRow, sal_uInt16 nColumn ) const;
};

class SwAutoMarkDlg_Impl : public ModalDialog
{
    OKButton            aOKPB;
    CancelButton        aCancelPB;
    HelpButton          aHelpPB;

    SwEntryBrowseBox    aEntriesBB;
    FixedLine           aEntriesFL;

    String              sAutoMarkURL;
    const String        sAutoMarkType;

    sal_Bool                bCreateMode;

    DECL_LINK(OkHdl, OKButton*);
public:
    SwAutoMarkDlg_Impl(Window* pParent, const String& rAutoMarkURL,
                        const String& rAutoMarkType, sal_Bool bCreate);
    ~SwAutoMarkDlg_Impl();

};
/* -----------------04.11.99 11:02-------------------

 --------------------------------------------------*/
sal_uInt16 CurTOXType::GetFlatIndex() const
{
    sal_uInt16 nRet = static_cast< sal_uInt16 >(eType);
    if(eType == TOX_USER && nIndex)
    {
        nRet = static_cast< sal_uInt16 >(TOX_AUTHORITIES + nIndex);
    }
    return nRet;
}
/*************************************************************************

*************************************************************************/
#define EDIT_MINWIDTH 15

/* -----------------14.06.99 12:12-------------------

 --------------------------------------------------*/
SwMultiTOXTabDialog::SwMultiTOXTabDialog(Window* pParent, const SfxItemSet& rSet,
                    SwWrtShell &rShell,
                    SwTOXBase* pCurTOX,
                    sal_uInt16 nToxType, sal_Bool bGlobal) :
        SfxTabDialog(   pParent, SW_RES(DLG_MULTI_TOX), &rSet),
        aExampleContainerWIN(this, SW_RES(WIN_EXAMPLE)),
        aExampleWIN( &aExampleContainerWIN, 0 ),
        aShowExampleCB( this, SW_RES(CB_SHOWEXAMPLE)),
        pMgr( new SwTOXMgr( &rShell ) ),
        rSh(rShell),
        pExampleFrame(0),
        pParamTOXBase(pCurTOX),
        sUserDefinedIndex(SW_RES(ST_USERDEFINEDINDEX)),
        nInitialTOXType(nToxType),

        bEditTOX(sal_False),
        bExampleCreated(sal_False),
        bGlobalFlag(bGlobal)
{
    FreeResource();

    aExampleWIN.SetPosSizePixel(aExampleContainerWIN.GetPosPixel(),
                                aExampleContainerWIN.GetSizePixel());

    eCurrentTOXType.eType = TOX_CONTENT;
    eCurrentTOXType.nIndex = 0;

    sal_uInt16 nUserTypeCount = rSh.GetTOXTypeCount(TOX_USER);
    nTypeCount = nUserTypeCount + 6;
    pFormArr = new SwForm*[nTypeCount];
    pDescArr = new SwTOXDescription*[nTypeCount];
    pxIndexSectionsArr = new SwIndexSections_Impl*[nTypeCount];
    //the standard user index is on position TOX_USER
    //all user user indexes follow after position TOX_AUTHORITIES
    if(pCurTOX)
    {
        bEditTOX = sal_True;
    }
    for(int i = nTypeCount - 1; i > -1; i--)
    {
        pFormArr[i] = 0;
        pDescArr[i] = 0;
        pxIndexSectionsArr[i] = new SwIndexSections_Impl;
        if(pCurTOX)
        {
            eCurrentTOXType.eType = pCurTOX->GetType();
            sal_uInt16 nArrayIndex = static_cast< sal_uInt16 >(eCurrentTOXType.eType);
            if(eCurrentTOXType.eType == TOX_USER)
            {
                //which user type is it?
                for(sal_uInt16 nUser = 0; nUser < nUserTypeCount; nUser++)
                {
                    const SwTOXType* pTemp = rSh.GetTOXType(TOX_USER, nUser);
                    if(pCurTOX->GetTOXType() == pTemp)
                    {
                        eCurrentTOXType.nIndex = nUser;
                        nArrayIndex = static_cast< sal_uInt16 >(nUser > 0 ? TOX_AUTHORITIES + nUser : TOX_USER);
                        break;
                    }
                }
            }
            pFormArr[nArrayIndex] = new SwForm(pCurTOX->GetTOXForm());
            pDescArr[nArrayIndex] = CreateTOXDescFromTOXBase(pCurTOX);
            if(TOX_AUTHORITIES == eCurrentTOXType.eType)
            {
                const SwAuthorityFieldType* pFType = (const SwAuthorityFieldType*)
                                                rSh.GetFldType(RES_AUTHORITY, aEmptyStr);
                if(pFType)
                {
                    String sBrackets;
                    if(pFType->GetPrefix())
                        sBrackets += pFType->GetPrefix();
                    if(pFType->GetSuffix())
                        sBrackets += pFType->GetSuffix();
                    pDescArr[nArrayIndex]->SetAuthBrackets(sBrackets);
                    pDescArr[nArrayIndex]->SetAuthSequence(pFType->IsSequence());
                }
                else
                {
                    pDescArr[nArrayIndex]->SetAuthBrackets(C2S("[]"));
                }
            }
        }
    }
    SfxAbstractDialogFactory* pFact = SfxAbstractDialogFactory::Create();
    DBG_ASSERT(pFact, "Dialogdiet fail!");
    AddTabPage(TP_TOX_SELECT, SwTOXSelectTabPage::Create, 0);
    AddTabPage(TP_TOX_STYLES, SwTOXStylesTabPage::Create, 0);
    AddTabPage(TP_COLUMN,   SwColumnPage::Create,    0);
    AddTabPage(TP_BACKGROUND, pFact->GetTabPageCreatorFunc( RID_SVXPAGE_BACKGROUND ),  0 );
    AddTabPage(TP_TOX_ENTRY, SwTOXEntryTabPage::Create,     0);
    if(!pCurTOX)
        SetCurPageId(TP_TOX_SELECT);

    aShowExampleCB.SetClickHdl(LINK(this, SwMultiTOXTabDialog, ShowPreviewHdl));

    aShowExampleCB.Check( SW_MOD()->GetModuleConfig()->IsShowIndexPreview());

    aExampleContainerWIN.SetAccessibleName(aShowExampleCB.GetText());
    SetViewAlign( WINDOWALIGN_LEFT );
    // SetViewWindow does not work if the dialog is visible!

    if(!aShowExampleCB.IsChecked())
        SetViewWindow( &aExampleContainerWIN );

    Point aOldPos = GetPosPixel();
    ShowPreviewHdl(0);
    Point aNewPos = GetPosPixel();
    //72040: initial position may be left of the view - that has to be corrected
    if(aNewPos.X() < 0)
        SetPosPixel(aOldPos);
}
/*-- 14.06.99 13:11:40---------------------------------------------------

  -----------------------------------------------------------------------*/
SwMultiTOXTabDialog::~SwMultiTOXTabDialog()
{
    SW_MOD()->GetModuleConfig()->SetShowIndexPreview(aShowExampleCB.IsChecked());

    for(sal_uInt16 i = 0; i < nTypeCount; i++)
    {
        delete pFormArr[i];
        delete pDescArr[i];
        delete pxIndexSectionsArr[i];
    }
    delete[] pxIndexSectionsArr;

    delete[] pFormArr;
    delete[] pDescArr;
    delete pMgr;
    delete pExampleFrame;
}
/*-- 14.06.99 13:11:40---------------------------------------------------

  -----------------------------------------------------------------------*/
void    SwMultiTOXTabDialog::PageCreated( sal_uInt16 nId, SfxTabPage &rPage )
{
    if( TP_BACKGROUND == nId  )
    {
        SfxAllItemSet aSet(*(GetInputSetImpl()->GetPool()));
        aSet.Put (SfxUInt32Item(SID_FLAG_TYPE, SVX_SHOW_SELECTOR));
        rPage.PageCreated(aSet);
    }
    else if(TP_COLUMN == nId )
    {
        const SwFmtFrmSize& rSize = (const SwFmtFrmSize&)GetInputSetImpl()->Get(RES_FRM_SIZE);

        ((SwColumnPage&)rPage).SetPageWidth(rSize.GetWidth());
    }
    else if(TP_TOX_ENTRY == nId)
        ((SwTOXEntryTabPage&)rPage).SetWrtShell(rSh);
    if(TP_TOX_SELECT == nId)
    {
        ((SwTOXSelectTabPage&)rPage).SetWrtShell(rSh);
        if(USHRT_MAX != nInitialTOXType)
            ((SwTOXSelectTabPage&)rPage).SelectType((TOXTypes)nInitialTOXType);
    }
}
/*-- 14.06.99 13:11:40---------------------------------------------------

  -----------------------------------------------------------------------*/
short   SwMultiTOXTabDialog::Ok()
{
    short nRet = SfxTabDialog::Ok();
    SwTOXDescription& rDesc = GetTOXDescription(eCurrentTOXType);
    SwTOXBase aNewDef(*rSh.GetDefaultTOXBase( eCurrentTOXType.eType, sal_True ));

    sal_uInt16 nIndex = static_cast< sal_uInt16 >(eCurrentTOXType.eType);
    if(eCurrentTOXType.eType == TOX_USER && eCurrentTOXType.nIndex)
    {
        nIndex =  static_cast< sal_uInt16 >(TOX_AUTHORITIES + eCurrentTOXType.nIndex);
    }

    if(pFormArr[nIndex])
    {
        rDesc.SetForm(*pFormArr[nIndex]);
        aNewDef.SetTOXForm(*pFormArr[nIndex]);
    }
    rDesc.ApplyTo(aNewDef);
    if(!bGlobalFlag)
        pMgr->UpdateOrInsertTOX(
                rDesc, 0, GetOutputItemSet());
    else if(bEditTOX)
        pMgr->UpdateOrInsertTOX(
                rDesc, &pParamTOXBase, GetOutputItemSet());

    if(!eCurrentTOXType.nIndex)
        rSh.SetDefaultTOXBase(aNewDef);

    return nRet;
}
/* -----------------16.06.99 11:59-------------------

 --------------------------------------------------*/
SwForm* SwMultiTOXTabDialog::GetForm(CurTOXType eType)
{
    sal_uInt16 nIndex = eType.GetFlatIndex();
    if(!pFormArr[nIndex])
        pFormArr[nIndex] = new SwForm(eType.eType);
    return pFormArr[nIndex];
}
/* -----------------09.09.99 11:29-------------------

 --------------------------------------------------*/
SwTOXDescription&   SwMultiTOXTabDialog::GetTOXDescription(CurTOXType eType)
{
    sal_uInt16 nIndex = eType.GetFlatIndex();
    if(!pDescArr[nIndex])
    {
        const SwTOXBase* pDef = rSh.GetDefaultTOXBase( eType.eType );
        if(pDef)
            pDescArr[nIndex] = CreateTOXDescFromTOXBase(pDef);
        else
        {
            pDescArr[nIndex] = new SwTOXDescription(eType.eType);
            if(eType.eType == TOX_USER)
                pDescArr[nIndex]->SetTitle(sUserDefinedIndex);
            else
                pDescArr[nIndex]->SetTitle(
                    rSh.GetTOXType(eType.eType, 0)->GetTypeName());
        }
        if(TOX_AUTHORITIES == eType.eType)
        {
            const SwAuthorityFieldType* pFType = (const SwAuthorityFieldType*)
                                            rSh.GetFldType(RES_AUTHORITY, aEmptyStr);
            if(pFType)
            {
                String sBrackets(pFType->GetPrefix());
                sBrackets += pFType->GetSuffix();
                pDescArr[nIndex]->SetAuthBrackets(sBrackets);
                pDescArr[nIndex]->SetAuthSequence(pFType->IsSequence());
            }
            else
            {
                pDescArr[nIndex]->SetAuthBrackets(C2S("[]"));
            }
        }
        else if(TOX_INDEX == eType.eType)
            pDescArr[nIndex]->SetMainEntryCharStyle(SW_RESSTR(STR_POOLCHR_IDX_MAIN_ENTRY));

    }
    return *pDescArr[nIndex];
}
/* -----------------09.09.99 11:36-------------------

 --------------------------------------------------*/
SwTOXDescription* SwMultiTOXTabDialog::CreateTOXDescFromTOXBase(
            const SwTOXBase*pCurTOX)
{
    SwTOXDescription * pDesc = new SwTOXDescription(pCurTOX->GetType());
    for(sal_uInt16 i = 0; i < MAXLEVEL; i++)
        pDesc->SetStyleNames(pCurTOX->GetStyleNames(i), i);
    pDesc->SetAutoMarkURL(rSh.GetTOIAutoMarkURL());
    pDesc->SetTitle(pCurTOX->GetTitle());


    pDesc->SetContentOptions(pCurTOX->GetCreateType());
    if(pDesc->GetTOXType() == TOX_INDEX)
        pDesc->SetIndexOptions(pCurTOX->GetOptions());
    pDesc->SetMainEntryCharStyle(pCurTOX->GetMainEntryCharStyle());
    if(pDesc->GetTOXType() != TOX_INDEX)
        pDesc->SetLevel((sal_uInt8)pCurTOX->GetLevel());
    pDesc->SetCreateFromObjectNames(pCurTOX->IsFromObjectNames());
    pDesc->SetSequenceName(pCurTOX->GetSequenceName());
    pDesc->SetCaptionDisplay(pCurTOX->GetCaptionDisplay());
    pDesc->SetFromChapter(pCurTOX->IsFromChapter());
    pDesc->SetReadonly(pCurTOX->IsProtected());
    pDesc->SetOLEOptions(pCurTOX->GetOLEOptions());
    pDesc->SetLevelFromChapter(pCurTOX->IsLevelFromChapter());
    pDesc->SetLanguage(pCurTOX->GetLanguage());
    pDesc->SetSortAlgorithm(pCurTOX->GetSortAlgorithm());
    return pDesc;
}

/* -----------------------------29.12.99 09:53--------------------------------

 ---------------------------------------------------------------------------*/

IMPL_LINK( SwMultiTOXTabDialog, ShowPreviewHdl, CheckBox *, pBox )
{
    if(aShowExampleCB.IsChecked())
    {
        if(!pExampleFrame && !bExampleCreated)
        {
            bExampleCreated = sal_True;
            String sTemplate( String::CreateFromAscii(
                                RTL_CONSTASCII_STRINGPARAM("internal")) );
            sTemplate += INET_PATH_TOKEN;
            sTemplate.AppendAscii( RTL_CONSTASCII_STRINGPARAM("idxexample") );
            String sTemplateWithoutExt( sTemplate );
#ifndef MAC_WITHOUT_EXT
            sTemplate.AppendAscii( RTL_CONSTASCII_STRINGPARAM(".odt") );
#endif

            SvtPathOptions aOpt;
            // 6.0 (extension .sxw)
            sal_Bool bExist = aOpt.SearchFile( sTemplate, SvtPathOptions::PATH_TEMPLATE );

#ifndef MAC_WITHOUT_EXT
            if( !bExist )
            {
                // 6.0 (extension .sxw)
                sTemplate = sTemplateWithoutExt;
                sTemplate.AppendAscii( RTL_CONSTASCII_STRINGPARAM(".sxw") );
                bExist = aOpt.SearchFile( sTemplate, SvtPathOptions::PATH_TEMPLATE );
            }
            if( !bExist )
            {
                // 5.0 (extension .vor)
                sTemplate = sTemplateWithoutExt;
                sTemplate.AppendAscii( RTL_CONSTASCII_STRINGPARAM(".sdw") );
                bExist = aOpt.SearchFile( sTemplate, SvtPathOptions::PATH_TEMPLATE );
            }
#endif

            if(!bExist)
            {
                String sInfo(SW_RES(STR_FILE_NOT_FOUND));
                sInfo.SearchAndReplaceAscii( "%1", sTemplate );
                sInfo.SearchAndReplaceAscii( "%2", aOpt.GetTemplatePath() );
                InfoBox aInfo(GetParent(), sInfo);
                aInfo.Execute();
            }
            else
            {
                Link aLink(LINK(this, SwMultiTOXTabDialog, CreateExample_Hdl));
                pExampleFrame = new SwOneExampleFrame(
                        aExampleWIN, EX_SHOW_ONLINE_LAYOUT, &aLink, &sTemplate);

                if(!pExampleFrame->IsServiceAvailable())
                {
                    pExampleFrame->CreateErrorMessage(0);
                }
            }
            aShowExampleCB.Show(pExampleFrame && pExampleFrame->IsServiceAvailable());
        }
    }
    sal_Bool bSetViewWindow = aShowExampleCB.IsChecked()
        && pExampleFrame && pExampleFrame->IsServiceAvailable();

    aExampleContainerWIN.Show( bSetViewWindow );
    SetViewWindow( bSetViewWindow ? &aExampleContainerWIN  : 0 );

    Window *pTopmostParent = this;
    while(pTopmostParent->GetParent())
        pTopmostParent = pTopmostParent->GetParent();
    ::Rectangle aRect(GetClientWindowExtentsRelative(pTopmostParent));
    ::Point aPos = aRect.TopLeft();
    Size aSize = GetSizePixel();
    if(pBox)
        AdjustLayout();
    long nDiffWidth = GetSizePixel().Width() - aSize.Width();
    aPos.X() -= nDiffWidth;
    SetPosPixel(aPos);

    return 0;
}


/* -----------------05.07.99 09:49-------------------

 --------------------------------------------------*/
sal_Bool SwMultiTOXTabDialog::IsNoNum(SwWrtShell& rSh, const String& rName)
{
    SwTxtFmtColl* pColl = rSh.GetParaStyle(rName);
    //if(pColl && pColl->GetOutlineLevel() == NO_NUMBERING)     //#outline level,zhaojianwei
    if(pColl && ! pColl->IsAssignedToListLevelOfOutlineStyle()) //<-end,zhaojianwei
        return sal_True;

    sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName(rName, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL);
    if(nId != USHRT_MAX &&
        //rSh.GetTxtCollFromPool(nId)->GetOutlineLevel() == NO_NUMBERING)       //#outline level,zhaojianwei
        ! rSh.GetTxtCollFromPool(nId)->IsAssignedToListLevelOfOutlineStyle())   //<-end,zhaojianwei
        return sal_True;

    return sal_False;
}
/* -----------------14.07.99 16:01-------------------

 --------------------------------------------------*/
class SwIndexTreeLB : public SvTreeListBox
{
    const HeaderBar* pHeaderBar;
public:
    SwIndexTreeLB(Window* pWin, const ResId& rResId) :
        SvTreeListBox(pWin, rResId), pHeaderBar(0){}

    virtual void    KeyInput( const KeyEvent& rKEvt );
    virtual long    GetTabPos( SvLBoxEntry*, SvLBoxTab* );
    void            SetHeaderBar(const HeaderBar* pHB) {pHeaderBar = pHB;}
};
/* -----------------14.07.99 16:03-------------------

 --------------------------------------------------*/
long  SwIndexTreeLB::GetTabPos( SvLBoxEntry* pEntry, SvLBoxTab* pTab)
{
    long nData = (long)pEntry->GetUserData();
    if(nData != USHRT_MAX)
    {
        long  nPos = pHeaderBar->GetItemRect( static_cast< sal_uInt16 >(101 + nData) ).TopLeft().X();
        nData = nPos;
    }
    else
        nData = 0;
    nData += pTab->GetPos();
    return nData;
}
/* -----------------25.08.99 11:14-------------------

 --------------------------------------------------*/
void    SwIndexTreeLB::KeyInput( const KeyEvent& rKEvt )
{
    SvLBoxEntry* pEntry = FirstSelected();
    KeyCode aCode = rKEvt.GetKeyCode();
    sal_Bool bChanged = sal_False;
    if(pEntry)
    {
        long nLevel = (long)pEntry->GetUserData();
        if(aCode.GetCode() == KEY_ADD )
        {
            if(nLevel < MAXLEVEL - 1)
                nLevel++;
            else if(nLevel == USHRT_MAX)
                nLevel = 0;
            bChanged = sal_True;
        }
        else if(aCode.GetCode() == KEY_SUBTRACT)
        {
            if(!nLevel)
                nLevel = USHRT_MAX;
            else if(nLevel != USHRT_MAX)
                nLevel--;
            bChanged = sal_True;
        }
        if(bChanged)
        {
            pEntry->SetUserData((void*)nLevel);
            Invalidate();
        }
    }
    if(!bChanged)
        SvTreeListBox::KeyInput(rKEvt);
}

/* -----------------16.07.99 10:01-------------------

 --------------------------------------------------*/
class SwHeaderTree : public Control
{
    HeaderBar       aStylesHB;
    SwIndexTreeLB   aStylesTLB;

public:
    SwHeaderTree(Window* pParent, const ResId rResId);

    HeaderBar&      GetHeaderBar() {return aStylesHB;}
    SwIndexTreeLB&  GetTreeListBox() { return aStylesTLB;}

    virtual void    GetFocus();
};
/* -----------------16.07.99 10:11-------------------

 --------------------------------------------------*/
SwHeaderTree::SwHeaderTree(Window* pParent, const ResId rResId) :
        Control(pParent, rResId),
        aStylesHB(  this, ResId(HB_STYLES, *rResId.GetResMgr())),
        aStylesTLB( this, ResId(TLB_STYLES, *rResId.GetResMgr()))
{
    FreeResource();
    aStylesHB.SetStyle(aStylesHB.GetStyle()|WB_BUTTONSTYLE|WB_TABSTOP|WB_BORDER);
    Size aHBSize(aStylesHB.GetSizePixel());
    aHBSize.Height() = aStylesHB.CalcWindowSizePixel().Height();
    aStylesHB.SetSizePixel(aHBSize);
    aStylesTLB.SetPosPixel(Point(0, aHBSize.Height()));
    Size aTLBSize(aStylesHB.GetSizePixel());
    aTLBSize.Height() = GetOutputSizePixel().Height() - aHBSize.Height();
    aStylesTLB.SetSizePixel(aTLBSize);
    aStylesTLB.SetHeaderBar(&aStylesHB);
}
/* -----------------25.08.99 10:38-------------------

 --------------------------------------------------*/
void    SwHeaderTree::GetFocus()
{
    Control::GetFocus();
    aStylesTLB.GrabFocus();
}
/* -----------------13.07.99 15:29-------------------

 --------------------------------------------------*/
class SwAddStylesDlg_Impl : public SfxModalDialog
{
    OKButton        aOk;
    CancelButton    aCancel;
    HelpButton      aHelp;

    FixedLine       aStylesFL;
    SwHeaderTree    aHeaderTree;
    ImageButton     aLeftPB;
    ImageButton      aRightPB;

    String          sHBFirst;
    String*         pStyleArr;

    DECL_LINK(OkHdl, OKButton*);
    DECL_LINK(LeftRightHdl, PushButton*);
    DECL_LINK(HeaderDragHdl, HeaderBar*);

public:
    SwAddStylesDlg_Impl(Window* pParent, SwWrtShell& rWrtSh, String rStringArr[]);
    ~SwAddStylesDlg_Impl();
};
/* -----------------13.07.99 15:39-------------------

 --------------------------------------------------*/
SwAddStylesDlg_Impl::SwAddStylesDlg_Impl(Window* pParent,
            SwWrtShell& rWrtSh, String rStringArr[]) :
    SfxModalDialog(pParent, SW_RES(DLG_ADD_IDX_STYLES)),
    aOk(        this, SW_RES(PB_OK      )),
    aCancel(    this, SW_RES(PB_CANCEL  )),
    aHelp(      this, SW_RES(PB_HELP        )),

    aStylesFL(  this, SW_RES(FL_STYLES   )),
    aHeaderTree(this, SW_RES(TR_HEADER   )),
    aLeftPB(    this, SW_RES(PB_LEFT     )),
    aRightPB(   this, SW_RES(PB_RIGHT    )),

    sHBFirst(   SW_RES(ST_HB_FIRST)),
    pStyleArr(rStringArr)
{
    FreeResource();

    aHeaderTree.SetAccessibleRelationMemberOf(&aStylesFL);
    aLeftPB.SetAccessibleRelationMemberOf(&aStylesFL);
    aRightPB.SetAccessibleRelationMemberOf(&aStylesFL);

    aLeftPB.SetModeImage( Image( SW_RES( IMG_ALL_LEFT_HC ) ), BMP_COLOR_HIGHCONTRAST );
    aRightPB.SetModeImage( Image( SW_RES( IMG_ALL_RIGHT_HC ) ), BMP_COLOR_HIGHCONTRAST );

    aOk.SetClickHdl(LINK(this, SwAddStylesDlg_Impl, OkHdl));
    aLeftPB.SetClickHdl(LINK(this, SwAddStylesDlg_Impl, LeftRightHdl));
    aRightPB.SetClickHdl(LINK(this, SwAddStylesDlg_Impl, LeftRightHdl));

    HeaderBar& rHB = aHeaderTree.GetHeaderBar();
    rHB.SetEndDragHdl(LINK(this, SwAddStylesDlg_Impl, HeaderDragHdl));

    long nWidth = rHB.GetSizePixel().Width();
    sal_uInt16 i;

    nWidth /= 14;
    nWidth--;
    rHB.InsertItem( 100, sHBFirst,  4 * nWidth );
    for( i = 1; i <= MAXLEVEL; i++)
        rHB.InsertItem( 100 + i, String::CreateFromInt32(i), nWidth );
    rHB.Show();

    SwIndexTreeLB& rTLB = aHeaderTree.GetTreeListBox();
    rTLB.SetStyle(rTLB.GetStyle()|WB_CLIPCHILDREN|WB_SORT);
    //aStylesTLB.SetSelectHdl(LINK(this, SwAddStylesDlg_Impl, SelectHdl));
    rTLB.GetModel()->SetSortMode(SortAscending);
    for(i = 0; i < MAXLEVEL; ++i)
    {
        String sStyles(rStringArr[i]);
        for(sal_uInt16 nToken = 0; nToken < sStyles.GetTokenCount(TOX_STYLE_DELIMITER); nToken++)
        {
            String sTmp(sStyles.GetToken(nToken, TOX_STYLE_DELIMITER));
            SvLBoxEntry* pEntry = rTLB.InsertEntry(sTmp);
            pEntry->SetUserData(reinterpret_cast<void*>(i));
        }
    }
    // now the other styles
    //
    const SwTxtFmtColl *pColl   = 0;
    const sal_uInt16 nSz = rWrtSh.GetTxtFmtCollCount();

    for ( sal_uInt16 j = 0;j < nSz; ++j )
    {
        pColl = &rWrtSh.GetTxtFmtColl(j);
        if(pColl->IsDefault())
            continue;

        const String& rName = pColl->GetName();

        if(rName.Len() > 0)
        {
            SvLBoxEntry* pEntry = rTLB.First();
            sal_Bool bFound = sal_False;
            while(pEntry && !bFound)
            {
                if(rTLB.GetEntryText(pEntry) == rName)
                    bFound = sal_True;
                pEntry = rTLB.Next(pEntry);
            }
            if(!bFound)
            {
                rTLB.InsertEntry(rName)->SetUserData((void*)USHRT_MAX);
            }
        }
    }
    rTLB.GetModel()->Resort();
}

/* -----------------13.07.99 15:39-------------------

 --------------------------------------------------*/
SwAddStylesDlg_Impl::~SwAddStylesDlg_Impl()
{
}
/* -----------------13.07.99 15:39-------------------

 --------------------------------------------------*/
IMPL_LINK(SwAddStylesDlg_Impl, OkHdl, OKButton*, EMPTYARG)
{
    for(sal_uInt16 i = 0; i < MAXLEVEL; i++)
        pStyleArr[i].Erase();

    SwIndexTreeLB& rTLB = aHeaderTree.GetTreeListBox();
    SvLBoxEntry* pEntry = rTLB.First();
    while(pEntry)
    {
        long nLevel = (long)pEntry->GetUserData();
        if(nLevel != USHRT_MAX)
        {
            String sName(rTLB.GetEntryText(pEntry));
            if(pStyleArr[nLevel].Len())
                pStyleArr[nLevel] += TOX_STYLE_DELIMITER;
            pStyleArr[nLevel] += sName;
        }
        pEntry = rTLB.Next(pEntry);
    }

    //TODO write back style names
    EndDialog(RET_OK);
    return 0;
}
/* -----------------16.07.99 09:27-------------------

 --------------------------------------------------*/
IMPL_LINK(SwAddStylesDlg_Impl, HeaderDragHdl, HeaderBar*, EMPTYARG)
{
    aHeaderTree.GetTreeListBox().Invalidate();
    return 0;
}
/* -----------------13.07.99 15:39-------------------

 --------------------------------------------------*/
IMPL_LINK(SwAddStylesDlg_Impl, LeftRightHdl, PushButton*, pBtn)
{
    sal_Bool bLeft = pBtn == &aLeftPB;
    SvLBoxEntry* pEntry = aHeaderTree.GetTreeListBox().FirstSelected();
    if(pEntry)
    {
        long nLevel = (long)pEntry->GetUserData();
        if(bLeft)
        {
            if(!nLevel)
                nLevel = USHRT_MAX;
            else if(nLevel != USHRT_MAX)
                nLevel--;
        }
        else
        {
            if(nLevel < MAXLEVEL - 1)
                nLevel++;
            else if(nLevel == USHRT_MAX)
                nLevel = 0;
        }
        pEntry->SetUserData((void*)nLevel);
        aHeaderTree.GetTreeListBox().Invalidate();
    }
    return 0;
}

/*-- 14.06.99 13:11:40---------------------------------------------------

  -----------------------------------------------------------------------*/
SwTOXSelectTabPage::SwTOXSelectTabPage(Window* pParent, const SfxItemSet& rAttrSet) :
    SfxTabPage(pParent, SW_RES(TP_TOX_SELECT), rAttrSet),

    aTypeTitleFL(       this, SW_RES(FL_TYPETITLE        )),
    aTitleFT(           this, SW_RES(FT_TITLE            )),
    aTitleED(           this, SW_RES(ED_TITLE           )),
    aTypeFT(            this, SW_RES(FT_TYPE                )),
    aTypeLB(            this, SW_RES(LB_TYPE                )),
    aReadOnlyCB(        this, SW_RES(CB_READONLY            )),

    aAreaFL(            this, SW_RES(FL_AREA             )),
    aAreaFT(            this, SW_RES(FT_AREA             )),
    aAreaLB(            this, SW_RES(LB_AREA                )),
    aLevelFT(           this, SW_RES(FT_LEVEL           )),
    aLevelNF(           this, SW_RES(NF_LEVEL           )),

    aCreateFromFL(      this, SW_RES(FL_CREATEFROM       )),
    aFromHeadingsCB(    this, SW_RES(CB_FROMHEADINGS     )),
//   aChapterDlgPB(      this, SW_RES(PB_CHAPTERDLG      )),//#outline level,removed by zhaojianwei
    aAddStylesCB(       this, SW_RES(CB_ADDSTYLES       )),
    aAddStylesPB(       this, SW_RES(PB_ADDSTYLES       )),

    aFromTablesCB(      this, SW_RES(CB_FROMTABLES       )),
    aFromFramesCB(      this, SW_RES(CB_FROMFRAMES      )),
    aFromGraphicsCB(    this, SW_RES(CB_FROMGRAPHICS        )),
    aFromOLECB(         this, SW_RES(CB_FROMOLE         )),
    aLevelFromChapterCB(this, SW_RES(CB_LEVELFROMCHAPTER    )),

    aFromCaptionsRB(    this, SW_RES(RB_FROMCAPTIONS     )),
    aFromObjectNamesRB( this, SW_RES(RB_FROMOBJECTNAMES )),

    aCaptionSequenceFT( this, SW_RES(FT_CAPTIONSEQUENCE  )),
    aCaptionSequenceLB( this, SW_RES(LB_CAPTIONSEQUENCE  )),
    aDisplayTypeFT(     this, SW_RES(FT_DISPLAYTYPE     )),
    aDisplayTypeLB(     this, SW_RES(LB_DISPLAYTYPE     )),

    aTOXMarksCB(        this, SW_RES(CB_TOXMARKS         )),

    aIdxOptionsFL(      this, SW_RES(FL_IDXOPTIONS       )),
    aCollectSameCB(     this, SW_RES(CB_COLLECTSAME      )),
    aUseFFCB(           this, SW_RES(CB_USEFF           )),
    aUseDashCB(         this, SW_RES(CB_USE_DASH            )),
    aCaseSensitiveCB(   this, SW_RES(CB_CASESENSITIVE   )),
    aInitialCapsCB(     this, SW_RES(CB_INITIALCAPS     )),
    aKeyAsEntryCB(      this, SW_RES(CB_KEYASENTRY      )),
    aFromFileCB(        this, SW_RES(CB_FROMFILE            )),
    aAutoMarkPB(        this, SW_RES(MB_AUTOMARK            )),

    aFromNames(         SW_RES(RES_SRCTYPES              )),
    aFromObjCLB(        this, SW_RES(CLB_FROMOBJ            )),
    aFromObjFL(         this, SW_RES(FL_FROMOBJ          )),

    aSequenceCB(        this, SW_RES(CB_SEQUENCE         )),
    aBracketFT(         this, SW_RES(FT_BRACKET         )),
    aBracketLB(         this, SW_RES(LB_BRACKET         )),
    aAuthorityFormatFL( this, SW_RES(FL_AUTHORITY        )),

    aSortOptionsFL(     this, SW_RES(FL_SORTOPTIONS      )),
    aLanguageFT(        this, SW_RES(FT_LANGUAGE         )),
    aLanguageLB(        this, SW_RES(LB_LANGUAGE         )),
    aSortAlgorithmFT(   this, SW_RES(FT_SORTALG          )),
    aSortAlgorithmLB(   this, SW_RES(LB_SORTALG          )),

    pIndexRes(0),

    sAutoMarkType(SW_RES(ST_AUTOMARK_TYPE)),
    sAddStyleUser(SW_RES(ST_USER_ADDSTYLE)),
    bFirstCall(sal_True)
{
    aBracketLB.InsertEntry(String(SW_RES(ST_NO_BRACKET)), 0);

    aAddStylesPB.SetAccessibleRelationMemberOf(&aCreateFromFL);
    aAddStylesPB.SetAccessibleRelationLabeledBy(&aAddStylesCB);
    aAddStylesPB.SetAccessibleName(aAddStylesCB.GetText());

    FreeResource();

    pIndexEntryWrapper = new IndexEntrySupplierWrapper();

    aLanguageLB.SetLanguageList( LANG_LIST_ALL | LANG_LIST_ONLY_KNOWN,
                                 sal_False, sal_False, sal_False );

    sAddStyleContent = aAddStylesCB.GetText();

    aCBLeftPos1 = aFromHeadingsCB.GetPosPixel();
    aCBLeftPos2 = aAddStylesCB.GetPosPixel();
    aCBLeftPos3 = aTOXMarksCB.GetPosPixel();

    ResStringArray& rNames = aFromNames.GetNames();
    for(sal_uInt16 i = 0; i < rNames.Count(); i++)
    {
        aFromObjCLB.InsertEntry(rNames.GetString(i));
        aFromObjCLB.SetEntryData( i, (void*)rNames.GetValue(i) );
    }
    aFromObjCLB.SetHelpId(HID_OLE_CHECKLB);

    SetExchangeSupport();
    aTypeLB.SetSelectHdl(LINK(this, SwTOXSelectTabPage, TOXTypeHdl));

    aAddStylesPB.SetClickHdl(LINK(this, SwTOXSelectTabPage, AddStylesHdl));
    //aChapterDlgPB.SetClickHdl(LINK(this, SwTOXSelectTabPage, ChapterHdl));//#outline level,removed by zhaojianwei

    PopupMenu*  pMenu = aAutoMarkPB.GetPopupMenu();
    pMenu->SetActivateHdl(LINK(this, SwTOXSelectTabPage, MenuEnableHdl));
    pMenu->SetSelectHdl(LINK(this, SwTOXSelectTabPage, MenuExecuteHdl));

    Link aLk =  LINK(this, SwTOXSelectTabPage, CheckBoxHdl);
    aAddStylesCB    .SetClickHdl(aLk);
    aFromHeadingsCB .SetClickHdl(aLk);
    aTOXMarksCB     .SetClickHdl(aLk);
    aFromFileCB     .SetClickHdl(aLk);
    aCollectSameCB  .SetClickHdl(aLk);
    aUseFFCB        .SetClickHdl(aLk);
    aUseDashCB      .SetClickHdl(aLk);
    aInitialCapsCB  .SetClickHdl(aLk);
    aKeyAsEntryCB   .SetClickHdl(aLk);

    Link aModifyLk = LINK(this, SwTOXSelectTabPage, ModifyHdl);
    aTitleED.SetModifyHdl(aModifyLk);
    aLevelNF.SetModifyHdl(aModifyLk);
    aSortAlgorithmLB.SetSelectHdl(aModifyLk);

    aLk =  LINK(this, SwTOXSelectTabPage, RadioButtonHdl);
    aFromCaptionsRB.SetClickHdl(aLk);
    aFromObjectNamesRB.SetClickHdl(aLk);
    RadioButtonHdl(&aFromCaptionsRB);

    aLanguageLB.SetSelectHdl(LINK(this, SwTOXSelectTabPage, LanguageHdl));
    aTypeLB.SelectEntryPos(0);
    aTitleED.SaveValue();
}
/*-- 14.06.99 13:11:41---------------------------------------------------

  -----------------------------------------------------------------------*/
SwTOXSelectTabPage::~SwTOXSelectTabPage()
{
    delete pIndexRes;
    delete pIndexEntryWrapper;
}
/* -----------------21.10.99 17:03-------------------

 --------------------------------------------------*/
void SwTOXSelectTabPage::SetWrtShell(SwWrtShell& rSh)
{
    sal_uInt16 nUserTypeCount = rSh.GetTOXTypeCount(TOX_USER);
    if(nUserTypeCount > 1)
    {
        //insert all new user indexes names after the standard user index
        sal_uInt16 nPos = aTypeLB.GetEntryPos((void*)(sal_uInt32)TO_USER);
        nPos++;
        for(sal_uInt16 nUser = 1; nUser < nUserTypeCount; nUser++)
        {
            nPos = aTypeLB.InsertEntry(rSh.GetTOXType(TOX_USER, nUser)->GetTypeName(), nPos);
            sal_uInt32 nEntryData = nUser << 8;
            nEntryData |= TO_USER;
            aTypeLB.SetEntryData(nPos, (void*)nEntryData);
        }
    }
}
/* -----------------14.06.99 13:10-------------------

 --------------------------------------------------*/
sal_Bool SwTOXSelectTabPage::FillItemSet( SfxItemSet& )
{
    return sal_True;
}
/* -----------------25.08.99 14:31-------------------

 --------------------------------------------------*/
long lcl_TOXTypesToUserData(CurTOXType eType)
{
    sal_uInt16 nRet = TOX_INDEX;
    switch(eType.eType)
    {
        case TOX_INDEX       : nRet = TO_INDEX;     break;
        case TOX_USER        :
        {
            nRet = eType.nIndex << 8;
            nRet |= TO_USER;
        }
        break;
        case TOX_CONTENT     : nRet = TO_CONTENT;   break;
        case TOX_ILLUSTRATIONS:nRet = TO_ILLUSTRATION; break;
        case TOX_OBJECTS     : nRet = TO_OBJECT;    break;
        case TOX_TABLES      : nRet = TO_TABLE;     break;
        case TOX_AUTHORITIES : nRet = TO_AUTHORITIES; break;
    }
    return nRet;
}
//-----------------------------------------------------------------
void SwTOXSelectTabPage::SelectType(TOXTypes eSet)
{
    CurTOXType eCurType (eSet, 0);

    long nData = lcl_TOXTypesToUserData(eCurType);
    aTypeLB.SelectEntryPos(aTypeLB.GetEntryPos((void*)nData));
    aTypeFT.Enable(sal_False);
    aTypeLB.Enable(sal_False);
    TOXTypeHdl(&aTypeLB);
}

/*-- 14.06.99 13:10:45---------------------------------------------------

  -----------------------------------------------------------------------*/
//-----------------------------------------------------------------
CurTOXType lcl_UserData2TOXTypes(sal_uInt16 nData)
{
    CurTOXType eRet;

    switch(nData&0xff)
    {
        case TO_INDEX       : eRet.eType = TOX_INDEX;       break;
        case TO_USER        :
        {
            eRet.eType = TOX_USER;
            eRet.nIndex  = (nData&0xff00) >> 8;
        }
        break;
        case TO_CONTENT     : eRet.eType = TOX_CONTENT;     break;
        case TO_ILLUSTRATION: eRet.eType = TOX_ILLUSTRATIONS; break;
        case TO_OBJECT      : eRet.eType = TOX_OBJECTS;     break;
        case TO_TABLE       : eRet.eType = TOX_TABLES;      break;
        case TO_AUTHORITIES : eRet.eType = TOX_AUTHORITIES; break;
        default: DBG_ERROR("what a type?");
    }
    return eRet;
}
/* -----------------02.09.99 08:16-------------------

 --------------------------------------------------*/
void    SwTOXSelectTabPage::ApplyTOXDescription()
{
    SwMultiTOXTabDialog* pTOXDlg = (SwMultiTOXTabDialog*)GetTabDialog();
    const CurTOXType aCurType = pTOXDlg->GetCurrentTOXType();
    SwTOXDescription& rDesc = pTOXDlg->GetTOXDescription(aCurType);
    aReadOnlyCB.Check(rDesc.IsReadonly());
    if(aTitleED.GetText() == aTitleED.GetSavedValue())
    {
        if(rDesc.GetTitle())
            aTitleED.SetText(*rDesc.GetTitle());
        else
            aTitleED.SetText(aEmptyStr);
        aTitleED.SaveValue();
    }

    aAreaLB.SelectEntryPos(rDesc.IsFromChapter() ? 1 : 0);

    if(aCurType.eType != TOX_INDEX)
        aLevelNF.SetValue(rDesc.GetLevel());   //content, user

    sal_uInt16 nCreateType = rDesc.GetContentOptions();

    //user + content
    sal_Bool bHasStyleNames = sal_False;
    sal_uInt16 i;

    for( i = 0; i < MAXLEVEL; i++)
        if(rDesc.GetStyleNames(i).Len())
        {
            bHasStyleNames = sal_True;
            break;
        }
    aAddStylesCB.Check(bHasStyleNames && (nCreateType & nsSwTOXElement::TOX_TEMPLATE));

    aFromOLECB.     Check( 0 != (nCreateType & nsSwTOXElement::TOX_OLE) );
    aFromTablesCB.  Check( 0 != (nCreateType & nsSwTOXElement::TOX_TABLE) );
    aFromGraphicsCB.Check( 0 != (nCreateType & nsSwTOXElement::TOX_GRAPHIC) );
    aFromFramesCB.  Check( 0 != (nCreateType & nsSwTOXElement::TOX_FRAME) );

    aLevelFromChapterCB.Check(rDesc.IsLevelFromChapter());

    //all but illustration and table
    aTOXMarksCB.Check( 0 != (nCreateType & nsSwTOXElement::TOX_MARK) );

    //content
    if(TOX_CONTENT == aCurType.eType)
    {
        aFromHeadingsCB.Check( 0 != (nCreateType & nsSwTOXElement::TOX_OUTLINELEVEL) );
        //aChapterDlgPB.Enable(aFromHeadingsCB.IsChecked());//#outline level,removed by zhaojianwei
        aAddStylesCB.SetText(sAddStyleContent);
        aAddStylesPB.Enable(aAddStylesCB.IsChecked());
    }
    //index only
    else if(TOX_INDEX == aCurType.eType)
    {
        sal_uInt16 nIndexOptions = rDesc.GetIndexOptions();
        aCollectSameCB.     Check( 0 != (nIndexOptions & nsSwTOIOptions::TOI_SAME_ENTRY) );
        aUseFFCB.           Check( 0 != (nIndexOptions & nsSwTOIOptions::TOI_FF) );
        aUseDashCB.         Check( 0 != (nIndexOptions & nsSwTOIOptions::TOI_DASH) );
        if(aUseFFCB.IsChecked())
            aUseDashCB.Enable(sal_False);
        else if(aUseDashCB.IsChecked())
            aUseFFCB.Enable(sal_False);

        aCaseSensitiveCB.   Check( 0 != (nIndexOptions & nsSwTOIOptions::TOI_CASE_SENSITIVE) );
        aInitialCapsCB.     Check( 0 != (nIndexOptions & nsSwTOIOptions::TOI_INITIAL_CAPS) );
        aKeyAsEntryCB.      Check( 0 != (nIndexOptions & nsSwTOIOptions::TOI_KEY_AS_ENTRY) );
    }
    else if(TOX_ILLUSTRATIONS == aCurType.eType ||
        TOX_TABLES == aCurType.eType)
    {
        aFromObjectNamesRB.Check(rDesc.IsCreateFromObjectNames());
        aFromCaptionsRB.Check(!rDesc.IsCreateFromObjectNames());
        aCaptionSequenceLB.SelectEntry(rDesc.GetSequenceName());
        aDisplayTypeLB.SelectEntryPos( static_cast< sal_uInt16 >(rDesc.GetCaptionDisplay()) );
        RadioButtonHdl(&aFromCaptionsRB);

    }
    else if(TOX_OBJECTS == aCurType.eType)
    {
        long nOLEData = rDesc.GetOLEOptions();
        for(sal_uInt16 nFromObj = 0; nFromObj < aFromObjCLB.GetEntryCount(); nFromObj++)
        {
            long nData = (long)aFromObjCLB.GetEntryData(nFromObj);
            aFromObjCLB.CheckEntryPos(nFromObj, 0 != (nData & nOLEData));
        }
    }
    else if(TOX_AUTHORITIES == aCurType.eType)
    {
        String sBrackets(rDesc.GetAuthBrackets());
        if(!sBrackets.Len() || sBrackets.EqualsAscii("  "))
            aBracketLB.SelectEntryPos(0);
        else
            aBracketLB.SelectEntry(sBrackets);
        aSequenceCB.Check(rDesc.IsAuthSequence());
    }
    aAutoMarkPB.Enable(aFromFileCB.IsChecked());

    for(i = 0; i < MAXLEVEL; i++)
        aStyleArr[i] = rDesc.GetStyleNames(i);

    aLanguageLB.SelectLanguage(rDesc.GetLanguage());
    LanguageHdl(0);
    for( long nCnt = 0; nCnt < aSortAlgorithmLB.GetEntryCount(); ++nCnt )
    {
        const String* pEntryData = (const String*)aSortAlgorithmLB.GetEntryData( (sal_uInt16)nCnt );
        DBG_ASSERT(pEntryData, "no entry data available");
        if( pEntryData && *pEntryData == rDesc.GetSortAlgorithm())
        {
            aSortAlgorithmLB.SelectEntryPos( (sal_uInt16)nCnt );
            break;
        }
    }
}
/* -----------------09.09.99 11:57-------------------

 --------------------------------------------------*/
void SwTOXSelectTabPage::FillTOXDescription()
{
    SwMultiTOXTabDialog* pTOXDlg = (SwMultiTOXTabDialog*)GetTabDialog();
    CurTOXType aCurType = pTOXDlg->GetCurrentTOXType();
    SwTOXDescription& rDesc = pTOXDlg->GetTOXDescription(aCurType);
    rDesc.SetTitle(aTitleED.GetText());
    rDesc.SetFromChapter(1 == aAreaLB.GetSelectEntryPos());
    sal_uInt16 nContentOptions = 0;
    if(aTOXMarksCB.IsVisible() && aTOXMarksCB.IsChecked())
        nContentOptions |= nsSwTOXElement::TOX_MARK;

    sal_uInt16 nIndexOptions = rDesc.GetIndexOptions()&nsSwTOIOptions::TOI_ALPHA_DELIMITTER;
    switch(rDesc.GetTOXType())
    {
        case TOX_CONTENT:
            if(aFromHeadingsCB.IsChecked())
                nContentOptions |= nsSwTOXElement::TOX_OUTLINELEVEL;
        break;
        case TOX_USER:
        {
            rDesc.SetTOUName(aTypeLB.GetSelectEntry());

            if(aFromOLECB.IsChecked())
                nContentOptions |= nsSwTOXElement::TOX_OLE;
            if(aFromTablesCB.IsChecked())
                nContentOptions |= nsSwTOXElement::TOX_TABLE;
            if(aFromFramesCB.IsChecked())
                nContentOptions |= nsSwTOXElement::TOX_FRAME;
            if(aFromGraphicsCB.IsChecked())
                nContentOptions |= nsSwTOXElement::TOX_GRAPHIC;
        }
        break;
        case  TOX_INDEX:
        {
            nContentOptions = nsSwTOXElement::TOX_MARK;

            if(aCollectSameCB.IsChecked())
                nIndexOptions |= nsSwTOIOptions::TOI_SAME_ENTRY;
            if(aUseFFCB.IsChecked())
                nIndexOptions |= nsSwTOIOptions::TOI_FF;
            if(aUseDashCB.IsChecked())
                nIndexOptions |= nsSwTOIOptions::TOI_DASH;
            if(aCaseSensitiveCB.IsChecked())
                nIndexOptions |= nsSwTOIOptions::TOI_CASE_SENSITIVE;
            if(aInitialCapsCB.IsChecked())
                nIndexOptions |= nsSwTOIOptions::TOI_INITIAL_CAPS;
            if(aKeyAsEntryCB.IsChecked())
                nIndexOptions |= nsSwTOIOptions::TOI_KEY_AS_ENTRY;
            if(aFromFileCB.IsChecked())
                rDesc.SetAutoMarkURL(sAutoMarkURL);
            else
                rDesc.SetAutoMarkURL(aEmptyStr);
        }
        break;
        case TOX_ILLUSTRATIONS:
        case TOX_TABLES :
            rDesc.SetCreateFromObjectNames(aFromObjectNamesRB.IsChecked());
            rDesc.SetSequenceName(aCaptionSequenceLB.GetSelectEntry());
            rDesc.SetCaptionDisplay((SwCaptionDisplay)aDisplayTypeLB.GetSelectEntryPos());
        break;
        case TOX_OBJECTS:
        {
            long nOLEData = 0;
            for(sal_uInt16 i = 0; i < aFromObjCLB.GetEntryCount(); i++)
            {
                if(aFromObjCLB.IsChecked(i))
                {
                    long nData = (long)aFromObjCLB.GetEntryData(i);
                    nOLEData |= nData;
                }
            }
            rDesc.SetOLEOptions((sal_uInt16)nOLEData);
        }
        break;
        case TOX_AUTHORITIES:
        {
            if(aBracketLB.GetSelectEntryPos())
                rDesc.SetAuthBrackets(aBracketLB.GetSelectEntry());
            else
                rDesc.SetAuthBrackets(aEmptyStr);
            rDesc.SetAuthSequence(aSequenceCB.IsChecked());
        }
        break;
    }

    rDesc.SetLevelFromChapter(  aLevelFromChapterCB.IsVisible() &&
                                aLevelFromChapterCB.IsChecked());
    if(aTOXMarksCB.IsChecked() && aTOXMarksCB.IsVisible())
        nContentOptions |= nsSwTOXElement::TOX_MARK;
    if(aFromHeadingsCB.IsChecked() && aFromHeadingsCB.IsVisible())
        nContentOptions |= nsSwTOXElement::TOX_OUTLINELEVEL;
    if(aAddStylesCB.IsChecked() && aAddStylesCB.IsVisible())
        nContentOptions |= nsSwTOXElement::TOX_TEMPLATE;

    rDesc.SetContentOptions(nContentOptions);
    rDesc.SetIndexOptions(nIndexOptions);
    rDesc.SetLevel( static_cast< sal_uInt8 >(aLevelNF.GetValue()) );

    rDesc.SetReadonly(aReadOnlyCB.IsChecked());

    for(sal_uInt16 i = 0; i < MAXLEVEL; i++)
        rDesc.SetStyleNames(aStyleArr[i], i);

    rDesc.SetLanguage(aLanguageLB.GetSelectLanguage());
    const String* pEntryData = (const String*)aSortAlgorithmLB.GetEntryData(
                                            aSortAlgorithmLB.GetSelectEntryPos() );
    DBG_ASSERT(pEntryData, "no entry data available");
    if(pEntryData)
        rDesc.SetSortAlgorithm(*pEntryData);
}
/* -----------------05.07.99 15:09-------------------

 --------------------------------------------------*/
void SwTOXSelectTabPage::Reset( const SfxItemSet& )
{
    SwMultiTOXTabDialog* pTOXDlg = (SwMultiTOXTabDialog*)GetTabDialog();
    SwWrtShell& rSh = pTOXDlg->GetWrtShell();
    const CurTOXType aCurType = pTOXDlg->GetCurrentTOXType();
    long nData = lcl_TOXTypesToUserData(aCurType);
    aTypeLB.SelectEntryPos(aTypeLB.GetEntryPos((void*)nData));

    sAutoMarkURL = INetURLObject::decode( rSh.GetTOIAutoMarkURL(),
                                        INET_HEX_ESCAPE,
                                        INetURLObject::DECODE_UNAMBIGUOUS,
                                        RTL_TEXTENCODING_UTF8 );
    aFromFileCB.Check( 0 != sAutoMarkURL.Len() );

    aCaptionSequenceLB.Clear();
    sal_uInt16 i, nCount = rSh.GetFldTypeCount(RES_SETEXPFLD);
    for (i = 0; i < nCount; i++)
    {
        SwFieldType *pType = rSh.GetFldType( i, RES_SETEXPFLD );
        if( pType->Which() == RES_SETEXPFLD &&
            ((SwSetExpFieldType *) pType)->GetType() & nsSwGetSetExpType::GSE_SEQ )
            aCaptionSequenceLB.InsertEntry(pType->GetName());
    }

    if(pTOXDlg->IsTOXEditMode())
    {
        aTypeFT.Enable(sal_False);
        aTypeLB.Enable(sal_False);
    }
    TOXTypeHdl(&aTypeLB);
    CheckBoxHdl(&aAddStylesCB);
}
/*-- 14.06.99 13:10:52---------------------------------------------------

  -----------------------------------------------------------------------*/
void SwTOXSelectTabPage::ActivatePage( const SfxItemSet& )
{
    //nothing to do
}
/*-- 14.06.99 13:11:00---------------------------------------------------

  -----------------------------------------------------------------------*/
int SwTOXSelectTabPage::DeactivatePage( SfxItemSet* _pSet )
{
    if(_pSet)
        _pSet->Put(SfxUInt16Item(FN_PARAM_TOX_TYPE,
            (sal_uInt16)(long)aTypeLB.GetEntryData( aTypeLB.GetSelectEntryPos() )));
    FillTOXDescription();
    return LEAVE_PAGE;
}
/* -----------------14.06.99 13:10-------------------

 --------------------------------------------------*/
SfxTabPage* SwTOXSelectTabPage::Create( Window* pParent, const SfxItemSet& rAttrSet)
{
    return new SwTOXSelectTabPage(pParent, rAttrSet);
}
/* -----------------14.06.99 13:10-------------------

 --------------------------------------------------*/
IMPL_LINK(SwTOXSelectTabPage, TOXTypeHdl,   ListBox*, pBox)
{
    SwMultiTOXTabDialog* pTOXDlg = (SwMultiTOXTabDialog*)GetTabDialog();
    if(!bFirstCall)
    {
        // save current values into the proper TOXDescription
        FillTOXDescription();
    }
    bFirstCall = sal_False;
    const sal_uInt16 nType =  sal::static_int_cast< sal_uInt16 >(reinterpret_cast< sal_uIntPtr >(
                                pBox->GetEntryData( pBox->GetSelectEntryPos() )));
    CurTOXType eCurType = lcl_UserData2TOXTypes(nType);
    pTOXDlg->SetCurrentTOXType(eCurType);

    aAreaLB.Show( 0 != (nType & (TO_CONTENT|TO_ILLUSTRATION|TO_USER|TO_INDEX|TO_TABLE|TO_OBJECT)) );
    aLevelFT.Show( 0 != (nType & (TO_CONTENT)) );
    aLevelNF.Show( 0 != (nType & (TO_CONTENT)) );
    aLevelFromChapterCB.Show( 0 != (nType & (TO_USER)) );
    aAreaFT.Show( 0 != (nType & (TO_CONTENT|TO_ILLUSTRATION|TO_USER|TO_INDEX|TO_TABLE|TO_OBJECT)) );
    aAreaFL.Show( 0 != (nType & (TO_CONTENT|TO_ILLUSTRATION|TO_USER|TO_INDEX|TO_TABLE|TO_OBJECT)) );

    aFromHeadingsCB.Show( 0 != (nType & (TO_CONTENT)) );
   // aChapterDlgPB.Show( 0 != (nType & (TO_CONTENT)) );//#outline level,removed by zhaojianwei
    aAddStylesCB.Show( 0 != (nType & (TO_CONTENT|TO_USER)) );
    aAddStylesPB.Show( 0 != (nType & (TO_CONTENT|TO_USER)) );

    aFromTablesCB.Show( 0 != (nType & (TO_USER)) );
    aFromFramesCB.Show( 0 != (nType & (TO_USER)) );
    aFromGraphicsCB.Show( 0 != (nType & (TO_USER)) );
    aFromOLECB.Show( 0 != (nType & (TO_USER)) );

    aFromCaptionsRB.Show( 0 != (nType & (TO_ILLUSTRATION|TO_TABLE)) );
    aFromObjectNamesRB.Show( 0 != (nType & (TO_ILLUSTRATION|TO_TABLE)) );

    aTOXMarksCB.Show( 0 != (nType & (TO_CONTENT|TO_USER)) );

    aCreateFromFL.Show( 0 != (nType & (TO_CONTENT|TO_ILLUSTRATION|TO_USER|TO_TABLE)) );
    aCaptionSequenceFT.Show( 0 != (nType & (TO_ILLUSTRATION|TO_TABLE)) );
    aCaptionSequenceLB.Show( 0 != (nType & (TO_ILLUSTRATION|TO_TABLE)) );
    aDisplayTypeFT.Show( 0 != (nType & (TO_ILLUSTRATION|TO_TABLE)) );
    aDisplayTypeLB.Show( 0 != (nType & (TO_ILLUSTRATION|TO_TABLE)) );

    aSequenceCB.Show( 0 != (nType & TO_AUTHORITIES) );
    aBracketFT.Show( 0 != (nType & TO_AUTHORITIES) );
    aBracketLB.Show( 0 != (nType & TO_AUTHORITIES) );
    aAuthorityFormatFL.Show( 0 != (nType & TO_AUTHORITIES) );

    sal_Bool bEnableSortLanguage = 0 != (nType & (TO_INDEX|TO_AUTHORITIES));
    aSortOptionsFL.Show(bEnableSortLanguage);
    aLanguageFT.Show(bEnableSortLanguage);
    aLanguageLB.Show(bEnableSortLanguage);
    aSortAlgorithmFT.Show(bEnableSortLanguage);
    aSortAlgorithmLB.Show(bEnableSortLanguage);

    //if(nType & TO_CONTENT)            //#outline level,removed by zhaojianwei
    //{
        //Point aPos(aAddStylesPB.GetPosPixel());
        //aPos.X() = aChapterDlgPB.GetPosPixel().X();
        //aAddStylesPB.SetPosPixel(aPos);
    //}
    //else if( nType & TO_ILLUSTRATION )//<-removed end.
        // initialize button positions

    //#i111993# add styles button has two different positions
    if( !aAddStylesPosDef.X() )
    {
        aAddStylesPosDef = ( aAddStylesPB.GetPosPixel() );
        // move left!
        Point aPos(aAddStylesPosDef);
        aPos.X() -= 2 * aAddStylesPB.GetSizePixel().Width();
        aAddStylesPosUser = aPos;
    }

    if( nType & TO_ILLUSTRATION )       //add by zhaojianwei
        aCaptionSequenceLB.SelectEntry( SwStyleNameMapper::GetUIName(
                                    RES_POOLCOLL_LABEL_ABB, aEmptyStr ));
    else if( nType & TO_TABLE )
        aCaptionSequenceLB.SelectEntry( SwStyleNameMapper::GetUIName(
                                    RES_POOLCOLL_LABEL_TABLE, aEmptyStr ));
    else if( nType & TO_USER )
    {
        aAddStylesCB.SetText(sAddStyleUser);
        aAddStylesPB.SetPosPixel(aAddStylesPosUser);
    }
    else if( nType & TO_CONTENT )
    {
        aAddStylesPB.SetPosPixel(aAddStylesPosDef);
    }

    aCollectSameCB.Show( 0 != (nType & TO_INDEX) );
    aUseFFCB.Show( 0 != (nType & TO_INDEX) );
    aUseDashCB.Show( 0 != (nType & TO_INDEX) );
    aCaseSensitiveCB.Show( 0 != (nType & TO_INDEX) );
    aInitialCapsCB.Show( 0 != (nType & TO_INDEX) );
    aKeyAsEntryCB.Show( 0 != (nType & TO_INDEX) );
    aFromFileCB.Show( 0 != (nType & TO_INDEX) );
    aAutoMarkPB.Show( 0 != (nType & TO_INDEX) );
//  aCreateAutoMarkPB.Show(nType &TO_INDEX);
//  aEditAutoMarkPB.Show(nType & TO_INDEX);

    aIdxOptionsFL.Show( 0 != (nType & TO_INDEX) );

    //object index
    aFromObjCLB.Show( 0 != (nType & TO_OBJECT) );
    aFromObjFL.Show( 0 != (nType & TO_OBJECT) );

    //move controls
    aAddStylesCB.SetPosPixel(nType & TO_USER ? aCBLeftPos1 : aCBLeftPos2);
 Point aPBPos(aAddStylesPB.GetPosPixel());
    aPBPos.Y() = nType & TO_USER ? aCBLeftPos1.Y() : aCBLeftPos2.Y();
    aAddStylesPB.SetPosPixel(aPBPos);
    aTOXMarksCB.SetPosPixel(nType & TO_USER ? aCBLeftPos2 : aCBLeftPos3);
    //set control values from the proper TOXDescription
    {
        ApplyTOXDescription();
    }
    ModifyHdl(0);
    return 0;
}
/* -----------------30.11.99 12:48-------------------

 --------------------------------------------------*/
IMPL_LINK(SwTOXSelectTabPage, ModifyHdl, void*, EMPTYARG)
{
    SwMultiTOXTabDialog* pTOXDlg = (SwMultiTOXTabDialog*)GetTabDialog();
    if(pTOXDlg)
    {
        FillTOXDescription();
        pTOXDlg->CreateOrUpdateExample(pTOXDlg->GetCurrentTOXType().eType, TOX_PAGE_SELECT);
    }
    return 0;
}
/* -----------------05.07.99 10:13-------------------

 --------------------------------------------------*/
IMPL_LINK(SwTOXSelectTabPage, CheckBoxHdl,  CheckBox*, pBox )
{
    SwMultiTOXTabDialog* pTOXDlg = (SwMultiTOXTabDialog*)GetTabDialog();
    const CurTOXType aCurType = pTOXDlg->GetCurrentTOXType();
    if(TOX_CONTENT == aCurType.eType)
    {
        //at least one of the three CheckBoxes must be checked
        if(!aAddStylesCB.IsChecked() && !aFromHeadingsCB.IsChecked() && !aTOXMarksCB.IsChecked())
        {
            //TODO: InfoBox?
            pBox->Check(sal_True);
        }
        aAddStylesPB.Enable(aAddStylesCB.IsChecked());
        //aChapterDlgPB.Enable(aFromHeadingsCB.IsChecked());//#outline level,removed by zhaojianwei
    }
    if(TOX_USER == aCurType.eType)
    {
        aAddStylesPB.Enable(aAddStylesCB.IsChecked());
    }
    else if(TOX_INDEX == aCurType.eType)
    {
        aAutoMarkPB.Enable(aFromFileCB.IsChecked());
        aUseFFCB.Enable(aCollectSameCB.IsChecked() && !aUseDashCB.IsChecked());
        aUseDashCB.Enable(aCollectSameCB.IsChecked() && !aUseFFCB.IsChecked());
        aCaseSensitiveCB.Enable(aCollectSameCB.IsChecked());
    }
    ModifyHdl(0);
    return 0;
};
/* -----------------14.07.99 14:21-------------------

 --------------------------------------------------*/
IMPL_LINK(SwTOXSelectTabPage, RadioButtonHdl, RadioButton*, EMPTYARG )
{
    sal_Bool bEnable = aFromCaptionsRB.IsChecked();
    aCaptionSequenceFT.Enable(bEnable);
    aCaptionSequenceLB.Enable(bEnable);
    aDisplayTypeFT.Enable(bEnable);
    aDisplayTypeLB.Enable(bEnable);
    ModifyHdl(0);
    return 0;
}
/* -----------------------------06.06.01 09:33--------------------------------

 ---------------------------------------------------------------------------*/
IMPL_LINK(SwTOXSelectTabPage, LanguageHdl, ListBox*, pBox)
{
    Locale aLcl( SvxCreateLocale( aLanguageLB.GetSelectLanguage() ) );
    Sequence< OUString > aSeq = pIndexEntryWrapper->GetAlgorithmList( aLcl );

    if( !pIndexRes )
        pIndexRes = new IndexEntryRessource();

    String sOldString;
    void* pUserData;
    if( 0 != (pUserData = aSortAlgorithmLB.GetEntryData( aSortAlgorithmLB.GetSelectEntryPos())) )
        sOldString = *(String*)pUserData;
    void* pDel;
    sal_uInt16 nEnd = aSortAlgorithmLB.GetEntryCount();
    for( sal_uInt16 n = 0; n < nEnd; ++n )
        if( 0 != ( pDel = aSortAlgorithmLB.GetEntryData( n )) )
            delete (String*)pDel;
    aSortAlgorithmLB.Clear();

    sal_uInt16 nInsPos;
    String sAlg, sUINm;
    nEnd = static_cast< sal_uInt16 >(aSeq.getLength());
    for( sal_uInt16 nCnt = 0; nCnt < nEnd; ++nCnt )
    {
        sUINm = pIndexRes->GetTranslation( sAlg = aSeq[ nCnt ] );
        nInsPos = aSortAlgorithmLB.InsertEntry( sUINm );
        aSortAlgorithmLB.SetEntryData( nInsPos, new String( sAlg ));
        if( sAlg == sOldString )
            aSortAlgorithmLB.SelectEntryPos( nInsPos );
    }

    if( LISTBOX_ENTRY_NOTFOUND == aSortAlgorithmLB.GetSelectEntryPos() )
        aSortAlgorithmLB.SelectEntryPos( 0 );

    if(pBox)
        ModifyHdl(0);
    return 0;
};
/* -----------------14.06.99 13:10-------------------

 --------------------------------------------------*/
IMPL_LINK(SwTOXSelectTabPage, TOXAreaHdl,   ListBox*, pBox)
{
    DBG_WARNING("not implemented");
    switch((long)pBox->GetEntryData( pBox->GetSelectEntryPos() ))
    {
        case AREA_DOCUMENT  : break;
        case AREA_CHAPTER   : break;
    }
    return 0;
}

//#outline level, removed by zhaojianwei
//It is no longer used!
///* -----------------14.06.99 13:10-------------------
//
// --------------------------------------------------*/
//IMPL_LINK(SwTOXSelectTabPage, ChapterHdl,     PushButton*, pButton)
//{
//  SwMultiTOXTabDialog* pTOXDlg = (SwMultiTOXTabDialog*)GetTabDialog();
//  SwWrtShell& rSh = pTOXDlg->GetWrtShell();
//
//  SfxItemSet aTmp(rSh.GetView().GetPool(), FN_PARAM_1, FN_PARAM_1);
//  SwOutlineTabDialog* pDlg = new SwOutlineTabDialog(pButton, &aTmp, rSh);
//
//  if(RET_OK == pDlg->Execute())
//  {
//      CurTOXType aCurType = pTOXDlg->GetCurrentTOXType();
//      SwForm* pForm = ((SwMultiTOXTabDialog*)GetTabDialog())->GetForm(aCurType);
//      // jetzt muss ueberprueft werden, ob dem sdbcx::Index Ueberschriftenvorlagen
//      // zugewiesen wurden
//      String sStr;
//      for(sal_uInt16 i = 0; i < MAXLEVEL; i++)
//      {
//          sal_Bool bNum = !SwMultiTOXTabDialog::IsNoNum(rSh, pForm->GetTemplate( i + 1 ));
//          if(bNum)
//          {
//              //es gibt getrennte Resourcebereiche fuer die Inhaltsverzeichnisse
//              if(i < 5)
//                    SwStyleNameMapper::FillUIName( static_cast< sal_uInt16 >(RES_POOLCOLL_TOX_CNTNT1 + i), sStr );
//              else
//                    SwStyleNameMapper::FillUIName( static_cast< sal_uInt16 >(RES_POOLCOLL_TOX_CNTNT6 + i - 5), sStr );
//              pForm->SetTemplate( i + 1, sStr );
//          }
//      }
//
//  }
//  delete pDlg;
//  return 0;
//}
/* -----------------14.06.99 13:10-------------------

 --------------------------------------------------*/
IMPL_LINK(SwTOXSelectTabPage, AddStylesHdl, PushButton*, pButton)
{
    SwAddStylesDlg_Impl* pDlg = new SwAddStylesDlg_Impl(pButton,
        ((SwMultiTOXTabDialog*)GetTabDialog())->GetWrtShell(),
        aStyleArr);
    pDlg->Execute();
    delete pDlg;
    ModifyHdl(0);
    return 0;
}
/* -----------------------------19.01.00 10:59--------------------------------

 ---------------------------------------------------------------------------*/

IMPL_LINK(SwTOXSelectTabPage, MenuEnableHdl, Menu*, pMenu)
{
    pMenu->EnableItem(MN_AUTOMARK_EDIT, sAutoMarkURL.Len() > 0);
    return 0;
}

IMPL_LINK(SwTOXSelectTabPage, MenuExecuteHdl, Menu*, pMenu)
{
    const String sSaveAutoMarkURL = sAutoMarkURL;
    switch(pMenu->GetCurItemId())
    {
        case  MN_AUTOMARK_OPEN:
            sAutoMarkURL = lcl_CreateAutoMarkFileDlg(
                                    sAutoMarkURL, sAutoMarkType, sal_True);
        break;
        case  MN_AUTOMARK_NEW :
            sAutoMarkURL = lcl_CreateAutoMarkFileDlg(
                                    sAutoMarkURL, sAutoMarkType, sal_False);
            if( !sAutoMarkURL.Len() )
                break;
        //no break
        case  MN_AUTOMARK_EDIT:
        {
            sal_Bool bNew = pMenu->GetCurItemId()== MN_AUTOMARK_NEW;
            SwAutoMarkDlg_Impl* pAutoMarkDlg = new SwAutoMarkDlg_Impl(
                    &aAutoMarkPB, sAutoMarkURL, sAutoMarkType, bNew );

            if( RET_OK != pAutoMarkDlg->Execute() && bNew )
                sAutoMarkURL = sSaveAutoMarkURL;
            delete pAutoMarkDlg;

        }
        break;
    }
    return 0;
}

/* -----------------16.06.99 10:46-------------------

 --------------------------------------------------*/
class SwTOXEdit : public Edit
{
    SwFormToken aFormToken;
    Link        aPrevNextControlLink;
    sal_Bool        bNextControl;
    SwTokenWindow* m_pParent;
public:
    SwTOXEdit( Window* pParent, SwTokenWindow* pTokenWin,
                const SwFormToken& aToken)
        : Edit( pParent, WB_BORDER|WB_TABSTOP|WB_CENTER),
        aFormToken(aToken),
        bNextControl(sal_False),
        m_pParent( pTokenWin )
    {
        SetHelpId( HID_TOX_ENTRY_EDIT );
    }

    virtual void    KeyInput( const KeyEvent& rKEvt );
    virtual void    RequestHelp( const HelpEvent& rHEvt );

    sal_Bool    IsNextControl() const {return bNextControl;}
    void SetPrevNextLink( const Link& rLink )   {aPrevNextControlLink = rLink;}

    const SwFormToken&  GetFormToken()
        {
            aFormToken.sText = GetText();
            return aFormToken;
        }

    void    SetCharStyleName(const String& rSet, sal_uInt16 nPoolId)
        {
            aFormToken.sCharStyleName = rSet;
            aFormToken.nPoolId = nPoolId;
        }

    void    AdjustSize();
};

//---------------------------------------------------
void    SwTOXEdit::RequestHelp( const HelpEvent& rHEvt )
{
    if(!m_pParent->CreateQuickHelp(this, aFormToken, rHEvt))
        Edit::RequestHelp(rHEvt);
}
//---------------------------------------------------
void    SwTOXEdit::KeyInput( const KeyEvent& rKEvt )
{
    const Selection& rSel = GetSelection();
    sal_uInt16 nTextLen = GetText().Len();
    if( (rSel.A() == rSel.B() &&
         !rSel.A() ) || rSel.A() == nTextLen )
    {
        sal_Bool bCall = sal_False;
        KeyCode aCode = rKEvt.GetKeyCode();
        if(aCode.GetCode() == KEY_RIGHT && rSel.A() == nTextLen)
        {
            bNextControl = sal_True;
            bCall = sal_True;
        }
        else if(aCode.GetCode() == KEY_LEFT && !rSel.A() )
        {
            bNextControl = sal_False;
            bCall = sal_True;
        }
        else if ( (aCode.GetCode() == KEY_F3) && aCode.IsShift() && !aCode.IsMod1() && !aCode.IsMod2() )
        {
            if ( m_pParent )
            {
                m_pParent->SetFocus2theAllBtn();
            }
        }
        if(bCall && aPrevNextControlLink.IsSet())
            aPrevNextControlLink.Call(this);

    }
    Edit::KeyInput(rKEvt);
}
/* -----------------16.07.99 12:41-------------------

 --------------------------------------------------*/
void SwTOXEdit::AdjustSize()
{
    Size aSize(GetSizePixel());
    Size aTextSize(GetTextWidth(GetText()), GetTextHeight());
    aTextSize = LogicToPixel(aTextSize);
    aSize.Width() = aTextSize.Width() + EDIT_MINWIDTH;
    SetSizePixel(aSize);
}

//---------------------------------------------------
//---------------------------------------------------
class SwTOXButton : public PushButton
{
    SwFormToken aFormToken;
    Link        aPrevNextControlLink;
    sal_Bool        bNextControl;
    SwTokenWindow* m_pParent;
public:
    SwTOXButton( Window* pParent, SwTokenWindow* pTokenWin,
                const SwFormToken& rToken)
        : PushButton(pParent, WB_BORDER|WB_TABSTOP),
        aFormToken(rToken),
        bNextControl(sal_False),
        m_pParent(pTokenWin)
    {
        SetHelpId(HID_TOX_ENTRY_BUTTON);
    }

    virtual void    KeyInput( const KeyEvent& rKEvt );
    virtual void    RequestHelp( const HelpEvent& rHEvt );

    sal_Bool IsNextControl() const          {return bNextControl;}
    void SetPrevNextLink(const Link& rLink) {aPrevNextControlLink = rLink;}
    const SwFormToken& GetFormToken() const {return aFormToken;}

    void SetCharStyleName(const String& rSet, sal_uInt16 nPoolId)
        {
            aFormToken.sCharStyleName = rSet;
            aFormToken.nPoolId = nPoolId;
        }

    void SetTabPosition(SwTwips nSet)
        { aFormToken.nTabStopPosition = nSet; }

    void SetFillChar( sal_Unicode cSet )
        { aFormToken.cTabFillChar = cSet; }

    void SetTabAlign(SvxTabAdjust eAlign)
         {  aFormToken.eTabAlign = eAlign;}

//---> i89791
    //used for entry number format, in TOC only
    //needed for different UI dialog position
    void SetEntryNumberFormat(sal_uInt16 nSet) {
        switch(nSet)
        {
        default:
        case 0:
            aFormToken.nChapterFormat = CF_NUMBER;
            break;
        case 1:
            aFormToken.nChapterFormat = CF_NUM_NOPREPST_TITLE;
            break;
        }
    }

    void SetChapterInfo(sal_uInt16 nSet) {
        switch(nSet)
        {
        default:
        case 0:
            aFormToken.nChapterFormat = CF_NUM_NOPREPST_TITLE;
            break;
        case 1:
            aFormToken.nChapterFormat = CF_TITLE;
            break;
        case 2:
            aFormToken.nChapterFormat = CF_NUMBER_NOPREPST;
            break;
        }
    }
//<---
    sal_uInt16 GetChapterInfo() const{ return aFormToken.nChapterFormat;}

    void SetOutlineLevel( sal_uInt16 nSet ) { aFormToken.nOutlineLevel = nSet;}//i53420
    sal_uInt16 GetOutlineLevel() const{ return aFormToken.nOutlineLevel;}

    void SetLinkEnd()
        {
            DBG_ASSERT(TOKEN_LINK_START == aFormToken.eTokenType,
                                    "call SetLinkEnd for link start only!");
            aFormToken.eTokenType = TOKEN_LINK_END;
            aFormToken.sText.AssignAscii(SwForm::aFormLinkEnd);
            SetText(aFormToken.sText);
        }
    void SetLinkStart()
        {
            DBG_ASSERT(TOKEN_LINK_END == aFormToken.eTokenType,
                                    "call SetLinkStart for link start only!");
            aFormToken.eTokenType = TOKEN_LINK_START;
            aFormToken.sText.AssignAscii(SwForm::aFormLinkStt);
            SetText(aFormToken.sText);
        }
};

//---------------------------------------------------
void    SwTOXButton::KeyInput( const KeyEvent& rKEvt )
{
    sal_Bool bCall = sal_False;
    KeyCode aCode = rKEvt.GetKeyCode();
    if(aCode.GetCode() == KEY_RIGHT)
    {
        bNextControl = sal_True;
        bCall = sal_True;
    }
    else if(aCode.GetCode() == KEY_LEFT  )
    {
        bNextControl = sal_False;
        bCall = sal_True;
    }
    else if(aCode.GetCode() == KEY_DELETE)
    {
        m_pParent->RemoveControl(this, sal_True);
        //this is invalid here
        return;
    }
    else if ( (aCode.GetCode() == KEY_F3) && aCode.IsShift() && !aCode.IsMod1() && !aCode.IsMod2() )
    {
        if ( m_pParent )
        {
            m_pParent->SetFocus2theAllBtn();
        }
    }
    if(bCall && aPrevNextControlLink.IsSet())
            aPrevNextControlLink.Call(this);
    else
        PushButton::KeyInput(rKEvt);
}
//---------------------------------------------------
void    SwTOXButton::RequestHelp( const HelpEvent& rHEvt )
{
    if(!m_pParent->CreateQuickHelp(this, aFormToken, rHEvt))
        Button::RequestHelp(rHEvt);
}
/* -----------------------------23.12.99 14:28--------------------------------

 ---------------------------------------------------------------------------*/
SwIdxTreeListBox::SwIdxTreeListBox(SwTOXEntryTabPage* pPar, const ResId& rResId) :
        SvTreeListBox(pPar, rResId),
        pParent(pPar)
{
}
/* -----------------------------23.12.99 14:19--------------------------------

 ---------------------------------------------------------------------------*/
void    SwIdxTreeListBox::RequestHelp( const HelpEvent& rHEvt )
{
    if( rHEvt.GetMode() & HELPMODE_QUICK )
    {
     Point aPos( ScreenToOutputPixel( rHEvt.GetMousePosPixel() ));
        SvLBoxEntry* pEntry = GetEntry( aPos );
        if( pEntry )
        {
            sal_uInt16 nLevel = static_cast< sal_uInt16 >(GetModel()->GetAbsPos(pEntry));
            String sEntry = pParent->GetLevelHelp(++nLevel);
            if('*' == sEntry)
                sEntry = GetEntryText(pEntry);
            if(sEntry.Len())
            {
                SvLBoxTab* pTab;
                SvLBoxItem* pItem = GetItem( pEntry, aPos.X(), &pTab );
                if( pItem && SV_ITEM_ID_LBOXSTRING == pItem->IsA())
                {
                    aPos = GetEntryPosition( pEntry );

                    aPos.X() = GetTabPos( pEntry, pTab );
                 Size aSize( pItem->GetSize( this, pEntry ) );

                    if((aPos.X() + aSize.Width()) > GetSizePixel().Width())
                        aSize.Width() = GetSizePixel().Width() - aPos.X();

                    aPos = OutputToScreenPixel(aPos);
                    Rectangle aItemRect( aPos, aSize );
                    Help::ShowQuickHelp( this, aItemRect, sEntry,
                            QUICKHELP_LEFT|QUICKHELP_VCENTER );
                }
            }
        }
    }
    else
        SvTreeListBox::RequestHelp(rHEvt);
}
//---------------------------------------------------
SwTOXEntryTabPage::SwTOXEntryTabPage(Window* pParent, const SfxItemSet& rAttrSet) :
        SfxTabPage(pParent, SW_RES(TP_TOX_ENTRY), rAttrSet),
    aLevelFT(this,              SW_RES(FT_LEVEL              )),
    aLevelLB(this,              SW_RES(LB_LEVEL             )),
    aEntryFL(this,              SW_RES(FL_ENTRY              )),

    aTokenFT(this,              SW_RES(FT_TOKEN              )),
    aTokenWIN(this,             SW_RES(WIN_TOKEN             )),
    aAllLevelsPB(this,          SW_RES(PB_ALL_LEVELS            )),

    aEntryNoPB(this,            SW_RES(PB_ENTRYNO            )),
    aEntryPB(this,              SW_RES(PB_ENTRY             )),
    aTabPB(this,                SW_RES(PB_TAB                )),
    aChapterInfoPB(this,        SW_RES(PB_CHAPTERINFO        )),
    aPageNoPB(this,             SW_RES(PB_PAGENO                )),
    aHyperLinkPB(this,          SW_RES(PB_HYPERLINK         )),

    aAuthFieldsLB(this,         SW_RES(LB_AUTHFIELD          )),
    aAuthInsertPB(this,         SW_RES(PB_AUTHINSERT            )),
    aAuthRemovePB(this,         SW_RES(PB_AUTHREMOVE            )),

    aCharStyleFT(this,          SW_RES(FT_CHARSTYLE          )),
    aCharStyleLB(this,          SW_RES(LB_CHARSTYLE         )),
    aEditStylePB(this,          SW_RES(PB_EDITSTYLE         )),

    aChapterEntryFT(this,       SW_RES(FT_CHAPTERENTRY       )),
    aChapterEntryLB(this,       SW_RES(LB_CHAPTERENTRY       )),

    aNumberFormatFT(this,       SW_RES(FT_ENTRY_NO           )),//i53420
    aNumberFormatLB(this,       SW_RES(LB_ENTRY_NO           )),
    aEntryOutlineLevelFT(this,  SW_RES(FT_LEVEL_OL           )),//i53420
    aEntryOutlineLevelNF(this,  SW_RES(NF_LEVEL_OL           )),

    aFillCharFT(this,           SW_RES(FT_FILLCHAR           )),
    aFillCharCB(this,           SW_RES(CB_FILLCHAR          )),
    aTabPosFT(this,             SW_RES(FT_TABPOS                )),
    aTabPosMF(this,             SW_RES(MF_TABPOS                )),
    aAutoRightCB(this,          SW_RES(CB_AUTORIGHT         )),
    aFormatFL(this,             SW_RES(FL_FORMAT             )),


    aRelToStyleCB(this,         SW_RES(CB_RELTOSTYLE         )),
    aMainEntryStyleFT(this,     SW_RES(FT_MAIN_ENTRY_STYLE)),
    aMainEntryStyleLB(this,     SW_RES(LB_MAIN_ENTRY_STYLE)),
    aAlphaDelimCB(this,         SW_RES(CB_ALPHADELIM            )),
    aCommaSeparatedCB(this,     SW_RES(CB_COMMASEPARATED        )),

    aSortDocPosRB(this,         SW_RES(RB_DOCPOS                )),
    aSortContentRB(this,        SW_RES(RB_SORTCONTENT       )),
    aSortingFL(this,            SW_RES(FL_SORTING            )),

    aFirstKeyFT(this,           SW_RES(FT_FIRSTKEY          )),
    aFirstKeyLB(this,           SW_RES(LB_FIRSTKEY          )),
    aFirstSortUpRB(this,        SW_RES(RB_SORTUP1            )),
    aFirstSortDownRB(this,      SW_RES(RB_SORTDOWN1          )),

    aSecondKeyFT(this,          SW_RES(FT_SECONDKEY          )),
    aSecondKeyLB(this,          SW_RES(LB_SECONDKEY         )),
    aSecondSortUpRB(this,       SW_RES(RB_SORTUP2            )),
    aSecondSortDownRB(this,     SW_RES(RB_SORTDOWN2          )),

    aThirdKeyFT(this,           SW_RES(FT_THIRDDKEY          )),
    aThirdKeyLB(this,           SW_RES(LB_THIRDKEY           )),
    aThirdSortUpRB(this,        SW_RES(RB_SORTUP3           )),
    aThirdSortDownRB(this,      SW_RES(RB_SORTDOWN3          )),

    aSortKeyFL(this,            SW_RES(FL_SORTKEY            )),

    sDelimStr(                  SW_RES(STR_DELIM)),
    sAuthTypeStr(               SW_RES(ST_AUTHTYPE)),

    sNoCharStyle(               SW_RES(STR_NO_CHAR_STYLE)),
    sNoCharSortKey(             SW_RES(STR_NOSORTKEY        )),
    m_pCurrentForm(0),
    bInLevelHdl(sal_False)
{
    aEditStylePB.SetAccessibleRelationMemberOf(&aEntryFL);
    aHyperLinkPB.SetAccessibleRelationMemberOf(&aEntryFL);
    aPageNoPB.SetAccessibleRelationMemberOf(&aEntryFL);
    aTabPB.SetAccessibleRelationMemberOf(&aEntryFL);
    aEntryPB.SetAccessibleRelationMemberOf(&aEntryFL);
    aEntryNoPB.SetAccessibleRelationMemberOf(&aEntryFL);
    aAllLevelsPB.SetAccessibleRelationMemberOf(&aEntryFL);
    aTokenWIN.SetAccessibleRelationMemberOf(&aEntryFL);
    aTokenWIN.SetAccessibleRelationLabeledBy(&aTokenFT);

    Image aSortUpHC(SW_RES(IMG_SORTUP_HC ));
    aFirstSortUpRB.SetModeRadioImage(aSortUpHC,BMP_COLOR_HIGHCONTRAST);
    aSecondSortUpRB.SetModeRadioImage(aSortUpHC,BMP_COLOR_HIGHCONTRAST);
    aThirdSortUpRB.SetModeRadioImage(aSortUpHC,BMP_COLOR_HIGHCONTRAST);

    Image aSortDownHC(SW_RES(IMG_SORTDOWN_HC ));
    aFirstSortDownRB.SetModeRadioImage(aSortDownHC,BMP_COLOR_HIGHCONTRAST);
    aSecondSortDownRB.SetModeRadioImage(aSortDownHC,BMP_COLOR_HIGHCONTRAST);
    aThirdSortDownRB.SetModeRadioImage(aSortDownHC,BMP_COLOR_HIGHCONTRAST);
    FreeResource();

    sLevelStr = aLevelFT.GetText();
    aLevelLB.SetStyle( aLevelLB.GetStyle() | WB_HSCROLL );
    aLevelLB.SetSpaceBetweenEntries(0);
    aLevelLB.SetSelectionMode( SINGLE_SELECTION );
    aLevelLB.SetHighlightRange();   // select full width
    aLevelLB.SetHelpId(HID_INSERT_INDEX_ENTRY_LEVEL_LB);
    aLevelLB.Show();

    aLastTOXType.eType = (TOXTypes)USHRT_MAX;
    aLastTOXType.nIndex = 0;
    //aLevelGBSize = aLevelGB.GetSizePixel();
    aLevelFLSize = aLevelFT.GetSizePixel();

    SetExchangeSupport();
    aEntryNoPB.SetClickHdl(LINK(this, SwTOXEntryTabPage, InsertTokenHdl));
    aEntryPB.SetClickHdl(LINK(this, SwTOXEntryTabPage, InsertTokenHdl));
    aChapterInfoPB.SetClickHdl(LINK(this, SwTOXEntryTabPage, InsertTokenHdl));
    aPageNoPB.SetClickHdl(LINK(this, SwTOXEntryTabPage, InsertTokenHdl));
    aTabPB.SetClickHdl(LINK(this, SwTOXEntryTabPage, InsertTokenHdl));
    aHyperLinkPB.SetClickHdl(LINK(this, SwTOXEntryTabPage, InsertTokenHdl));
    aEditStylePB.SetClickHdl(LINK(this, SwTOXEntryTabPage, EditStyleHdl));
    aLevelLB.SetSelectHdl(LINK(this, SwTOXEntryTabPage, LevelHdl));
    aTokenWIN.SetButtonSelectedHdl(LINK(this, SwTOXEntryTabPage, TokenSelectedHdl));
    aTokenWIN.SetModifyHdl(LINK(this, SwTOXEntryTabPage, ModifyHdl));
    aCharStyleLB.SetSelectHdl(LINK(this, SwTOXEntryTabPage, StyleSelectHdl));
    aCharStyleLB.InsertEntry(sNoCharStyle);
    aChapterEntryLB.SetSelectHdl(LINK(this, SwTOXEntryTabPage, ChapterInfoHdl));
    aEntryOutlineLevelNF.SetModifyHdl(LINK(this, SwTOXEntryTabPage, ChapterInfoOutlineHdl));
    aNumberFormatLB.SetSelectHdl(LINK(this, SwTOXEntryTabPage, NumberFormatHdl));

    aTabPosMF.SetModifyHdl(LINK(this, SwTOXEntryTabPage, TabPosHdl));
    aFillCharCB.SetModifyHdl(LINK(this, SwTOXEntryTabPage, FillCharHdl));
    aAutoRightCB.SetClickHdl(LINK(this, SwTOXEntryTabPage, AutoRightHdl));
    aAuthInsertPB.SetClickHdl(LINK(this, SwTOXEntryTabPage, RemoveInsertAuthHdl));
    aAuthRemovePB.SetClickHdl(LINK(this, SwTOXEntryTabPage, RemoveInsertAuthHdl));
    aSortDocPosRB.SetClickHdl(LINK(this, SwTOXEntryTabPage, SortKeyHdl));
    aSortContentRB.SetClickHdl(LINK(this, SwTOXEntryTabPage, SortKeyHdl));
    aAllLevelsPB.SetClickHdl(LINK(this, SwTOXEntryTabPage, AllLevelsHdl));

    aAlphaDelimCB.SetClickHdl(LINK(this, SwTOXEntryTabPage, ModifyHdl));
    aCommaSeparatedCB.SetClickHdl(LINK(this, SwTOXEntryTabPage, ModifyHdl));
    aRelToStyleCB.SetClickHdl(LINK(this, SwTOXEntryTabPage, ModifyHdl));

    FieldUnit aMetric = ::GetDfltMetric(sal_False);
    SetMetric(aTabPosMF, aMetric);

    aSortDocPosRB.Check();

    aFillCharCB.SetMaxTextLen(1);
    aFillCharCB.InsertEntry(' ');
    aFillCharCB.InsertEntry('.');
    aFillCharCB.InsertEntry('-');
    aFillCharCB.InsertEntry('_');

    aButtonPositions[0] = aEntryNoPB.GetPosPixel();
    aButtonPositions[1] = aEntryPB.GetPosPixel();
    aButtonPositions[2] = aChapterInfoPB.GetPosPixel();
    aButtonPositions[3] = aPageNoPB.GetPosPixel();
    aButtonPositions[4] = aTabPB.GetPosPixel();

    aRelToStylePos = aRelToStyleCB.GetPosPixel();
    aRelToStyleIdxPos = aCommaSeparatedCB.GetPosPixel();
    aRelToStyleIdxPos.Y() +=
        (aRelToStyleIdxPos.Y() - aAlphaDelimCB.GetPosPixel().Y());
    aEditStylePB.Enable(sal_False);

//get position for Numbering and other stuff
    aChapterEntryFTPosition = aChapterEntryFT.GetPosPixel();
    aEntryOutlineLevelFTPosition = aEntryOutlineLevelFT.GetPosPixel();
    nBiasToEntryPoint = aEntryOutlineLevelNF.GetPosPixel().X() -
                               aEntryOutlineLevelFT.GetPosPixel().X();

    //fill the types in
    sal_uInt16 i;
    for( i = 0; i < AUTH_FIELD_END; i++)
    {
        String sTmp(SW_RES(STR_AUTH_FIELD_START + i));
        sal_uInt16 nPos = aAuthFieldsLB.InsertEntry(sTmp);
        aAuthFieldsLB.SetEntryData(nPos, reinterpret_cast< void * >(sal::static_int_cast< sal_uIntPtr >(i)));
    }
    sal_uInt16 nPos = aFirstKeyLB.InsertEntry(sNoCharSortKey);
    aFirstKeyLB.SetEntryData(nPos, reinterpret_cast< void * >(sal::static_int_cast< sal_uIntPtr >(USHRT_MAX)));
    nPos = aSecondKeyLB.InsertEntry(sNoCharSortKey);
    aSecondKeyLB.SetEntryData(nPos, reinterpret_cast< void * >(sal::static_int_cast< sal_uIntPtr >(USHRT_MAX)));
    nPos = aThirdKeyLB.InsertEntry(sNoCharSortKey);
    aThirdKeyLB.SetEntryData(nPos, reinterpret_cast< void * >(sal::static_int_cast< sal_uIntPtr >(USHRT_MAX)));

    for( i = 0; i < AUTH_FIELD_END; i++)
    {
        String sTmp(aAuthFieldsLB.GetEntry(i));
        void* pEntryData = aAuthFieldsLB.GetEntryData(i);
        nPos = aFirstKeyLB.InsertEntry(sTmp);
        aFirstKeyLB.SetEntryData(nPos, pEntryData);
        nPos = aSecondKeyLB.InsertEntry(sTmp);
        aSecondKeyLB.SetEntryData(nPos, pEntryData);
        nPos = aThirdKeyLB.InsertEntry(sTmp);
        aThirdKeyLB.SetEntryData(nPos, pEntryData);
    }
    aFirstKeyLB.SelectEntryPos(0);
    aSecondKeyLB.SelectEntryPos(0);
    aThirdKeyLB.SelectEntryPos(0);
}
/* -----------------30.11.99 13:37-------------------
    pVoid is used as signal to change all levels of the example
 --------------------------------------------------*/
IMPL_LINK(SwTOXEntryTabPage, ModifyHdl, void*, pVoid)
{
    UpdateDescriptor();
    SwMultiTOXTabDialog* pTOXDlg = (SwMultiTOXTabDialog*)GetTabDialog();

    if(pTOXDlg)
    {
        sal_uInt16 nCurLevel = static_cast< sal_uInt16 >(aLevelLB.GetModel()->GetAbsPos(aLevelLB.FirstSelected()) + 1);
        if(aLastTOXType.eType == TOX_CONTENT && pVoid)
            nCurLevel = USHRT_MAX;
        pTOXDlg->CreateOrUpdateExample(
            pTOXDlg->GetCurrentTOXType().eType, TOX_PAGE_ENTRY, nCurLevel);
    }
    return 0;
}

/*-- 16.06.99 10:47:33---------------------------------------------------

  -----------------------------------------------------------------------*/
SwTOXEntryTabPage::~SwTOXEntryTabPage()
{
}
/*-- 16.06.99 10:47:33---------------------------------------------------

  -----------------------------------------------------------------------*/
sal_Bool    SwTOXEntryTabPage::FillItemSet( SfxItemSet& )
{
    // nothing to do
    return sal_True;
}
/*-- 16.06.99 10:47:34---------------------------------------------------

  -----------------------------------------------------------------------*/
void SwTOXEntryTabPage::Reset( const SfxItemSet& )
{
    SwMultiTOXTabDialog* pTOXDlg = (SwMultiTOXTabDialog*)GetTabDialog();
    const CurTOXType aCurType = pTOXDlg->GetCurrentTOXType();
    m_pCurrentForm = pTOXDlg->GetForm(aCurType);
    if(TOX_INDEX == aCurType.eType)
    {
        SwTOXDescription& rDesc = pTOXDlg->GetTOXDescription(aCurType);
        String sMainEntryCharStyle = rDesc.GetMainEntryCharStyle();
        if(sMainEntryCharStyle.Len())
        {
            if( LISTBOX_ENTRY_NOTFOUND ==
                    aMainEntryStyleLB.GetEntryPos(sMainEntryCharStyle))
                aMainEntryStyleLB.InsertEntry(
                        sMainEntryCharStyle);
            aMainEntryStyleLB.SelectEntry(sMainEntryCharStyle);
        }
        else
            aMainEntryStyleLB.SelectEntry(sNoCharStyle);
        aAlphaDelimCB.Check( 0 != (rDesc.GetIndexOptions() & nsSwTOIOptions::TOI_ALPHA_DELIMITTER) );
    }
    aRelToStyleCB.Check(m_pCurrentForm->IsRelTabPos());
    aCommaSeparatedCB.Check(m_pCurrentForm->IsCommaSeparated());
}
/*-- 16.06.99 10:47:34---------------------------------------------------

  -----------------------------------------------------------------------*/
void lcl_ChgWidth(Window& rWin, long nDiff)
{
 Size aTempSz(rWin.GetSizePixel());
    aTempSz.Width() += nDiff;
    rWin.SetSizePixel(aTempSz);
}
/* ----------------------------------------------------------------------

  -----------------------------------------------------------------------*/
void lcl_ChgXPos(Window& rWin, long nDiff)
{
    Point aTempPos(rWin.GetPosPixel());
    aTempPos.X() += nDiff;
    rWin.SetPosPixel(aTempPos);
}
/* ----------------------------------------------------------------------

  -----------------------------------------------------------------------*/
void SwTOXEntryTabPage::ActivatePage( const SfxItemSet& /*rSet*/)
{
    SwMultiTOXTabDialog* pTOXDlg = (SwMultiTOXTabDialog*)GetTabDialog();
    const CurTOXType aCurType = pTOXDlg->GetCurrentTOXType();

    m_pCurrentForm = pTOXDlg->GetForm(aCurType);
    if( !( aLastTOXType == aCurType ))
    {
        sal_Bool bToxIsAuthorities = TOX_AUTHORITIES == aCurType.eType;
        sal_Bool bToxIsIndex =       TOX_INDEX == aCurType.eType;
        sal_Bool bToxIsContent =     TOX_CONTENT == aCurType.eType;

        aLevelLB.Clear();
        for(sal_uInt16 i = 1; i < m_pCurrentForm->GetFormMax(); i++)
        {
            if(bToxIsAuthorities)
                aLevelLB.InsertEntry( SwAuthorityFieldType::GetAuthTypeName(
                                            (ToxAuthorityType) (i - 1)) );
            else if( bToxIsIndex )
            {
                if(i == 1)
                    aLevelLB.InsertEntry( sDelimStr );
                else
                    aLevelLB.InsertEntry( String::CreateFromInt32(i - 1) );
            }
            else
                aLevelLB.InsertEntry(String::CreateFromInt32(i));
        }
        if(bToxIsAuthorities)
        {
            //
            SwWrtShell& rSh = pTOXDlg->GetWrtShell();
            const SwAuthorityFieldType* pFType = (const SwAuthorityFieldType*)
                                    rSh.GetFldType(RES_AUTHORITY, aEmptyStr);
            if(pFType)
            {
                if(pFType->IsSortByDocument())
                    aSortDocPosRB.Check();
                else
                {
                    aSortContentRB.Check();
                    sal_uInt16 nKeyCount = pFType->GetSortKeyCount();
                    if(0 < nKeyCount)
                    {
                        const SwTOXSortKey* pKey = pFType->GetSortKey(0);
                        aFirstKeyLB.SelectEntryPos(
                            aFirstKeyLB.GetEntryPos((void*)(sal_uInt32)pKey->eField));
                        aFirstSortUpRB.Check(pKey->bSortAscending);
                        aFirstSortDownRB.Check(!pKey->bSortAscending);
                    }
                    if(1 < nKeyCount)
                    {
                        const SwTOXSortKey* pKey = pFType->GetSortKey(1);
                        aSecondKeyLB.SelectEntryPos(
                            aSecondKeyLB.GetEntryPos((void*)(sal_uInt32)pKey->eField));
                        aSecondSortUpRB.Check(pKey->bSortAscending);
                        aSecondSortDownRB.Check(!pKey->bSortAscending);
                    }
                    if(2 < nKeyCount)
                    {
                        const SwTOXSortKey* pKey = pFType->GetSortKey(2);
                        aThirdKeyLB.SelectEntryPos(
                            aThirdKeyLB.GetEntryPos((void*)(sal_uInt32)pKey->eField));
                        aThirdSortUpRB.Check(pKey->bSortAscending);
                        aThirdSortDownRB.Check(!pKey->bSortAscending);
                    }
                }
            }
            SortKeyHdl(aSortDocPosRB.IsChecked() ? &aSortDocPosRB : &aSortContentRB);
            aLevelFT.SetText(sAuthTypeStr);
        }
        else
            aLevelFT.SetText(sLevelStr);

        long nDiff = 0;
        if( bToxIsAuthorities ? aLevelFT.GetSizePixel() == aLevelFLSize
                              : aLevelFT.GetSizePixel() != aLevelFLSize )
        {
            nDiff = aLevelFLSize.Width();
            if( !bToxIsAuthorities )
                nDiff *= -1;
        }

        if(nDiff)
        {
//          lcl_ChgWidth(aLevelFL, nDiff);
            lcl_ChgWidth(aLevelFT, nDiff);
            lcl_ChgWidth(aLevelLB, nDiff);
            lcl_ChgXPos(aCharStyleFT, nDiff);
            lcl_ChgXPos(aCharStyleLB, nDiff);
            lcl_ChgWidth(aCharStyleLB, -nDiff);
    //          lcl_ChgXPos(aEditStylePB, -nDiff);
            lcl_ChgXPos(aFillCharFT,  nDiff);
            lcl_ChgXPos(aFillCharCB,  nDiff);
            lcl_ChgXPos(aTabPosFT,   nDiff);
            lcl_ChgXPos(aTabPosMF,   nDiff);
            lcl_ChgXPos(aAutoRightCB, nDiff);
            lcl_ChgXPos(aAuthFieldsLB,   nDiff);
            lcl_ChgXPos(aAuthInsertPB,   nDiff);
            lcl_ChgXPos(aAuthRemovePB,   nDiff);
            lcl_ChgXPos(aTokenFT, nDiff);
            lcl_ChgXPos(aTokenWIN,   nDiff);
            lcl_ChgWidth(aTokenWIN, -nDiff);
            lcl_ChgXPos(aSortDocPosRB,   nDiff);
            lcl_ChgXPos(aSortContentRB,      nDiff);
            lcl_ChgXPos(aFormatFL,  nDiff);
            lcl_ChgWidth(aFormatFL,     -nDiff);
            lcl_ChgXPos(aSortingFL, nDiff);
            lcl_ChgWidth(aSortingFL,    -nDiff);
            lcl_ChgXPos(aEntryFL,   nDiff);
            lcl_ChgWidth(aEntryFL,  -nDiff);

            lcl_ChgXPos(aFirstKeyFT, nDiff);
            lcl_ChgXPos(aFirstKeyLB, nDiff);
            lcl_ChgXPos(aSecondKeyFT, nDiff);
            lcl_ChgXPos(aSecondKeyLB, nDiff);
            lcl_ChgXPos(aThirdKeyFT, nDiff);
            lcl_ChgXPos(aThirdKeyLB, nDiff);
            lcl_ChgXPos(aSortKeyFL,     nDiff);

            lcl_ChgWidth(aFirstKeyLB, -nDiff);
            lcl_ChgWidth(aSecondKeyLB, -nDiff);
            lcl_ChgWidth(aThirdKeyLB, -nDiff);
            lcl_ChgWidth(aSortKeyFL, -nDiff);
        }
        Link aLink = aLevelLB.GetSelectHdl();
        aLevelLB.SetSelectHdl(Link());
        aLevelLB.Select( aLevelLB.GetEntry( bToxIsIndex ? 1 : 0 ) );
        aLevelLB.SetSelectHdl(aLink);

        // sort token buttons
        aEntryNoPB.SetPosPixel(aButtonPositions[0]);
        aEntryPB.SetPosPixel(aButtonPositions[ bToxIsContent ? 1 : 0]);
        aChapterInfoPB.SetPosPixel(aButtonPositions[2]);
        aPageNoPB.SetPosPixel(aButtonPositions[3]);
        sal_uInt16 nBtPos = 1;
        if( bToxIsContent )
            nBtPos = 2;
        else if( bToxIsAuthorities )
            nBtPos = 4;
        aTabPB.SetPosPixel(aButtonPositions[nBtPos]);
        aHyperLinkPB.SetPosPixel(aButtonPositions[4]);

        //show or hide controls
        aEntryNoPB.Show(        bToxIsContent );
        aHyperLinkPB.Show(      bToxIsContent );
        aRelToStyleCB.Show(    !bToxIsAuthorities );
        aChapterInfoPB.Show(    !bToxIsContent && !bToxIsAuthorities);
        aEntryPB.Show(         !bToxIsAuthorities );
        aPageNoPB.Show(        !bToxIsAuthorities );
        aAuthFieldsLB.Show(     bToxIsAuthorities );
        aAuthInsertPB.Show(     bToxIsAuthorities );
        aAuthRemovePB.Show(     bToxIsAuthorities );
        aFormatFL.Show(        !bToxIsAuthorities );
        aSortDocPosRB.Show(     bToxIsAuthorities );
        aSortContentRB.Show(    bToxIsAuthorities );
        aSortingFL.Show(        bToxIsAuthorities );
        aFirstKeyFT.Show(       bToxIsAuthorities );
        aFirstKeyLB.Show(       bToxIsAuthorities );
        aSecondKeyFT.Show(      bToxIsAuthorities );
        aSecondKeyLB.Show(      bToxIsAuthorities );
        aThirdKeyFT.Show(       bToxIsAuthorities );
        aThirdKeyLB.Show(       bToxIsAuthorities );
        aSortKeyFL.Show(        bToxIsAuthorities );
        aFirstSortUpRB.Show(    bToxIsAuthorities );
        aFirstSortDownRB.Show(  bToxIsAuthorities );
        aSecondSortUpRB.Show(   bToxIsAuthorities );
        aSecondSortDownRB.Show( bToxIsAuthorities );
        aThirdSortUpRB.Show(    bToxIsAuthorities );
        aThirdSortDownRB.Show(  bToxIsAuthorities );

        aRelToStyleCB.SetPosPixel( bToxIsIndex ? aRelToStyleIdxPos
                                               : aRelToStylePos );

//      aRecalcTabCB.Show(  aCurType.eType == TOX_CONTENT);

        aMainEntryStyleFT.Show( bToxIsIndex );
        aMainEntryStyleLB.Show( bToxIsIndex );
        aAlphaDelimCB.Show(     bToxIsIndex );
        aCommaSeparatedCB.Show( bToxIsIndex );
    }
    aLastTOXType = aCurType;

    //invalidate PatternWindow
    aTokenWIN.SetInvalid();
    LevelHdl(&aLevelLB);
}
/* -----------------30.11.99 15:04-------------------

 --------------------------------------------------*/
void SwTOXEntryTabPage::UpdateDescriptor()
{
    WriteBackLevel();
    SwMultiTOXTabDialog* pTOXDlg = (SwMultiTOXTabDialog*)GetTabDialog();
    SwTOXDescription& rDesc = pTOXDlg->GetTOXDescription(aLastTOXType);
    if(TOX_INDEX == aLastTOXType.eType)
    {
        String sTemp(aMainEntryStyleLB.GetSelectEntry());
        rDesc.SetMainEntryCharStyle(sNoCharStyle == sTemp ? aEmptyStr : sTemp);
        sal_uInt16 nIdxOptions = rDesc.GetIndexOptions() & ~nsSwTOIOptions::TOI_ALPHA_DELIMITTER;
        if(aAlphaDelimCB.IsChecked())
            nIdxOptions |= nsSwTOIOptions::TOI_ALPHA_DELIMITTER;
        rDesc.SetIndexOptions(nIdxOptions);
    }
    else if(TOX_AUTHORITIES == aLastTOXType.eType)
    {
        rDesc.SetSortByDocument(aSortDocPosRB.IsChecked());
        SwTOXSortKey aKey1, aKey2, aKey3;
        aKey1.eField = (ToxAuthorityField)(sal_uIntPtr)aFirstKeyLB.GetEntryData(
                                    aFirstKeyLB.GetSelectEntryPos());
        aKey1.bSortAscending = aFirstSortUpRB.IsChecked();
        aKey2.eField = (ToxAuthorityField)(sal_uIntPtr)aSecondKeyLB.GetEntryData(
                                    aSecondKeyLB.GetSelectEntryPos());
        aKey2.bSortAscending = aSecondSortUpRB.IsChecked();
        aKey3.eField = (ToxAuthorityField)(sal_uIntPtr)aThirdKeyLB.GetEntryData(
                                aThirdKeyLB.GetSelectEntryPos());
        aKey3.bSortAscending = aThirdSortUpRB.IsChecked();


        rDesc.SetSortKeys(aKey1, aKey2, aKey3);
    }
    SwForm* pCurrentForm = pTOXDlg->GetForm(aLastTOXType);
    if(aRelToStyleCB.IsVisible())
    {
        pCurrentForm->SetRelTabPos(aRelToStyleCB.IsChecked());
    }
    if(aCommaSeparatedCB.IsVisible())
        pCurrentForm->SetCommaSeparated(aCommaSeparatedCB.IsChecked());
}
/*-- 16.06.99 10:47:34---------------------------------------------------

  -----------------------------------------------------------------------*/
int SwTOXEntryTabPage::DeactivatePage( SfxItemSet* /*pSet*/)
{
    UpdateDescriptor();
    return LEAVE_PAGE;
}
/*-- 16.06.99 10:47:34---------------------------------------------------

  -----------------------------------------------------------------------*/
SfxTabPage* SwTOXEntryTabPage::Create( Window* pParent,     const SfxItemSet& rAttrSet)
{
    return new SwTOXEntryTabPage(pParent, rAttrSet);
}
/*-- 16.06.99 10:47:35---------------------------------------------------

  -----------------------------------------------------------------------*/
IMPL_LINK(SwTOXEntryTabPage, EditStyleHdl, PushButton*, pBtn)
{
    if( LISTBOX_ENTRY_NOTFOUND != aCharStyleLB.GetSelectEntryPos())
    {
        SfxStringItem aStyle(SID_STYLE_EDIT, aCharStyleLB.GetSelectEntry());
        SfxUInt16Item aFamily(SID_STYLE_FAMILY, SFX_STYLE_FAMILY_CHAR);
        // TODO: WrtShell?
//      SwPtrItem aShell(FN_PARAM_WRTSHELL, pWrtShell);
        Window* pDefDlgParent = Application::GetDefDialogParent();
        Application::SetDefDialogParent( pBtn );
        ((SwMultiTOXTabDialog*)GetTabDialog())->GetWrtShell().
        GetView().GetViewFrame()->GetDispatcher()->Execute(
        SID_STYLE_EDIT, SFX_CALLMODE_SYNCHRON|SFX_CALLMODE_MODAL,
            &aStyle, &aFamily/*, &aShell*/, 0L);
        Application::SetDefDialogParent( pDefDlgParent );
    }
    return 0;
}
/* -----------------04.10.99 11:34-------------------

 --------------------------------------------------*/
IMPL_LINK(SwTOXEntryTabPage, RemoveInsertAuthHdl, PushButton*, pButton)
{
    sal_Bool bInsert = pButton == &aAuthInsertPB;
    if(bInsert)
    {
        sal_uInt16 nSelPos = aAuthFieldsLB.GetSelectEntryPos();
        String sToInsert(aAuthFieldsLB.GetSelectEntry());
        SwFormToken aInsert(TOKEN_AUTHORITY);
        aInsert.nAuthorityField = (sal_uInt16)(sal_uIntPtr)aAuthFieldsLB.GetEntryData(nSelPos);
        aTokenWIN.InsertAtSelection(String::CreateFromAscii(
                                            SwForm::aFormAuth), aInsert);
        aAuthFieldsLB.RemoveEntry(sToInsert);
        aAuthFieldsLB.SelectEntryPos( nSelPos ? nSelPos - 1 : 0);
    }
    else
    {
        Control* pCtrl = aTokenWIN.GetActiveControl();
        DBG_ASSERT(WINDOW_EDIT != pCtrl->GetType(), "Remove should be disabled");
        if( WINDOW_EDIT != pCtrl->GetType() )
        {
            //fill it into the ListBox
            const SwFormToken& rToken = ((SwTOXButton*)pCtrl)->GetFormToken();
            PreTokenButtonRemoved(rToken);
            aTokenWIN.RemoveControl((SwTOXButton*)pCtrl);
        }
    }
    ModifyHdl(0);
    return 0;
}
/* -----------------------------17.01.00 13:44--------------------------------

 ---------------------------------------------------------------------------*/
void SwTOXEntryTabPage::PreTokenButtonRemoved(const SwFormToken& rToken)
{
    //fill it into the ListBox
    sal_uInt32 nData = rToken.nAuthorityField;
    String sTemp(SW_RES(STR_AUTH_FIELD_START + nData));
    sal_uInt16 nPos = aAuthFieldsLB.InsertEntry(sTemp);
    aAuthFieldsLB.SetEntryData(nPos, (void*)(nData));
}
void SwTOXEntryTabPage::SetFocus2theAllBtn()
{
    aAllLevelsPB.GrabFocus();
}
long SwTOXEntryTabPage::Notify( NotifyEvent& rNEvt )
{
    if ( rNEvt.GetType() == EVENT_KEYINPUT )
    {
        const KeyEvent& rKEvt = *rNEvt.GetKeyEvent();
        KeyCode aCode = rKEvt.GetKeyCode();
        if ( (aCode.GetCode() == KEY_F4) && aCode.IsShift() && !aCode.IsMod1() && !aCode.IsMod2() )
        {
            if ( aTokenWIN.GetActiveControl() )
            {
                aTokenWIN.GetActiveControl()->GrabFocus();
            }
        }

    }

    return SfxTabPage::Notify( rNEvt );
}
/*-- 16.06.99 10:47:35---------------------------------------------------

This function inizializes the default value in the Token
put here the UI dependent initializations
  -----------------------------------------------------------------------*/
IMPL_LINK(SwTOXEntryTabPage, InsertTokenHdl, PushButton*, pBtn)
{
    String sText;
    FormTokenType eTokenType = TOKEN_ENTRY_NO;
    String sCharStyle;
    sal_uInt16  nChapterFormat = CF_NUMBER; // i89791
    if(pBtn == &aEntryNoPB)
    {
        sText.AssignAscii(SwForm::aFormEntryNum);
        eTokenType = TOKEN_ENTRY_NO;
    }
    else if(pBtn == &aEntryPB)
    {
        if( TOX_CONTENT == m_pCurrentForm->GetTOXType() )
        {
            sText.AssignAscii( SwForm::aFormEntryTxt );
            eTokenType = TOKEN_ENTRY_TEXT;
        }
        else
        {
            sText.AssignAscii( SwForm::aFormEntry);
            eTokenType = TOKEN_ENTRY;
        }
    }
    else if(pBtn == &aChapterInfoPB)
    {
        sText.AssignAscii( SwForm::aFormChapterMark);
        eTokenType = TOKEN_CHAPTER_INFO;
        nChapterFormat = CF_NUM_NOPREPST_TITLE; // i89791
    }
    else if(pBtn == &aPageNoPB)
    {
        sText.AssignAscii(SwForm::aFormPageNums);
        eTokenType = TOKEN_PAGE_NUMS;
    }
    else if(pBtn == &aHyperLinkPB)
    {
        sText.AssignAscii(SwForm::aFormLinkStt);
        eTokenType = TOKEN_LINK_START;
        sCharStyle = String(SW_RES(STR_POOLCHR_INET_NORMAL));
    }
    else if(pBtn == &aTabPB)
    {
        sText.AssignAscii(SwForm::aFormTab);
        eTokenType = TOKEN_TAB_STOP;
    }
    SwFormToken aInsert(eTokenType);
    aInsert.sCharStyleName = sCharStyle;
    aInsert.nTabStopPosition = 0;
    aInsert.nChapterFormat = nChapterFormat; // i89791
    aTokenWIN.InsertAtSelection(sText, aInsert);
    ModifyHdl(0);
    return 0;
}
/* -----------------------------14.01.00 11:53--------------------------------

 ---------------------------------------------------------------------------*/
IMPL_LINK(SwTOXEntryTabPage, AllLevelsHdl, PushButton*, EMPTYARG)
{
    //get current level
    //write it into all levels
    if(aTokenWIN.IsValid())
    {
        String sNewToken = aTokenWIN.GetPattern();
        for(sal_uInt16 i = 1; i < m_pCurrentForm->GetFormMax(); i++)
            m_pCurrentForm->SetPattern(i, sNewToken);
        //
        ModifyHdl(this);
    }
    return 0;
}

/* -----------------02.12.99 12:40-------------------

 --------------------------------------------------*/
void SwTOXEntryTabPage::WriteBackLevel()
{
    if(aTokenWIN.IsValid())
    {
        String sNewToken = aTokenWIN.GetPattern();
        sal_uInt16 nLastLevel = aTokenWIN.GetLastLevel();
        if(nLastLevel != USHRT_MAX)
            m_pCurrentForm->SetPattern(nLastLevel + 1, sNewToken );
    }
}
/*-- 16.06.99 10:47:35---------------------------------------------------

  -----------------------------------------------------------------------*/
IMPL_LINK(SwTOXEntryTabPage, LevelHdl, SvTreeListBox*, pBox)
{
    if(bInLevelHdl)
        return 0;
    bInLevelHdl = sal_True;
    WriteBackLevel();

    sal_uInt16 nLevel = static_cast< sal_uInt16 >(pBox->GetModel()->GetAbsPos(pBox->FirstSelected()));
    aTokenWIN.SetForm(*m_pCurrentForm, nLevel);
    if(TOX_AUTHORITIES == m_pCurrentForm->GetTOXType())
    {
        //fill the types in
        aAuthFieldsLB.Clear();
        for( sal_uInt32 i = 0; i < AUTH_FIELD_END; i++)
        {
            String sTmp(SW_RES(STR_AUTH_FIELD_START + i));
            sal_uInt16 nPos = aAuthFieldsLB.InsertEntry(sTmp);
            aAuthFieldsLB.SetEntryData(nPos, (void*)(i));
        }

        // #i21237#
        SwFormTokens aPattern = m_pCurrentForm->GetPattern(nLevel + 1);
        SwFormTokens::iterator aIt = aPattern.begin();

        while(aIt != aPattern.end())
        {
            SwFormToken aToken = *aIt; // #i21237#
            if(TOKEN_AUTHORITY == aToken.eTokenType)
            {
                sal_uInt32 nSearch = aToken.nAuthorityField;
                sal_uInt16  nLstBoxPos = aAuthFieldsLB.GetEntryPos( (void*) nSearch );
                DBG_ASSERT(LISTBOX_ENTRY_NOTFOUND != nLstBoxPos, "Entry not found?");
                aAuthFieldsLB.RemoveEntry(nLstBoxPos);
            }

            aIt++; // #i21237#
        }
        aAuthFieldsLB.SelectEntryPos(0);
    }
    bInLevelHdl = sal_False;
    pBox->GrabFocus();
    return 0;
}
/* -----------------20.10.99 13:16-------------------

 --------------------------------------------------*/
IMPL_LINK(SwTOXEntryTabPage, SortKeyHdl, RadioButton*, pButton)
{
    sal_Bool bEnable = &aSortContentRB == pButton;
    aFirstKeyFT.Enable(bEnable);
    aFirstKeyLB.Enable(bEnable);
    aSecondKeyFT.Enable(bEnable);
    aSecondKeyLB.Enable(bEnable);
    aThirdKeyFT.Enable(bEnable);
    aThirdKeyLB.Enable(bEnable);
    aSortKeyFL.Enable(bEnable);
    aFirstSortUpRB.Enable(bEnable);
    aFirstSortDownRB.Enable(bEnable);
    aSecondSortUpRB.Enable(bEnable);
    aSecondSortDownRB.Enable(bEnable);
    aThirdSortUpRB.Enable(bEnable);
    aThirdSortDownRB.Enable(bEnable);
    return 0;
}
/* -----------------01.07.99 12:21-------------------

 --------------------------------------------------*/
IMPL_LINK(SwTOXEntryTabPage, TokenSelectedHdl, SwFormToken*, pToken)
{
    if(pToken->sCharStyleName.Len())
        aCharStyleLB.SelectEntry(pToken->sCharStyleName);
    else
        aCharStyleLB.SelectEntry(sNoCharStyle);
    //StyleSelectHdl(&aCharStyleLB);

    String sEntry = aCharStyleLB.GetSelectEntry();
    aEditStylePB.Enable(sEntry != sNoCharStyle);

    if(pToken->eTokenType == TOKEN_CHAPTER_INFO)
    {
//---> i89791
        switch(pToken->nChapterFormat)
        {
        default:
            aChapterEntryLB.SetNoSelection();//to alert the user
            break;
        case CF_NUM_NOPREPST_TITLE:
            aChapterEntryLB.SelectEntryPos(0);
            break;
        case CF_TITLE:
            aChapterEntryLB.SelectEntryPos(1);
           break;
        case CF_NUMBER_NOPREPST:
            aChapterEntryLB.SelectEntryPos(2);
            break;
        }
//<---
//i53420
//move into position the fixed text
//         aEntryOutlineLevelFT.SetPosPixel( aEntryOutlineLevelFTPosition );
// // then the entry
//         Point aPoint;
//         aPoint.Y() = aEntryOutlineLevelFTPosition.Y();
//         aPoint.X() = aEntryOutlineLevelFTPosition.X() + nBiasToEntryPoint;
//         aEntryOutlineLevelNF.SetPosPixel( aPoint );

        aEntryOutlineLevelNF.SetValue(pToken->nOutlineLevel);
    }

//i53420
    if(pToken->eTokenType == TOKEN_ENTRY_NO)
    {
//move into position the fixed text
//        aEntryOutlineLevelFT.SetPosPixel( aChapterEntryFTPosition );
// // then the entry
//         Point aPoint;
//         aPoint.Y() = aChapterEntryFTPosition.Y();
//         aPoint.X() = aChapterEntryFTPosition.X() + nBiasToEntryPoint;
//         aEntryOutlineLevelNF.SetPosPixel( aPoint );

        aEntryOutlineLevelNF.SetValue(pToken->nOutlineLevel);
        sal_uInt16 nFormat = 0;
        if( pToken->nChapterFormat == CF_NUM_NOPREPST_TITLE )
            nFormat = 1;
        aNumberFormatLB.SelectEntryPos(nFormat);
    }

    sal_Bool bTabStop = TOKEN_TAB_STOP == pToken->eTokenType;
    aFillCharFT.Show(bTabStop);
    aFillCharCB.Show(bTabStop);
    aTabPosFT.Show(bTabStop);
    aTabPosMF.Show(bTabStop);
    aAutoRightCB.Show(bTabStop);
    aAutoRightCB.Enable(bTabStop);
    if(bTabStop)
    {
        aTabPosMF.SetValue(aTabPosMF.Normalize(pToken->nTabStopPosition), FUNIT_TWIP);
        aAutoRightCB.Check(SVX_TAB_ADJUST_END == pToken->eTabAlign);
        aFillCharCB.SetText(pToken->cTabFillChar);
        aTabPosFT.Enable(!aAutoRightCB.IsChecked());
        aTabPosMF.Enable(!aAutoRightCB.IsChecked());
    }
    else
    {
        aTabPosMF.Enable(sal_False);
    }

    sal_Bool bIsChapterInfo = pToken->eTokenType == TOKEN_CHAPTER_INFO;
    sal_Bool bIsEntryNumber = pToken->eTokenType == TOKEN_ENTRY_NO;
    aChapterEntryFT.Show( bIsChapterInfo );
    aChapterEntryLB.Show( bIsChapterInfo );
    aEntryOutlineLevelFT.Show( bIsChapterInfo || bIsEntryNumber );
    aEntryOutlineLevelNF.Show( bIsChapterInfo || bIsEntryNumber );
    aNumberFormatFT.Show( bIsEntryNumber );
    aNumberFormatLB.Show( bIsEntryNumber );


    //now enable the visible buttons
    //- inserting the same type of control is not allowed
    //- some types of controls can only appear once (EntryText EntryNumber)

    if(aEntryNoPB.IsVisible())
    {
        aEntryNoPB.Enable(TOKEN_ENTRY_NO != pToken->eTokenType );
    }
    if(aEntryPB.IsVisible())
    {
        aEntryPB.Enable(TOKEN_ENTRY_TEXT != pToken->eTokenType &&
                                !aTokenWIN.Contains(TOKEN_ENTRY_TEXT)
                                && !aTokenWIN.Contains(TOKEN_ENTRY));
    }

    if(aChapterInfoPB.IsVisible())
    {
        aChapterInfoPB.Enable(TOKEN_CHAPTER_INFO != pToken->eTokenType);
    }
    if(aPageNoPB.IsVisible())
    {
        aPageNoPB.Enable(TOKEN_PAGE_NUMS != pToken->eTokenType &&
                                !aTokenWIN.Contains(TOKEN_PAGE_NUMS));
    }
    if(aTabPB.IsVisible())
    {
        aTabPB.Enable(!bTabStop);
    }
    if(aHyperLinkPB.IsVisible())
    {
        aHyperLinkPB.Enable(TOKEN_LINK_START != pToken->eTokenType &&
                            TOKEN_LINK_END != pToken->eTokenType);
    }
    //table of authorities
    if(aAuthInsertPB.IsVisible())
    {
        sal_Bool bText = TOKEN_TEXT == pToken->eTokenType;
        aAuthInsertPB.Enable(bText && aAuthFieldsLB.GetSelectEntry().Len());
        aAuthRemovePB.Enable(!bText);
    }

    return 0;
}
/* -----------------01.07.99 12:36-------------------

 --------------------------------------------------*/
IMPL_LINK(SwTOXEntryTabPage, StyleSelectHdl, ListBox*, pBox)
{
    String sEntry = pBox->GetSelectEntry();
    sal_uInt16 nId = (sal_uInt16)(long)pBox->GetEntryData(pBox->GetSelectEntryPos());
    aEditStylePB.Enable(sEntry != sNoCharStyle);
    if(sEntry == sNoCharStyle)
        sEntry.Erase();
    Control* pCtrl = aTokenWIN.GetActiveControl();
    DBG_ASSERT(pCtrl, "no active control?");
    if(pCtrl)
    {
        if(WINDOW_EDIT == pCtrl->GetType())
            ((SwTOXEdit*)pCtrl)->SetCharStyleName(sEntry, nId);
        else
            ((SwTOXButton*)pCtrl)->SetCharStyleName(sEntry, nId);

    }
    ModifyHdl(0);
    return 0;
}
/* -----------------------------11.01.00 12:54--------------------------------

 ---------------------------------------------------------------------------*/
IMPL_LINK(SwTOXEntryTabPage, ChapterInfoHdl, ListBox*, pBox)
{
    sal_uInt16 nPos = pBox->GetSelectEntryPos();
    if(LISTBOX_ENTRY_NOTFOUND != nPos)
    {
        Control* pCtrl = aTokenWIN.GetActiveControl();
        DBG_ASSERT(pCtrl, "no active control?");
        if(pCtrl && WINDOW_EDIT != pCtrl->GetType())
            ((SwTOXButton*)pCtrl)->SetChapterInfo(nPos);

        ModifyHdl(0);
    }
    return 0;
}

IMPL_LINK(SwTOXEntryTabPage, ChapterInfoOutlineHdl, NumericField*, pField)
{
    const sal_uInt16 nLevel = static_cast<sal_uInt8>(pField->GetValue());

    Control* pCtrl = aTokenWIN.GetActiveControl();
    DBG_ASSERT(pCtrl, "no active control?");
    if(pCtrl && WINDOW_EDIT != pCtrl->GetType())
        ((SwTOXButton*)pCtrl)->SetOutlineLevel(nLevel);

    ModifyHdl(0);
    return 0;
}

IMPL_LINK(SwTOXEntryTabPage, NumberFormatHdl, ListBox*, pBox)
{
    const sal_uInt16 nPos = pBox->GetSelectEntryPos();

    if(LISTBOX_ENTRY_NOTFOUND != nPos)
    {
        Control* pCtrl = aTokenWIN.GetActiveControl();
        DBG_ASSERT(pCtrl, "no active control?");
        if(pCtrl && WINDOW_EDIT != pCtrl->GetType())
        {
           ((SwTOXButton*)pCtrl)->SetEntryNumberFormat(nPos);//i89791
        }
        ModifyHdl(0);
    }
    return 0;
}

/* -----------------19.08.99 15:37-------------------

 --------------------------------------------------*/
IMPL_LINK(SwTOXEntryTabPage, TabPosHdl, MetricField*, pField)
{
    Control* pCtrl = aTokenWIN.GetActiveControl();
    DBG_ASSERT(pCtrl && WINDOW_EDIT != pCtrl->GetType() &&
        TOKEN_TAB_STOP == ((SwTOXButton*)pCtrl)->GetFormToken().eTokenType,
                "no active style::TabStop control?");
    if( pCtrl && WINDOW_EDIT != pCtrl->GetType() )
    {
        ((SwTOXButton*)pCtrl)->SetTabPosition( static_cast< SwTwips >(
                pField->Denormalize( pField->GetValue( FUNIT_TWIP ))));
    }
    ModifyHdl(0);
    return 0;
}
/* -----------------09.09.99 15:37-------------------

 --------------------------------------------------*/
IMPL_LINK(SwTOXEntryTabPage, FillCharHdl, ComboBox*, pBox)
{
    Control* pCtrl = aTokenWIN.GetActiveControl();
    DBG_ASSERT(pCtrl && WINDOW_EDIT != pCtrl->GetType() &&
        TOKEN_TAB_STOP == ((SwTOXButton*)pCtrl)->GetFormToken().eTokenType,
                "no active style::TabStop control?");
    if(pCtrl && WINDOW_EDIT != pCtrl->GetType())
    {
        sal_Unicode cSet;
        if( pBox->GetText().Len() )
            cSet = pBox->GetText().GetChar(0);
        else
            cSet = ' ';
        ((SwTOXButton*)pCtrl)->SetFillChar( cSet );
    }
    ModifyHdl(0);
    return 0;
}

/*-- 16.06.99 10:47:36---------------------------------------------------

  -----------------------------------------------------------------------*/
IMPL_LINK(SwTOXEntryTabPage, AutoRightHdl, CheckBox*, pBox)
{
    //the most right style::TabStop is usually right aligned
    Control* pCurCtrl = aTokenWIN.GetActiveControl();
    DBG_ASSERT(WINDOW_EDIT != pCurCtrl->GetType() &&
            ((SwTOXButton*)pCurCtrl)->GetFormToken().eTokenType == TOKEN_TAB_STOP,
            "no style::TabStop selected!");

    const SwFormToken& rToken = ((SwTOXButton*)pCurCtrl)->GetFormToken();
    sal_Bool bChecked = pBox->IsChecked();
    if(rToken.eTokenType == TOKEN_TAB_STOP)
        ((SwTOXButton*)pCurCtrl)->SetTabAlign(
            bChecked ? SVX_TAB_ADJUST_END : SVX_TAB_ADJUST_LEFT);
    aTabPosFT.Enable(!bChecked);
    aTabPosMF.Enable(!bChecked);
    ModifyHdl(0);
    return 0;
}
/* -----------------16.06.99 11:00-------------------

 --------------------------------------------------*/
void SwTOXEntryTabPage::SetWrtShell(SwWrtShell& rSh)
{
    SwDocShell* pDocSh = rSh.GetView().GetDocShell();
    ::FillCharStyleListBox(aCharStyleLB, pDocSh, sal_True, sal_True);
    const String sDefault(SW_RES(STR_POOLCOLL_STANDARD));
    for(sal_uInt16 i = 0; i < aCharStyleLB.GetEntryCount(); i++)
    {
        String sEntry = aCharStyleLB.GetEntry(i);
        if(sDefault != sEntry)
        {
            aMainEntryStyleLB.InsertEntry( sEntry );
            aMainEntryStyleLB.SetEntryData(i, aCharStyleLB.GetEntryData(i));
        }
    }
    aMainEntryStyleLB.SelectEntry( SwStyleNameMapper::GetUIName(
                                RES_POOLCHR_IDX_MAIN_ENTRY, aEmptyStr ));
}
/* -----------------------------23.12.99 14:23--------------------------------

 ---------------------------------------------------------------------------*/
String  SwTOXEntryTabPage::GetLevelHelp(sal_uInt16 nLevel) const
{
    String sRet;
    SwMultiTOXTabDialog* pTOXDlg = (SwMultiTOXTabDialog*)GetTabDialog();
    const CurTOXType aCurType = pTOXDlg->GetCurrentTOXType();
    if( TOX_INDEX == aCurType.eType )
        SwStyleNameMapper::FillUIName( static_cast< sal_uInt16 >(1 == nLevel ? RES_POOLCOLL_TOX_IDXBREAK
                                  : RES_POOLCOLL_TOX_IDX1 + nLevel-2), sRet );

    else if( TOX_AUTHORITIES == aCurType.eType )
    {
        //wildcard -> show entry text
        sRet = '*';
    }
    return sRet;
}
/* -----------------16.06.99 15:18-------------------

 --------------------------------------------------*/

SwTokenWindow::SwTokenWindow(SwTOXEntryTabPage* pParent, const ResId& rResId) :
        Window( pParent, rResId ),
        aLeftScrollWin(this, ResId(WIN_LEFT_SCROLL, *rResId.GetResMgr()  )),
        aCtrlParentWin(this, ResId(WIN_CTRL_PARENT, *rResId.GetResMgr()   )),
        aRightScrollWin(this, ResId(WIN_RIGHT_SCROLL, *rResId.GetResMgr() )),
        pForm(0),
        nLevel(0),
        bValid(sal_False),
        sCharStyle(ResId(STR_CHARSTYLE, *rResId.GetResMgr())),
        pActiveCtrl(0),
        m_pParent(pParent)
{
    SetStyle(GetStyle()|WB_TABSTOP|WB_DIALOGCONTROL);
    SetHelpId(HID_TOKEN_WINDOW);
    for(sal_uInt16 i = 0; i < TOKEN_END; i++)
    {
        sal_uInt16 nTextId = STR_BUTTON_TEXT_START + i;
        if( STR_TOKEN_ENTRY_TEXT == nTextId )
            nTextId = STR_TOKEN_ENTRY;
        aButtonTexts[i] = String(ResId(nTextId, *rResId.GetResMgr()));

        sal_uInt16 nHelpId = STR_BUTTON_HELP_TEXT_START + i;
        if(STR_TOKEN_HELP_ENTRY_TEXT == nHelpId)
            nHelpId = STR_TOKEN_HELP_ENTRY;
        aButtonHelpTexts[i] = String(ResId(nHelpId, *rResId.GetResMgr()));
    }
    accessibleName = String(SW_RES(STR_STRUCTURE));
    sAdditionalAccnameString1 = String(SW_RES(STR_ADDITIONAL_ACCNAME_STRING1));
    sAdditionalAccnameString2 = String(SW_RES(STR_ADDITIONAL_ACCNAME_STRING2));
    sAdditionalAccnameString3 = String(SW_RES(STR_ADDITIONAL_ACCNAME_STRING3));
    FreeResource();

    Link aLink(LINK(this, SwTokenWindow, ScrollHdl));
    aLeftScrollWin.SetClickHdl(aLink);
    aRightScrollWin.SetClickHdl(aLink);
}
/* -----------------01.07.99 12:17-------------------

 --------------------------------------------------*/
SwTokenWindow::~SwTokenWindow()
{
//  for(sal_uInt16 i = GetItemCount(); i ; i--)
//      RemoveItem(i - 1);

    for( sal_uInt32 n = 0; n < aControlList.Count(); ++n )
    {
        Control* pControl = aControlList.GetObject( n );
        pControl->SetGetFocusHdl( Link() );
        pControl->SetLoseFocusHdl( Link() );
    }

    for( sal_uLong i = aControlList.Count(); i; )
    {
        Control* pControl = aControlList.Remove( --i );
        delete pControl;
    }
}
/* -----------------16.06.99 13:56-------------------

 --------------------------------------------------*/
void    SwTokenWindow::SetForm(SwForm& rForm, sal_uInt16 nL)
{
    SetActiveControl(0);
    bValid = sal_True;
    if(pForm)
    {
        //apply current level settings to the form
        for( sal_uLong i = aControlList.Count(); i; )
        {
            Control* pControl = aControlList.Remove( --i );
            delete pControl;
        }
    }
    nLevel = nL;
    pForm = &rForm;
    //now the display
    if(nLevel < MAXLEVEL || rForm.GetTOXType() == TOX_AUTHORITIES)
    {
        Size aToolBoxSize = GetSizePixel();

        // #i21237#
        SwFormTokens aPattern = pForm->GetPattern(nLevel + 1);
        SwFormTokens::iterator aIt = aPattern.begin();
        sal_Bool bLastWasText = sal_False; //assure alternating text - code - text

        Control* pSetActiveControl = 0;
        while(aIt != aPattern.end()) // #i21237#
        {
            SwFormToken aToken(*aIt); // #i21237#

            if(TOKEN_TEXT == aToken.eTokenType)
            {
                DBG_ASSERT(!bLastWasText, "text following text is invalid");
                Control* pCtrl = InsertItem(aToken.sText, aToken);
                bLastWasText = sal_True;
                if(!GetActiveControl())
                    SetActiveControl(pCtrl);
            }
            else
            {
                if( !bLastWasText )
                {
                    bLastWasText = sal_True;
                    SwFormToken aTemp(TOKEN_TEXT);
                    Control* pCtrl = InsertItem(aEmptyStr, aTemp);
                    if(!pSetActiveControl)
                        pSetActiveControl = pCtrl;
                }
                const sal_Char* pTmp = 0;
                switch( aToken.eTokenType )
                {
                case TOKEN_ENTRY_NO:    pTmp = SwForm::aFormEntryNum; break;
                case TOKEN_ENTRY_TEXT:  pTmp = SwForm::aFormEntryTxt; break;
                case TOKEN_ENTRY:       pTmp = SwForm::aFormEntry; break;
                case TOKEN_TAB_STOP:    pTmp = SwForm::aFormTab; break;
                case TOKEN_PAGE_NUMS:   pTmp = SwForm::aFormPageNums; break;
                case TOKEN_CHAPTER_INFO:pTmp = SwForm::aFormChapterMark; break;
                case TOKEN_LINK_START:  pTmp = SwForm::aFormLinkStt; break;
                case TOKEN_LINK_END:    pTmp = SwForm::aFormLinkEnd; break;
                case TOKEN_AUTHORITY:   pTmp = SwForm::aFormAuth; break;
                default:; //prevent warning
                }

                InsertItem( pTmp ? String::CreateFromAscii(pTmp)
                                 : aEmptyStr, aToken );
                bLastWasText = sal_False;
            }

            aIt++; // #i21237#
        }
        if(!bLastWasText)
        {
            bLastWasText = sal_True;
            SwFormToken aTemp(TOKEN_TEXT);
            Control* pCtrl = InsertItem(aEmptyStr, aTemp);
            if(!pSetActiveControl)
                pSetActiveControl = pCtrl;
        }
        SetActiveControl(pSetActiveControl);
    }
    AdjustScrolling();
}
/* -----------------19.08.99 13:00-------------------

 --------------------------------------------------*/
void SwTokenWindow::SetActiveControl(Control* pSet)
{
    if( pSet != pActiveCtrl )
    {
        pActiveCtrl = pSet;
        if( pActiveCtrl )
        {
            pActiveCtrl->GrabFocus();
            //it must be a SwTOXEdit
            const SwFormToken* pFToken;
            if( WINDOW_EDIT == pActiveCtrl->GetType() )
                pFToken = &((SwTOXEdit*)pActiveCtrl)->GetFormToken();
            else
                pFToken = &((SwTOXButton*)pActiveCtrl)->GetFormToken();

            SwFormToken aTemp( *pFToken );
            aButtonSelectedHdl.Call( &aTemp );
        }
    }
}

/* -----------------17.06.99 09:53-------------------

 --------------------------------------------------*/
Control*    SwTokenWindow::InsertItem(const String& rText, const SwFormToken& rToken)
{
    Control* pRet = 0;
    Control* pLast = aControlList.Last();
    Size aControlSize(GetOutputSizePixel());
    Point aControlPos;
    if( pLast )
    {
        aControlSize = pLast->GetSizePixel();
        aControlPos = pLast->GetPosPixel();
        aControlPos.X() += aControlSize.Width();
    }
    if(TOKEN_TEXT == rToken.eTokenType)
    {
        SwTOXEdit* pEdit = new SwTOXEdit(&aCtrlParentWin, this, rToken);
        pEdit->SetPosPixel(aControlPos);
        aControlList.Insert(pEdit, aControlList.Count());
        pEdit->SetText(rText);
        sal_uInt32 nIndex = GetControlIndex( TOKEN_TEXT, pEdit );
        String s1 = String::CreateFromAscii(" (");
        String s2 = String::CreateFromAscii(")");
        String s3 = String::CreateFromAscii(", ");
        String strName(accessibleName);
        strName += String::CreateFromInt32(nIndex);
        if ( nIndex == 1 )
        {
            /*Press left or right arrow to choose the structure controls*/
            strName += s1;
            strName += sAdditionalAccnameString2;
            strName += s3;
            /*Press Ctrl+Alt+A to move focus for more operations*/
            strName += sAdditionalAccnameString1;
            strName += s3;
            /*Press Ctrl+Alt+B to move focus back to the current structure control*/
            strName += sAdditionalAccnameString3;
            strName += s2;
            pEdit->SetAccessibleName(strName);
        }
        else
        {
            pEdit->SetAccessibleName(strName);
        }
        Size aEditSize(aControlSize);
        aEditSize.Width() = pEdit->GetTextWidth(rText) + EDIT_MINWIDTH;
        pEdit->SetSizePixel(aEditSize);
        pEdit->SetModifyHdl(LINK(this, SwTokenWindow, EditResize ));
        pEdit->SetPrevNextLink(LINK(this, SwTokenWindow, NextItemHdl));
        pEdit->SetGetFocusHdl(LINK(this, SwTokenWindow, TbxFocusHdl));
        pEdit->Show();
        pRet = pEdit;
    }
    else
    {
        SwTOXButton* pButton = new SwTOXButton(&aCtrlParentWin, this, rToken);
        pButton->SetPosPixel(aControlPos);
        aControlList.Insert(pButton, aControlList.Count());
        Size aEditSize(aControlSize);
        aEditSize.Width() = pButton->GetTextWidth(rText) + 5;
//        pButton->SetControlBackground(aCtrlColor);
//        pButton->SetControlForeground(aTextColor);
        pButton->SetSizePixel(aEditSize);
        pButton->SetPrevNextLink(LINK(this, SwTokenWindow, NextItemBtnHdl));
        pButton->SetGetFocusHdl(LINK(this, SwTokenWindow, TbxFocusBtnHdl));
        if(TOKEN_AUTHORITY != rToken.eTokenType)
            pButton->SetText(aButtonTexts[rToken.eTokenType]);
        else
        {
            //use the first two chars as symbol
            String sTmp(SwAuthorityFieldType::GetAuthFieldName(
                        (ToxAuthorityField)rToken.nAuthorityField));
            pButton->SetText(sTmp.Copy(0, 2));
        }
        String sSpace = String::CreateFromAscii(" ");
        sal_uInt32 nIndex = GetControlIndex( rToken.eTokenType, pButton );
        String sAccName = aButtonHelpTexts[rToken.eTokenType];
        if ( nIndex )
        {
            sAccName += sSpace;
            sAccName += String::CreateFromInt32(nIndex);
        }
        pButton->SetAccessibleName( sAccName );
        pButton->Show();
        pRet = pButton;
    }
    return pRet;
}
/* -----------------16.07.99 11:50-------------------

 --------------------------------------------------*/
void    SwTokenWindow::InsertAtSelection(
            const String& rText,
            const SwFormToken& rToken)
{
    DBG_ASSERT(pActiveCtrl, "no active control!");
    if(!pActiveCtrl)
        return;
    SwFormToken aToInsertToken(rToken);
    if(TOKEN_LINK_START == aToInsertToken.eTokenType)
    {
        //determine if start or end of hyperlink is appropriate
        //eventually change a following link start into a link end
        // groups of LS LE should be ignored
        // <insert>
        //LS <insert>
        //LE <insert>
        //<insert> LS
        //<insert> LE
        //<insert>
        sal_Bool bPreStartLinkFound = sal_False; //
        sal_Bool bPreEndLinkFound = sal_False;

        const Control* pControl = aControlList.First();
        const Control* pExchange = 0;
        while( pControl && pActiveCtrl != pControl )
        {
            if( WINDOW_EDIT != pControl->GetType())
            {
                const SwFormToken& rNewToken =
                                ((SwTOXButton*)pControl)->GetFormToken();
                if( TOKEN_LINK_START == rNewToken.eTokenType )
                {
                    bPreStartLinkFound = sal_True;
                    pExchange = 0;
                }
                else if(TOKEN_LINK_END == rNewToken.eTokenType)
                {
                    if( bPreStartLinkFound )
                        bPreStartLinkFound = sal_False;
                    else
                    {
                        bPreEndLinkFound = sal_False;
                        pExchange = pControl;
                    }
                }
            }
            pControl = aControlList.Next();
        }

        sal_Bool bPostLinkEndFound = sal_False;
        sal_Bool bPostLinkStartFound = sal_False;
        if(!bPreStartLinkFound && !bPreEndLinkFound)
            while(pControl)
            {
                if( pControl != pActiveCtrl &&
                    WINDOW_EDIT != pControl->GetType())
                {
                    const SwFormToken& rNewToken =
                                    ((SwTOXButton*)pControl)->GetFormToken();
                    if( TOKEN_LINK_START == rNewToken.eTokenType )
                    {
                        if(bPostLinkStartFound)
                            break;
                        bPostLinkStartFound = sal_True;
                        pExchange = pControl;
                    }
                    else if(TOKEN_LINK_END == rNewToken.eTokenType )
                    {
                        if(bPostLinkStartFound)
                        {
                            bPostLinkStartFound = sal_False;
                            pExchange = 0;
                        }
                        else
                        {
                            bPostLinkEndFound = sal_True;
                        }
                        break;
                    }
                }
                pControl = aControlList.Next();
            }

        if(bPreStartLinkFound)
        {
            aToInsertToken.eTokenType = TOKEN_LINK_END;
            aToInsertToken.sText =  aButtonTexts[TOKEN_LINK_END];
        }

        if(bPostLinkStartFound)
        {
            DBG_ASSERT(pExchange, "no control to exchange?");
            if(pExchange)
            {
                ((SwTOXButton*)pExchange)->SetLinkEnd();
                ((SwTOXButton*)pExchange)->SetText(aButtonTexts[TOKEN_LINK_END]);
            }
        }

        if(bPreEndLinkFound)
        {
            DBG_ASSERT(pExchange, "no control to exchange?");
            if(pExchange)
            {
                ((SwTOXButton*)pExchange)->SetLinkStart();
                ((SwTOXButton*)pExchange)->SetText(aButtonTexts[TOKEN_LINK_START]);
            }
        }
    }

    //if the active control is text then insert a new button at the selection
    //else replace the button
    sal_uInt32 nActivePos = aControlList.GetPos(pActiveCtrl);
    sal_uInt32 nInsertPos = nActivePos;

    Size aControlSize(GetOutputSizePixel());
    if( WINDOW_EDIT == pActiveCtrl->GetType())
    {
        nInsertPos++;
        Selection aSel = ((SwTOXEdit*)pActiveCtrl)->GetSelection();
        aSel.Justify();
        String sEditText = ((SwTOXEdit*)pActiveCtrl)->GetText();
        String sLeft = sEditText.Copy( 0, static_cast< sal_uInt16 >(aSel.A()) );
        String sRight = sEditText.Copy( static_cast< sal_uInt16 >(aSel.B()),
                                        static_cast< sal_uInt16 >(sEditText.Len() - aSel.B()));

        ((SwTOXEdit*)pActiveCtrl)->SetText(sLeft);
        ((SwTOXEdit*)pActiveCtrl)->AdjustSize();

        SwFormToken aTmpToken(TOKEN_TEXT);
        SwTOXEdit* pEdit = new SwTOXEdit(&aCtrlParentWin, this, aTmpToken);
        aControlList.Insert(pEdit, nActivePos + 1);
        pEdit->SetText(sRight);
        sal_uInt32 nIndex = GetControlIndex( TOKEN_TEXT, pEdit );
        String s1 = String::CreateFromAscii(" (");
        String s2 = String::CreateFromAscii(")");
        String s3 = String::CreateFromAscii(", ");
        String strName(accessibleName);
        strName += String::CreateFromInt32(nIndex);
        if ( nIndex == 1)
        {
            /*Press left or right arrow to choose the structure controls*/
            strName += s1;
            strName += sAdditionalAccnameString2;
            strName += s3;
            /*Press Ctrl+Alt+A to move focus for more operations*/
            strName += sAdditionalAccnameString1;
            strName += s3;
            /*Press Ctrl+Alt+B to move focus back to the current structure control*/
            strName += sAdditionalAccnameString3;
            strName += s2;
            pEdit->SetAccessibleName(strName);
        }
        else
        {
            pEdit->SetAccessibleName(strName);
        }
        pEdit->SetSizePixel(aControlSize);
        pEdit->AdjustSize();
        pEdit->SetModifyHdl(LINK(this, SwTokenWindow, EditResize ));
        pEdit->SetPrevNextLink(LINK(this, SwTokenWindow, NextItemHdl));
        pEdit->SetGetFocusHdl(LINK(this, SwTokenWindow, TbxFocusHdl));
        pEdit->Show();
    }
    else
    {
        aControlList.Remove(pActiveCtrl);
        pActiveCtrl->Hide();
        delete pActiveCtrl;
    }

    //now the new button
    SwTOXButton* pButton = new SwTOXButton(&aCtrlParentWin, this, aToInsertToken);
    aControlList.Insert(pButton, nInsertPos);
    pButton->SetPrevNextLink(LINK(this, SwTokenWindow, NextItemBtnHdl));
    pButton->SetGetFocusHdl(LINK(this, SwTokenWindow, TbxFocusBtnHdl));
    if(TOKEN_AUTHORITY != aToInsertToken.eTokenType)
        pButton->SetText(aButtonTexts[aToInsertToken.eTokenType]);
    else
    {
        //use the first two chars as symbol
        String sTmp(SwAuthorityFieldType::GetAuthFieldName(
                    (ToxAuthorityField)aToInsertToken.nAuthorityField));
        pButton->SetText(sTmp.Copy(0, 2));
    }

    String sSpace = String::CreateFromAscii(" ");
    sal_uInt32 nIndex = GetControlIndex( rToken.eTokenType, pButton );
    String sAccName = aButtonHelpTexts[rToken.eTokenType];
    if ( nIndex )
    {
        sAccName += sSpace;
        sAccName += String::CreateFromInt32(nIndex);
    }
    pButton->SetAccessibleName( sAccName );
 Size aEditSize(GetOutputSizePixel());
    aEditSize.Width() = pButton->GetTextWidth(rText) + 5;
    pButton->SetSizePixel(aEditSize);
    pButton->Check(sal_True);
    pButton->Show();
    SetActiveControl(pButton);

    AdjustPositions();
}
/* -----------------19.08.99 12:42-------------------

 --------------------------------------------------*/
void SwTokenWindow::RemoveControl(SwTOXButton* pDel, sal_Bool bInternalCall )
{
    if(bInternalCall && TOX_AUTHORITIES == pForm->GetTOXType())
        m_pParent->PreTokenButtonRemoved(pDel->GetFormToken());

    sal_uInt32 nActivePos = aControlList.GetPos(pDel);
    DBG_ASSERT(nActivePos != 0xffffffff, "Control does not exist!");
    // the two neighbours of the box must be merged
    // the properties of the right one will be lost
    DBG_ASSERT(nActivePos && nActivePos < aControlList.Count() - 1,
        "Button at first or last position?");
    aControlList.Seek(nActivePos - 1);
    Control* pLeftEdit = aControlList.GetCurObject();
    aControlList.Seek(nActivePos + 1);
    Control* pRightEdit = aControlList.GetCurObject();
    String sTemp(((SwTOXEdit*)pLeftEdit)->GetText());
    sTemp += ((SwTOXEdit*)pRightEdit)->GetText();
    ((SwTOXEdit*)pLeftEdit)->SetText(sTemp);
    ((SwTOXEdit*)pLeftEdit)->AdjustSize();

    aControlList.Remove(pRightEdit);
    delete pRightEdit;

    aControlList.Remove(pDel);
    pActiveCtrl->Hide();
    delete pActiveCtrl;
    SetActiveControl(pLeftEdit);
    AdjustPositions();
    if(aModifyHdl.IsSet())
        aModifyHdl.Call(0);
}

/* -----------------16.07.99 12:39-------------------

 --------------------------------------------------*/
void SwTokenWindow::AdjustPositions()
{
    if(aControlList.Count() > 1)
    {
        Control* pCtrl = aControlList.First();
     Point aNextPos = pCtrl->GetPosPixel();
        aNextPos.X() += pCtrl->GetSizePixel().Width();
        while(0 != (pCtrl = aControlList.Next()))
        {
            pCtrl->SetPosPixel(aNextPos);
            aNextPos.X() += pCtrl->GetSizePixel().Width();
        }
        AdjustScrolling();
    }
};
/* -----------------------------16.08.00 13:22--------------------------------

 ---------------------------------------------------------------------------*/
void SwTokenWindow::MoveControls(long nOffset)
{
    // move the complete list
    Control* pCtrl = aControlList.First();
    do
    {
        Point aPos = pCtrl->GetPosPixel();
        aPos.X() += nOffset;
        pCtrl->SetPosPixel(aPos);
    }while(0 != (pCtrl = aControlList.Next()));
}
/* -----------------------------14.01.00 13:03--------------------------------

 ---------------------------------------------------------------------------*/
void SwTokenWindow::AdjustScrolling()
{
    if(aControlList.Count() > 1)
    {
        //validate scroll buttons
        Control* pLastCtrl = aControlList.Last();
        Control* pFirstCtrl = aControlList.First();
        long nSpace = aCtrlParentWin.GetSizePixel().Width();
        long nWidth = pLastCtrl->GetPosPixel().X() - pFirstCtrl->GetPosPixel().X()
                                                    + pLastCtrl->GetSizePixel().Width();
        sal_Bool bEnable = nWidth > nSpace;
        //the active control must be visible
        if(bEnable && pActiveCtrl)
        {
            Point aActivePos(pActiveCtrl->GetPosPixel());
            long nMove = 0;
            if(aActivePos.X() < 0)
                nMove = -aActivePos.X();
            else if((aActivePos.X() + pActiveCtrl->GetSizePixel().Width())  > nSpace)
                nMove = -(aActivePos.X() + pActiveCtrl->GetSizePixel().Width() - nSpace);
            if(nMove)
                MoveControls(nMove);
            aLeftScrollWin.Enable(aControlList.First()->GetPosPixel().X() < 0);
            Control* pCtrl = aControlList.Last();
            aRightScrollWin.Enable((pCtrl->GetPosPixel().X() + pCtrl->GetSizePixel().Width()) > nSpace);
        }
        else
        {
            if(pFirstCtrl)
            {
                //if the control fits into the space then the first control must be at position 0
                long nFirstPos = pFirstCtrl->GetPosPixel().X();
                if(nFirstPos != 0)
                    MoveControls(-nFirstPos);
            }
            aRightScrollWin.Enable(sal_False);
            aLeftScrollWin.Enable(sal_False);
        }
    }
}
/* -----------------------------14.01.00 13:57--------------------------------

 ---------------------------------------------------------------------------*/
IMPL_LINK(SwTokenWindow, ScrollHdl, ImageButton*, pBtn )
{
    if(aControlList.Count())
    {
        const long nSpace = aCtrlParentWin.GetSizePixel().Width();
#if OSL_DEBUG_LEVEL > 1
    //find all start/end positions and print it
    String sMessage(String::CreateFromAscii("Space: "));
    sMessage += String::CreateFromInt32(nSpace);
    sMessage += String::CreateFromAscii(" | ");
    Control* pDebugCtrl = aControlList.First();
    do
    {
        long nDebugXPos = pDebugCtrl->GetPosPixel().X();
        long nDebugWidth = pDebugCtrl->GetSizePixel().Width();
        sMessage += String::CreateFromInt32( nDebugXPos );
        sMessage += String::CreateFromAscii(" ");
        sMessage += String::CreateFromInt32(nDebugXPos + nDebugWidth);
        sMessage += String::CreateFromAscii(" | ");

    }while(0 != (pDebugCtrl = aControlList.Next()));

#endif

        long nMove = 0;
        if(pBtn == &aLeftScrollWin)
        {
            //find the first completely visible control (left edge visible)
            for(sal_uInt16 i = 0; i < aControlList.Count(); i++ )
            {
                Control* pCtrl = aControlList.GetObject(i);
                long nXPos = pCtrl->GetPosPixel().X();
                if(nXPos >= 0)
                {
                    if(!i)
                        //move the current control to the left edge
                        nMove = -nXPos;
                    else
                        //move the left neighbor to the start position
                        nMove = -aControlList.GetObject(i - 1)->GetPosPixel().X();
                    break;
                }
            }
        }
        else
        {
            //find the first completely visible control (left edge visible)
            for(sal_uLong i = aControlList.Count(); i; i-- )
            {
                Control* pCtrl = aControlList.GetObject(i - 1);
                long nCtrlWidth = pCtrl->GetSizePixel().Width();
                long nXPos = pCtrl->GetPosPixel().X() + nCtrlWidth;
                if(nXPos <= nSpace)
                {
                    if( i < aControlList.Count())
                    {
                        //move the right neighbor  to the right edge right aligned
                        Control* pRight = aControlList.GetObject(i);
                        nMove = nSpace - pRight->GetPosPixel().X() - pRight->GetSizePixel().Width();
                    }
                    break;
                }
            }

            //move it left until it's completely visible
        }
        if(nMove)
        {
            // move the complete list
            Control* pCtrl = aControlList.First();
            do
            {
             Point aPos = pCtrl->GetPosPixel();
                aPos.X() += nMove;
                pCtrl->SetPosPixel(aPos);
            }while(0 != (pCtrl = aControlList.Next()));
            aLeftScrollWin.Enable(aControlList.First()->GetPosPixel().X() < 0);
            pCtrl = aControlList.Last();
            aRightScrollWin.Enable((pCtrl->GetPosPixel().X() + pCtrl->GetSizePixel().Width()) > nSpace);

#if OSL_DEBUG_LEVEL > 1
            sMessage.AppendAscii("Move: ");
            sMessage += String::CreateFromInt32(nMove);
            GetParent()->GetParent()->GetParent()->SetText(sMessage);
#endif
        }
    }
    return 0;
}
/* -----------------17.06.99 11:59-------------------

 --------------------------------------------------*/
String  SwTokenWindow::GetPattern() const
{
    String sRet;
    const Control* pControl = ((SwTokenWindow*)this)->aControlList.First();
    while(pControl)
    {
        const SwFormToken& rNewToken = WINDOW_EDIT == pControl->GetType()
                    ? ((SwTOXEdit*)pControl)->GetFormToken()
                    : ((SwTOXButton*)pControl)->GetFormToken();

        //TODO: prevent input of TOX_STYLE_DELIMITER in KeyInput
        sRet += rNewToken.GetString();

        pControl = ((SwTokenWindow*)this)->aControlList.Next();
    }
    return sRet;
}
/* -----------------19.08.99 11:27-------------------
    Description: Check if a control of the specified
                    TokenType is already contained in the list
 --------------------------------------------------*/
sal_Bool SwTokenWindow::Contains(FormTokenType eSearchFor) const
{
    sal_Bool bRet = sal_False;
    const Control* pControl = ((SwTokenWindow*)this)->aControlList.First();
    while(pControl)
    {
        const SwFormToken& rNewToken = WINDOW_EDIT == pControl->GetType()
                    ? ((SwTOXEdit*)pControl)->GetFormToken()
                    : ((SwTOXButton*)pControl)->GetFormToken();

        if(eSearchFor == rNewToken.eTokenType)
        {
            bRet = sal_True;
            break;
        }
        pControl = ((SwTokenWindow*)this)->aControlList.Next();
    }
    return bRet;
}
//---------------------------------------------------
sal_Bool SwTokenWindow::CreateQuickHelp(Control* pCtrl,
            const SwFormToken& rToken,
            const HelpEvent& rHEvt)
{
    sal_Bool bRet = sal_False;
    if( rHEvt.GetMode() & HELPMODE_QUICK )
    {
        sal_Bool bBalloon = Help::IsBalloonHelpEnabled();
        String sEntry;
        if(bBalloon || rToken.eTokenType != TOKEN_AUTHORITY)
            sEntry = (aButtonHelpTexts[rToken.eTokenType]);
        if(rToken.eTokenType == TOKEN_AUTHORITY )
        {
            sEntry += SwAuthorityFieldType::GetAuthFieldName(
                                (ToxAuthorityField) rToken.nAuthorityField);
        }

     Point aPos = OutputToScreenPixel(pCtrl->GetPosPixel());
     Rectangle aItemRect( aPos, pCtrl->GetSizePixel() );
        if(rToken.eTokenType == TOKEN_TAB_STOP )
        {
//          sEntry += '\n';
//          sEntry += rToken.nTabStopPosition;
        }
        else
        {
            if(rToken.sCharStyleName.Len())
            {
                if(bBalloon)
                    sEntry += '\n';
                else
                    sEntry += ' ';
                sEntry += sCharStyle;
                sEntry += rToken.sCharStyleName;
            }
        }
        if(bBalloon)
        {
            Help::ShowBalloon( this, aPos, aItemRect, sEntry );
        }
        else
            Help::ShowQuickHelp( this, aItemRect, sEntry,
                QUICKHELP_LEFT|QUICKHELP_VCENTER );
        bRet = sal_True;
    }
    return bRet;
}
/* -----------------------------14.01.00 12:22--------------------------------

 ---------------------------------------------------------------------------*/
void SwTokenWindow::Resize()
{
 Size aCompleteSize(GetOutputSizePixel());

 Point aRightPos(aRightScrollWin.GetPosPixel());
 Size aRightSize(aRightScrollWin.GetSizePixel());

 Size aMiddleSize(aCtrlParentWin.GetSizePixel());

    long nMove = aCompleteSize.Width() - aRightSize.Width() - aRightPos.X();

    aRightPos.X() += nMove;
    aRightScrollWin.SetPosPixel(aRightPos);
    aMiddleSize.Width() += nMove;
    aCtrlParentWin.SetSizePixel(aMiddleSize);
}

/* -----------------16.06.99 15:23-------------------

 --------------------------------------------------*/
IMPL_LINK(SwTokenWindow, EditResize, Edit*, pEdit)
{
    ((SwTOXEdit*)pEdit)->AdjustSize();
    AdjustPositions();
    if(aModifyHdl.IsSet())
        aModifyHdl.Call(0);
    return 0;
}
/* -----------------16.06.99 15:56-------------------

 --------------------------------------------------*/
IMPL_LINK(SwTokenWindow, NextItemHdl, SwTOXEdit*,  pEdit)
{
    sal_uInt16 nPos = (sal_uInt16)aControlList.GetPos(pEdit);
    if( (nPos && !pEdit->IsNextControl()) ||
        (nPos < aControlList.Count() - 1 && pEdit->IsNextControl()))
    {
        aControlList.Seek(nPos);
        Control* pNextPrev = pEdit->IsNextControl() ? aControlList.Next() : aControlList.Prev();
        nPos += pEdit->IsNextControl() ? 1 : -1;
        pNextPrev->GrabFocus();
        ((SwTOXButton*)pNextPrev)->Check();
        AdjustScrolling();
    }
    return 0;
}
/* -----------------17.06.99 08:58-------------------

 --------------------------------------------------*/
IMPL_LINK(SwTokenWindow, TbxFocusHdl, SwTOXEdit*, pEdit)
{
    for(sal_uInt16 i = 0; i < aControlList.Count(); i++)
    {
        Control* pControl = aControlList.First();
        while(pControl)
        {
            if(WINDOW_EDIT != pControl->GetType() )
                ((SwTOXButton*)pControl)->Check(sal_False);
            pControl = aControlList.Next();
        }
    }
    SetActiveControl(pEdit);
    return 0;
}
/* -----------------17.06.99 10:05-------------------

 --------------------------------------------------*/
IMPL_LINK(SwTokenWindow, NextItemBtnHdl, SwTOXButton*, pBtn )
{
    sal_uInt16 nPos = (sal_uInt16)aControlList.GetPos(pBtn);
    if( (nPos && !pBtn->IsNextControl()) ||
        (nPos < aControlList.Count() - 1 && pBtn->IsNextControl()))
    {
        aControlList.Seek(nPos);
        sal_Bool bNext = pBtn->IsNextControl();
        Control* pNextPrev = bNext ? aControlList.Next() : aControlList.Prev();
        pNextPrev->GrabFocus();
        Selection aSel(0, 0);
        if(!bNext)
        {
            sal_uInt16 nLen = ((SwTOXEdit*)pNextPrev)->GetText().Len();
            aSel.A() = nLen;
            aSel.B() = nLen;
        }
        ((SwTOXEdit*)pNextPrev)->SetSelection(aSel);
        pBtn->Check(sal_False);
        AdjustScrolling();
    }
    return 0;
}

/* -----------------17.06.99 10:04-------------------

 --------------------------------------------------*/
IMPL_LINK(SwTokenWindow, TbxFocusBtnHdl, SwTOXButton*, pBtn )
{
    for(sal_uInt16 i = 0; i < aControlList.Count(); i++)
    {
        Control* pControl = aControlList.First();
        while(pControl)
        {
            if(WINDOW_EDIT != pControl->GetType() )
                ((SwTOXButton*)pControl)->Check(pBtn == pControl);
            pControl = aControlList.Next();
        }
    }
    SetActiveControl(pBtn);
    return 0;
}
/* -----------------------------28.01.2002 12:22------------------------------

 ---------------------------------------------------------------------------*/
void SwTokenWindow::GetFocus()
{
    if(GETFOCUS_TAB & GetGetFocusFlags())
    {
       Control* pFirst = aControlList.First();
       if(pFirst)
       {
            pFirst->GrabFocus();
            SetActiveControl(pFirst);
            AdjustScrolling();
       }
    }
}
void SwTokenWindow::SetFocus2theAllBtn()
{
    if (m_pParent)
    {
        m_pParent->SetFocus2theAllBtn();
    }
}
sal_uInt32 SwTokenWindow::GetControlIndex(FormTokenType eType, const Control* /* pCurControl */) const
{
    //there are only one entry-text button and only one page-number button,
    //so we need not add index for these two buttons.
    if ( eType == TOKEN_ENTRY_TEXT || eType == TOKEN_PAGE_NUMS )
    {
        return 0;
    }

    sal_uInt32 nIndex = 0;
    const Control* pControl = ((SwTokenWindow*)this)->aControlList.First();
    while(pControl)
    {
        const SwFormToken& rNewToken = WINDOW_EDIT == pControl->GetType()
            ? ((SwTOXEdit*)pControl)->GetFormToken()
            : ((SwTOXButton*)pControl)->GetFormToken();

        if(eType == rNewToken.eTokenType)
        {
            nIndex++;
        }
        pControl = ((SwTokenWindow*)this)->aControlList.Next();
    }

    return nIndex;
}
/* -----------------25.03.99 15:17-------------------
 *
 * --------------------------------------------------*/
SwTOXStylesTabPage::SwTOXStylesTabPage(Window* pParent, const SfxItemSet& rAttrSet ) :
    SfxTabPage(pParent, SW_RES(TP_TOX_STYLES), rAttrSet),
    aFormatFL(this,     SW_RES(FL_FORMAT  )),
    aLevelFT2(this,     SW_RES(FT_LEVEL  )),
    aLevelLB(this,      SW_RES(LB_LEVEL  )),
    aAssignBT(this,     SW_RES(BT_ASSIGN  )),
    aTemplateFT(this,   SW_RES(FT_TEMPLATE)),
    aParaLayLB(this,    SW_RES(LB_PARALAY )),
    aStdBT(this,        SW_RES(BT_STD    )),
    aEditStyleBT(this,  SW_RES(BT_EDIT_STYLE    )),
    m_pCurrentForm(0)
{
    FreeResource();

    SetExchangeSupport( sal_True );

    aAssignBT.SetModeImage( Image( SW_RES( IMG_ONE_LEFT_HC ) ), BMP_COLOR_HIGHCONTRAST );

    aEditStyleBT.SetClickHdl   (LINK(   this, SwTOXStylesTabPage, EditStyleHdl));
    aAssignBT.SetClickHdl      (LINK(   this, SwTOXStylesTabPage, AssignHdl));
    aStdBT.SetClickHdl         (LINK(   this, SwTOXStylesTabPage, StdHdl));
    aParaLayLB.SetSelectHdl    (LINK(   this, SwTOXStylesTabPage, EnableSelectHdl));
    aLevelLB.SetSelectHdl      (LINK(   this, SwTOXStylesTabPage, EnableSelectHdl));
    aParaLayLB.SetDoubleClickHdl(LINK(  this, SwTOXStylesTabPage, DoubleClickHdl));

    aStdBT.SetAccessibleRelationMemberOf(&aFormatFL);
    aAssignBT.SetAccessibleRelationMemberOf(&aFormatFL);
    aEditStyleBT.SetAccessibleRelationMemberOf(&aFormatFL);

}
/* -----------------25.03.99 15:17-------------------
 *
 * --------------------------------------------------*/
SwTOXStylesTabPage::~SwTOXStylesTabPage()
{
    delete m_pCurrentForm;
}
/* -----------------25.03.99 15:17-------------------
 *
 * --------------------------------------------------*/
sal_Bool    SwTOXStylesTabPage::FillItemSet( SfxItemSet& )
{
    return sal_True;
}
/* -----------------25.03.99 15:17-------------------
 *
 * --------------------------------------------------*/
void    SwTOXStylesTabPage::Reset( const SfxItemSet& rSet )
{
    ActivatePage(rSet);
}
/* -----------------25.03.99 15:17-------------------
 *
 * --------------------------------------------------*/
void    SwTOXStylesTabPage::ActivatePage( const SfxItemSet& )
{
    m_pCurrentForm = new SwForm(GetForm());
    aParaLayLB.Clear();
    aLevelLB.Clear();

    // kein Hyperlink fuer Benutzerverzeichnisse

    sal_uInt16 i, nSize = m_pCurrentForm->GetFormMax();

    // form-Pattern anzeigen ohne Titel

    //1. TemplateEntry  anzeigen
    String aStr( SW_RES( STR_TITLE ));
    if( m_pCurrentForm->GetTemplate( 0 ).Len() )
    {
        aStr += ' ';
        aStr += aDeliStart;
        aStr += m_pCurrentForm->GetTemplate( 0 );
        aStr += aDeliEnd;
    }
    aLevelLB.InsertEntry(aStr);

    for( i=1; i < nSize; ++i )
    {
        if( TOX_INDEX == m_pCurrentForm->GetTOXType() &&
            FORM_ALPHA_DELIMITTER == i )
            aStr = SW_RESSTR(STR_ALPHA);
        else
        {
            aStr  = SW_RESSTR(STR_LEVEL);
            aStr += String::CreateFromInt32(
                    TOX_INDEX == m_pCurrentForm->GetTOXType() ? i - 1 : i );
        }
        String aCpy( aStr );

        if( m_pCurrentForm->GetTemplate( i ).Len() )
        {
            aCpy += ' ';
            aCpy += aDeliStart;
            aCpy += m_pCurrentForm->GetTemplate( i );
            aCpy += aDeliEnd;
        }
        aLevelLB.InsertEntry( aCpy );
    }

    // Templates initialisieren
    const SwTxtFmtColl *pColl;
    SwWrtShell& rSh = ((SwMultiTOXTabDialog*)GetTabDialog())->GetWrtShell();
    const sal_uInt16 nSz = rSh.GetTxtFmtCollCount();

    for( i = 0; i < nSz; ++i )
        if( !(pColl = &rSh.GetTxtFmtColl( i ))->IsDefault() )
            aParaLayLB.InsertEntry( pColl->GetName() );

    // Pool-Collections abfragen und fuer das Verzeichnis setzen
    for( i = 0; i < m_pCurrentForm->GetFormMax(); ++i )
    {
        aStr = m_pCurrentForm->GetTemplate( i );
        if( aStr.Len() &&
            LISTBOX_ENTRY_NOTFOUND == aParaLayLB.GetEntryPos( aStr ))
            aParaLayLB.InsertEntry( aStr );
    }

    EnableSelectHdl(&aParaLayLB);
}
/* -----------------25.03.99 15:17-------------------
 *
 * --------------------------------------------------*/
int     SwTOXStylesTabPage::DeactivatePage( SfxItemSet* /*pSet*/  )
{
    GetForm() = *m_pCurrentForm;
    return LEAVE_PAGE;
}

/* -----------------25.03.99 15:17-------------------
 *
 * --------------------------------------------------*/
SfxTabPage* SwTOXStylesTabPage::Create( Window* pParent,
                                const SfxItemSet& rAttrSet)
{
    return new SwTOXStylesTabPage(pParent, rAttrSet);
}
/* -----------------26.03.99 12:47-------------------
 *
 * --------------------------------------------------*/
IMPL_LINK( SwTOXStylesTabPage, EditStyleHdl, Button *, pBtn )
{
    if( LISTBOX_ENTRY_NOTFOUND != aParaLayLB.GetSelectEntryPos())
    {
        SfxStringItem aStyle(SID_STYLE_EDIT, aParaLayLB.GetSelectEntry());
        SfxUInt16Item aFamily(SID_STYLE_FAMILY, SFX_STYLE_FAMILY_PARA);
//      SwPtrItem aShell(FN_PARAM_WRTSHELL, pWrtShell);
        Window* pDefDlgParent = Application::GetDefDialogParent();
        Application::SetDefDialogParent( pBtn );
        SwWrtShell& rSh = ((SwMultiTOXTabDialog*)GetTabDialog())->GetWrtShell();
        rSh.GetView().GetViewFrame()->GetDispatcher()->Execute(
        SID_STYLE_EDIT, SFX_CALLMODE_SYNCHRON|SFX_CALLMODE_MODAL,
            &aStyle, &aFamily/*, &aShell*/, 0L);
        Application::SetDefDialogParent( pDefDlgParent );
    }
    return 0;
}
/*--------------------------------------------------------------------
     Beschreibung: Vorlagen zuweisen
 --------------------------------------------------------------------*/
IMPL_LINK( SwTOXStylesTabPage, AssignHdl, Button *, EMPTYARG )
{
    sal_uInt16 nLevPos   = aLevelLB.GetSelectEntryPos();
    sal_uInt16 nTemplPos = aParaLayLB.GetSelectEntryPos();
    if(nLevPos   != LISTBOX_ENTRY_NOTFOUND &&
       nTemplPos != LISTBOX_ENTRY_NOTFOUND)
    {
        String aStr(aLevelLB.GetEntry(nLevPos));
        sal_uInt16 nDelPos = aStr.Search(aDeliStart);
        if(nDelPos != STRING_NOTFOUND)
            aStr.Erase(nDelPos-1);
        aStr += ' ';
        aStr += aDeliStart;
        aStr += aParaLayLB.GetSelectEntry();

        m_pCurrentForm->SetTemplate(nLevPos, aParaLayLB.GetSelectEntry());

        aStr += aDeliEnd;

        aLevelLB.RemoveEntry(nLevPos);
        aLevelLB.InsertEntry(aStr, nLevPos);
        aLevelLB.SelectEntry(aStr);
        ModifyHdl(0);
    }
    return 0;
}
/* -----------------26.03.99 09:10-------------------
 *
 * --------------------------------------------------*/
IMPL_LINK( SwTOXStylesTabPage, StdHdl, Button *, EMPTYARG )
{
    sal_uInt16 nPos = aLevelLB.GetSelectEntryPos();
    if(nPos != LISTBOX_ENTRY_NOTFOUND)
    {   String aStr(aLevelLB.GetEntry(nPos));
        sal_uInt16 nDelPos = aStr.Search(aDeliStart);
        if(nDelPos != STRING_NOTFOUND)
            aStr.Erase(nDelPos-1);
        aLevelLB.RemoveEntry(nPos);
        aLevelLB.InsertEntry(aStr, nPos);
        aLevelLB.SelectEntry(aStr);
        m_pCurrentForm->SetTemplate(nPos, aEmptyStr);
        ModifyHdl(0);
    }
    return 0;
}
/* -----------------26.03.99 09:11-------------------
 *
 * --------------------------------------------------*/
IMPL_LINK_INLINE_START( SwTOXStylesTabPage, DoubleClickHdl, Button *, EMPTYARG )
{
    String aTmpName( aParaLayLB.GetSelectEntry() );
    SwWrtShell& rSh = ((SwMultiTOXTabDialog*)GetTabDialog())->GetWrtShell();

    if(aParaLayLB.GetSelectEntryPos() != LISTBOX_ENTRY_NOTFOUND &&
       (aLevelLB.GetSelectEntryPos() == 0 || SwMultiTOXTabDialog::IsNoNum(rSh, aTmpName)))
        AssignHdl(&aAssignBT);
    return 0;
}
IMPL_LINK_INLINE_END( SwTOXStylesTabPage, DoubleClickHdl, Button *, EMPTYARG )
/*--------------------------------------------------------------------
     Beschreibung: nur wenn selektiert enable
 --------------------------------------------------------------------*/
IMPL_LINK( SwTOXStylesTabPage, EnableSelectHdl, ListBox *, EMPTYARG )
{
    //UpdatePattern();
    aStdBT.Enable(aLevelLB.GetSelectEntryPos()  != LISTBOX_ENTRY_NOTFOUND);

    SwWrtShell& rSh = ((SwMultiTOXTabDialog*)GetTabDialog())->GetWrtShell();
    String aTmpName(aParaLayLB.GetSelectEntry());
    aAssignBT.Enable(aParaLayLB.GetSelectEntryPos() != LISTBOX_ENTRY_NOTFOUND &&
                     LISTBOX_ENTRY_NOTFOUND != aLevelLB.GetSelectEntryPos() &&
       (aLevelLB.GetSelectEntryPos() == 0 || SwMultiTOXTabDialog::IsNoNum(rSh, aTmpName)));
    aEditStyleBT.Enable(aParaLayLB.GetSelectEntryPos() != LISTBOX_ENTRY_NOTFOUND );
    return 0;
}
/* -----------------------------18.01.00 16:54--------------------------------

 ---------------------------------------------------------------------------*/
IMPL_LINK(SwTOXStylesTabPage, ModifyHdl, void*, EMPTYARG)
{
    SwMultiTOXTabDialog* pTOXDlg = (SwMultiTOXTabDialog*)GetTabDialog();
    if(pTOXDlg)
    {
        GetForm() = *m_pCurrentForm;
        pTOXDlg->CreateOrUpdateExample(pTOXDlg->GetCurrentTOXType().eType, TOX_PAGE_STYLES);
    }
    return 0;
}
/******************************************************************************

******************************************************************************/
#define ITEM_SEARCH         1
#define ITEM_ALTERNATIVE    2
#define ITEM_PRIM_KEY       3
#define ITEM_SEC_KEY        4
#define ITEM_COMMENT        5
#define ITEM_CASE           6
#define ITEM_WORDONLY       7


SwEntryBrowseBox::SwEntryBrowseBox(Window* pParent, const ResId& rId,
                                                    BrowserMode nMode ) :
            SwEntryBrowseBox_Base( pParent, rId, nMode,
                           BROWSER_KEEPSELECTION |
                           BROWSER_COLUMNSELECTION |
                           BROWSER_MULTISELECTION |
                           BROWSER_TRACKING_TIPS |
                           BROWSER_HLINESFULL |
                           BROWSER_VLINESFULL |
                           BROWSER_AUTO_VSCROLL|
                           BROWSER_HIDECURSOR   ),
            aCellEdit(&GetDataWindow(), 0),
            aCellCheckBox(&GetDataWindow()),

            sSearch(        ResId(ST_SEARCH, *rId.GetResMgr()         )),
            sAlternative(   ResId(ST_ALTERNATIVE, *rId.GetResMgr()  )),
            sPrimKey(       ResId(ST_PRIMKEY, *rId.GetResMgr()      )),
            sSecKey(        ResId(ST_SECKEY, *rId.GetResMgr()           )),
            sComment(       ResId(ST_COMMENT, *rId.GetResMgr()      )),
            sCaseSensitive( ResId(ST_CASESENSITIVE, *rId.GetResMgr()    )),
            sWordOnly(      ResId(ST_WORDONLY, *rId.GetResMgr()     )),
            sYes(           ResId(ST_TRUE, *rId.GetResMgr()             )),
            sNo(            ResId(ST_FALSE, *rId.GetResMgr()            )),
            bModified(sal_False)
{
    FreeResource();
    aCellCheckBox.GetBox().EnableTriState(sal_False);
    xController = new ::svt::EditCellController(&aCellEdit);
    xCheckController = new ::svt::CheckBoxCellController(&aCellCheckBox);

    //////////////////////////////////////////////////////////////////////
    // HACK: BrowseBox invalidiert nicht ihre Childs, wie es eigentlich sein sollte.
    // Deshalb wird WB_CLIPCHILDREN zurueckgesetzt, wodurch das Invalidieren
    // der Childs erzwungen wird.
    WinBits aStyle = GetStyle();
    if( aStyle & WB_CLIPCHILDREN )
    {
        aStyle &= ~WB_CLIPCHILDREN;
        SetStyle( aStyle );
    }
    const String* aTitles[7] =
    {
        &sSearch,
        &sAlternative,
        &sPrimKey,
        &sSecKey,
        &sComment,
        &sCaseSensitive,
        &sWordOnly
    };

    long nWidth = GetSizePixel().Width();
    nWidth /=7;
    --nWidth;
    for(sal_uInt16 i = 1; i < 8; i++)
        InsertDataColumn( i, *aTitles[i - 1], nWidth,
                          HIB_STDSTYLE, HEADERBAR_APPEND );

}
/* -----------------------------19.01.00 11:29--------------------------------

 ---------------------------------------------------------------------------*/
sal_Bool    SwEntryBrowseBox::SeekRow( long nRow )
{
    nCurrentRow = nRow;
    return sal_True;
}
/* -----------------------------19.01.00 15:32--------------------------------

 ---------------------------------------------------------------------------*/
String SwEntryBrowseBox::GetCellText(long nRow, sal_uInt16 nColumn) const
{
    const String* pRet = &aEmptyStr;
    if(aEntryArr.Count() > nRow)
    {
        AutoMarkEntry* pEntry = aEntryArr[ static_cast< sal_uInt16 >(nRow) ];
        switch(nColumn)
        {
            case  ITEM_SEARCH       :pRet = &pEntry->sSearch; break;
            case  ITEM_ALTERNATIVE  :pRet = &pEntry->sAlternative; break;
            case  ITEM_PRIM_KEY     :pRet = &pEntry->sPrimKey   ; break;
            case  ITEM_SEC_KEY      :pRet = &pEntry->sSecKey    ; break;
            case  ITEM_COMMENT      :pRet = &pEntry->sComment   ; break;
            case  ITEM_CASE         :pRet = pEntry->bCase ? &sYes : &sNo; break;
            case  ITEM_WORDONLY     :pRet = pEntry->bWord ? &sYes : &sNo; break;
        }
    }
    return *pRet;
}

/* -----------------------------19.01.00 11:29--------------------------------

 ---------------------------------------------------------------------------*/
void    SwEntryBrowseBox::PaintCell(OutputDevice& rDev,
                                const Rectangle& rRect, sal_uInt16 nColumnId) const
{
    String sPaint = GetCellText( nCurrentRow, nColumnId );
    sal_uInt16 nStyle = TEXT_DRAW_CLIP | TEXT_DRAW_CENTER;
    rDev.DrawText( rRect, sPaint, nStyle );
}
/* -----------------------------19.01.00 14:51--------------------------------

 ---------------------------------------------------------------------------*/
::svt::CellController* SwEntryBrowseBox::GetController(long /*nRow*/, sal_uInt16 nCol)
{
    return nCol < ITEM_CASE ? xController : xCheckController;
}
/* -----------------------------19.01.00 15:36--------------------------------

 ---------------------------------------------------------------------------*/
sal_Bool SwEntryBrowseBox::SaveModified()
{
    SetModified();
    sal_uInt16 nRow = static_cast< sal_uInt16 >(GetCurRow());
    sal_uInt16 nCol = GetCurColumnId();

    String sNew;
    sal_Bool bVal = sal_False;
    ::svt::CellController* pController = 0;
    if(nCol < ITEM_CASE)
    {
        pController = xController;
        sNew = ((::svt::EditCellController*)pController)->GetEditImplementation()->GetText( LINEEND_LF );
    }
    else
    {
        pController = xCheckController;
        bVal = ((::svt::CheckBoxCellController*)pController)->GetCheckBox().IsChecked();
    }
    AutoMarkEntry* pEntry = nRow >= aEntryArr.Count() ? new AutoMarkEntry
                                                      : aEntryArr[nRow];
    switch(nCol)
    {
        case  ITEM_SEARCH       : pEntry->sSearch = sNew; break;
        case  ITEM_ALTERNATIVE  : pEntry->sAlternative = sNew; break;
        case  ITEM_PRIM_KEY     : pEntry->sPrimKey   = sNew; break;
        case  ITEM_SEC_KEY      : pEntry->sSecKey    = sNew; break;
        case  ITEM_COMMENT      : pEntry->sComment   = sNew; break;
        case  ITEM_CASE         : pEntry->bCase = bVal; break;
        case  ITEM_WORDONLY     : pEntry->bWord = bVal; break;
    }
    if(nRow >= aEntryArr.Count())
    {
        aEntryArr.Insert( pEntry, aEntryArr.Count() );
        RowInserted(nRow, 1, sal_True, sal_True);
        if(nCol < ITEM_WORDONLY)
        {
            pController->ClearModified();
            GoToRow( nRow );
        }
    }
    return sal_True;
}
/* -----------------------------19.01.00 14:32--------------------------------

 ---------------------------------------------------------------------------*/
void    SwEntryBrowseBox::InitController(
                ::svt::CellControllerRef& rController, long nRow, sal_uInt16 nCol)
{
    String rTxt = GetCellText( nRow, nCol );
    if(nCol < ITEM_CASE)
    {
        rController = xController;
        ::svt::CellController* pController = xController;
        ((::svt::EditCellController*)pController)->GetEditImplementation()->SetText( rTxt );
    }
    else
    {
        rController = xCheckController;
        ::svt::CellController* pController = xCheckController;
        ((::svt::CheckBoxCellController*)pController)->GetCheckBox().Check(
                                                            rTxt == sYes );
    }
}
/* -----------------------------19.01.00 12:19--------------------------------

 ---------------------------------------------------------------------------*/
void    SwEntryBrowseBox::ReadEntries(SvStream& rInStr)
{
    AutoMarkEntry* pToInsert = 0;
    const String sZero('0');
    rtl_TextEncoding  eTEnc = gsl_getSystemTextEncoding();
    while( !rInStr.GetError() && !rInStr.IsEof() )
    {
        String sLine;
        rInStr.ReadByteStringLine( sLine, eTEnc );

        // # -> comment
        // ; -> delimiter between entries ->
        // Format: TextToSearchFor;AlternativeString;PrimaryKey;SecondaryKey
        // Leading and trailing blanks are ignored
        if( sLine.Len() )
        {
            //comments are contained in separate lines but are put into the struct of the following data
            //line (if available)
            if( '#' != sLine.GetChar(0) )
            {
                if( !pToInsert )
                    pToInsert = new AutoMarkEntry;

                sal_uInt16 nSttPos = 0;
                pToInsert->sSearch      = sLine.GetToken(0, ';', nSttPos );
                pToInsert->sAlternative = sLine.GetToken(0, ';', nSttPos );
                pToInsert->sPrimKey     = sLine.GetToken(0, ';', nSttPos );
                pToInsert->sSecKey      = sLine.GetToken(0, ';', nSttPos );

                String sStr = sLine.GetToken(0, ';', nSttPos );
                pToInsert->bCase = sStr.Len() && sStr != sZero;

                sStr = sLine.GetToken(0, ';', nSttPos );
                pToInsert->bWord = sStr.Len() && sStr != sZero;

                aEntryArr.Insert( pToInsert, aEntryArr.Count() );
                pToInsert = 0;
            }
            else
            {
                if(pToInsert)
                    aEntryArr.Insert(pToInsert, aEntryArr.Count());
                pToInsert = new AutoMarkEntry;
                pToInsert->sComment = sLine;
                pToInsert->sComment.Erase(0, 1);
            }
        }
    }
    if( pToInsert )
        aEntryArr.Insert(pToInsert, aEntryArr.Count());
    RowInserted(0, aEntryArr.Count() + 1, sal_True);
}
/* -----------------------------19.01.00 12:19--------------------------------

 ---------------------------------------------------------------------------*/
void    SwEntryBrowseBox::WriteEntries(SvStream& rOutStr)
{
    //check if the current controller is modified
    sal_uInt16 nCol = GetCurColumnId();
    ::svt::CellController* pController;
    if(nCol < ITEM_CASE)
        pController = xController;
    else
        pController = xCheckController;
    if(pController ->IsModified())
        GoToColumnId(nCol < ITEM_CASE ? ++nCol : --nCol );

    rtl_TextEncoding  eTEnc = gsl_getSystemTextEncoding();
    for(sal_uInt16 i = 0; i < aEntryArr.Count();i++)
    {
        AutoMarkEntry* pEntry = aEntryArr[i];
        if(pEntry->sComment.Len())
        {
            String sWrite('#');
            sWrite += pEntry->sComment;
            rOutStr.WriteByteStringLine( sWrite, eTEnc );
        }

        String sWrite( pEntry->sSearch );
        sWrite += ';';
        sWrite += pEntry->sAlternative;
        sWrite += ';';
        sWrite += pEntry->sPrimKey;
        sWrite += ';';
        sWrite += pEntry->sSecKey;
        sWrite += ';';
        sWrite += pEntry->bCase ? '1' : '0';
        sWrite += ';';
        sWrite += pEntry->bWord ? '1' : '0';

        if( sWrite.Len() > 5 )
            rOutStr.WriteByteStringLine( sWrite, eTEnc );
    }
}
/* -----------------------------21.01.00 11:49--------------------------------

 ---------------------------------------------------------------------------*/
sal_Bool SwEntryBrowseBox::IsModified()const
{
    if(bModified)
        return sal_True;


    //check if the current controller is modified
    sal_uInt16 nCol = GetCurColumnId();
    ::svt::CellController* pController;
    if(nCol < ITEM_CASE)
        pController = xController;
    else
        pController = xCheckController;
    return pController ->IsModified();
}
/* -----------------------------19.01.00 11:29--------------------------------

 ---------------------------------------------------------------------------*/
SwAutoMarkDlg_Impl::SwAutoMarkDlg_Impl(Window* pParent, const String& rAutoMarkURL,
        const String& rAutoMarkType, sal_Bool bCreate) :
    ModalDialog(pParent, SW_RES(DLG_CREATE_AUTOMARK)),
    aOKPB(      this, SW_RES(PB_OK      )),
    aCancelPB(  this, SW_RES(PB_CANCEL  )),
    aHelpPB(    this, SW_RES(PB_HELP        )),
    aEntriesBB( this, SW_RES(BB_ENTRIES )),
    aEntriesFL( this, SW_RES(FL_ENTRIES  )),
    sAutoMarkURL(rAutoMarkURL),
    sAutoMarkType(rAutoMarkType),
    bCreateMode(bCreate)
{
    FreeResource();
    aOKPB.SetClickHdl(LINK(this, SwAutoMarkDlg_Impl, OkHdl));

    String sTitle = GetText();
    sTitle.AppendAscii( RTL_CONSTASCII_STRINGPARAM(": "));
    sTitle += sAutoMarkURL;
    SetText(sTitle);
    sal_Bool bError = sal_False;
    if( bCreateMode )
        aEntriesBB.RowInserted(0, 1, sal_True);
    else
    {
        SfxMedium aMed( sAutoMarkURL, STREAM_STD_READ, sal_False );
        if( aMed.GetInStream() && !aMed.GetInStream()->GetError() )
            aEntriesBB.ReadEntries( *aMed.GetInStream() );
        else
            bError = sal_True;
    }

    if(bError)
        EndDialog(RET_CANCEL);
}
/* -----------------------------19.01.00 11:12--------------------------------

 ---------------------------------------------------------------------------*/
SwAutoMarkDlg_Impl::~SwAutoMarkDlg_Impl()
{
}
/* -----------------------------19.01.00 16:43--------------------------------

 ---------------------------------------------------------------------------*/
IMPL_LINK(SwAutoMarkDlg_Impl, OkHdl, OKButton*, EMPTYARG)
{
    sal_Bool bError = sal_False;
    if(aEntriesBB.IsModified() || bCreateMode)
    {
        SfxMedium aMed( sAutoMarkURL,
                        bCreateMode ? STREAM_WRITE
                                    : STREAM_WRITE| STREAM_TRUNC,
                        sal_False );
        SvStream* pStrm = aMed.GetOutStream();
        pStrm->SetStreamCharSet( RTL_TEXTENCODING_MS_1253 );
        if( !pStrm->GetError() )
        {
            aEntriesBB.WriteEntries( *pStrm );
            aMed.Commit();
        }
        else
            bError = sal_True;
    }
    if( !bError )
        EndDialog(RET_OK);
    return 0;
}