xref: /aoo42x/main/sw/source/ui/misc/glossary.cxx (revision 6f9cb704)

/**************************************************************
 *
 * 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

#define _SVSTDARR_STRINGSDTOR
#define _SVSTDARR_STRINGS
#include <hintids.hxx>

#include <vcl/menu.hxx>
#include <vcl/msgbox.hxx>
#include <vcl/help.hxx>
#ifndef _SVSTDARR_HXX
#include <svl/svstdarr.hxx>
#endif
#include <svl/stritem.hxx>
#include <unotools/pathoptions.hxx>
#include <unotools/lingucfg.hxx>
#include <sfx2/request.hxx>
#include <sfx2/fcontnr.hxx>

#include <svx/svxdlg.hxx>
#include <svx/dialogs.hrc>
#include <editeng/acorrcfg.hxx>
#include <sfx2/viewfrm.hxx>
#include <unocrsr.hxx>
#include <unotools.hxx>
#include <comphelper/processfactory.hxx>
#include <ucbhelper/content.hxx>
#include <com/sun/star/ui/dialogs/XFilePicker.hpp>
#include <com/sun/star/ui/dialogs/XFilterManager.hpp>
#include <com/sun/star/ui/dialogs/TemplateDescription.hpp>
#include <svl/urihelper.hxx>
#include <unotools/charclass.hxx>
#include <swwait.hxx>
#include <swtypes.hxx>
#include <wrtsh.hxx>
#include <view.hxx>
#include <basesh.hxx>
#include <glossary.hxx>
#include <gloshdl.hxx>
#include <glosbib.hxx>
#include <initui.hxx>					// fuer ::GetGlossaries()
#include <glosdoc.hxx>
#include <macassgn.hxx>
#include <swevent.hxx>
#include <docsh.hxx>
#include <shellio.hxx>

#include <cmdid.h>
#include <helpid.h>
#include <swerror.h>
#ifndef _GLOBALS_HRC
#include <globals.hrc>
#endif
#ifndef _MISC_HRC
#include <misc.hrc>
#endif
#ifndef _GLOSSARY_HRC
#include <glossary.hrc>
#endif
#include <swmodule.hxx>
#include <sfx2/filedlghelper.hxx>

#include "access.hrc"

#define LONG_LENGTH 60
#define SHORT_LENGTH 30


using namespace ::com::sun::star;
using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::text;
using namespace ::com::sun::star::ucb;
using namespace ::com::sun::star::ui::dialogs;
using namespace ::comphelper;
using namespace ::ucbhelper;
using ::rtl::OUString;
using namespace ::sfx2;

String lcl_GetValidShortCut( const String& rName )
{
    const sal_uInt16 nSz = rName.Len();

    if ( 0 == nSz )
        return rName;

    sal_uInt16 nStart = 1;
    while( rName.GetChar( nStart-1 ) == ' ' && nStart < nSz )
        nStart++;

    String aBuf( rName.GetChar( nStart-1 ));

    for( ; nStart < nSz; ++nStart )
    {
        if( rName.GetChar( nStart-1 ) == ' ' && rName.GetChar( nStart ) != ' ')
            aBuf += rName.GetChar( nStart );
    }
    return aBuf;
}

/* -----------------------------08.02.00 10:28--------------------------------

 ---------------------------------------------------------------------------*/
struct GroupUserData
{
	String 		sGroupName;
	sal_uInt16 	nPathIdx;
	sal_Bool 		bReadonly;

	GroupUserData()
		: nPathIdx(0),
		  bReadonly(sal_False)	{}
};

/*------------------------------------------------------------------------
 Beschreibung:	Dialog fuer neuen Bausteinnamen
------------------------------------------------------------------------*/
class SwNewGlosNameDlg : public ModalDialog
{
	FixedText		aNNFT;
	Edit			aNewName;
	FixedText		aNSFT;
	NoSpaceEdit		aNewShort;
	OKButton		aOk;
	CancelButton	aCancel;
	FixedText		aONFT;
	Edit			aOldName;
	FixedText 		aOSFT;
	Edit			aOldShort;
	FixedLine       aFL;

protected:
	DECL_LINK( Modify, Edit * );
	DECL_LINK( Rename, Button * );

public:
	SwNewGlosNameDlg( Window* pParent,
					  const String& rOldName,
					  const String& rOldShort );

	String GetNewName()  const { return aNewName.GetText(); }
	String GetNewShort() const { return aNewShort.GetText(); }
};

SwNewGlosNameDlg::SwNewGlosNameDlg(Window* pParent,
							const String& rOldName,
							const String& rOldShort ) :
	ModalDialog( pParent, SW_RES( DLG_RENAME_GLOS ) ),
    aNNFT   (this, SW_RES( FT_NN    )),
    aNewName(this, SW_RES( ED_NN    )),
    aNSFT   (this, SW_RES( FT_NS    )),
    aNewShort(this,SW_RES( ED_NS    )),
	aOk		(this, SW_RES( BT_OKNEW)),
	aCancel	(this, SW_RES( BT_CANCEL)),
	aONFT	(this, SW_RES( FT_ON	)),
    aOldName(this, SW_RES( ED_ON    )),
	aOSFT	(this, SW_RES( FT_OS	)),
    aOldShort(this,SW_RES( ED_OS    )),
    aFL    (this, SW_RES( FL_NN    ))

{
	FreeResource();
	aOldName.SetText( rOldName );
	aOldShort.SetText( rOldShort );
	aNewShort.SetMaxTextLen(SHORT_LENGTH);
	aNewName.SetMaxTextLen(LONG_LENGTH);
	aNewName.SetModifyHdl(LINK(this, SwNewGlosNameDlg, Modify ));
	aNewShort.SetModifyHdl(LINK(this, SwNewGlosNameDlg, Modify ));
	aOk.SetClickHdl(LINK(this, SwNewGlosNameDlg, Rename ));
	aNewName.GrabFocus();
}

/*------------------------------------------------------------------------
 Beschreibung:	aktuell eingestellte Gruppe erfragen / setzen
------------------------------------------------------------------------*/

String SwGlossaryDlg::GetCurrGroup()
{
	if( ::GetCurrGlosGroup() && ::GetCurrGlosGroup()->Len() )
		return *(::GetCurrGlosGroup());
	return SwGlossaries::GetDefName();
}



void SwGlossaryDlg::SetActGroup(const String &rGrp)
{
	if( !::GetCurrGlosGroup() )
		::SetCurrGlosGroup( new String );
	*(::GetCurrGlosGroup()) = rGrp;
}



SwGlossaryDlg::SwGlossaryDlg(SfxViewFrame* pViewFrame,
							SwGlossaryHdl * pGlosHdl, SwWrtShell *pWrtShell) :

	SvxStandardDialog(&pViewFrame->GetWindow(), SW_RES(DLG_GLOSSARY)),

    aInsertTipCB  (this, SW_RES(CB_INSERT_TIP)),
	aNameLbl	  (this, SW_RES(FT_NAME)),
	aNameED       (this, SW_RES(ED_NAME)),
	aShortNameLbl (this, SW_RES(FT_SHORTNAME)),
	aShortNameEdit(this, SW_RES(ED_SHORTNAME)),
	aCategoryBox  (this, SW_RES(LB_BIB)),
    aRelativeFL   (this, SW_RES(FL_RELATIVE)),
    aFileRelCB    (this, SW_RES(CB_FILE_REL)),
	aNetRelCB     (this, SW_RES(CB_NET_REL)),
    aExampleWIN   (this, SW_RES(WIN_EXAMPLE )),
    aExampleDummyWIN(this, SW_RES(WIN_EXAMPLE_DUMMY )),
    aShowExampleCB(this, SW_RES(CB_SHOW_EXAMPLE )),
    aInsertBtn    (this, SW_RES(PB_INSERT)),
    aCloseBtn     (this, SW_RES(PB_CLOSE)),
    aHelpBtn      (this, SW_RES(PB_HELP)),
    aEditBtn      (this, SW_RES(PB_EDIT)),
	aBibBtn		  (this, SW_RES(PB_BIB)),
	aPathBtn	  (this, SW_RES(PB_PATH)),

    sReadonlyPath (SW_RES(ST_READONLY_PATH)),
    pExampleFrame(0),

    pMenu         (new PopupMenu(SW_RES(MNU_EDIT))),
	pGlossaryHdl  (pGlosHdl),

    bResume(sal_False),

    bSelection( pWrtShell->IsSelection() ),
    bReadOnly( sal_False ),
    bIsOld( sal_False ),
    bIsDocReadOnly(sal_False),

    pSh           (pWrtShell)
{
    SvtLinguConfig aLocalLinguConfig;

    // Static-Pointer initialisieren
	if( !::GetCurrGlosGroup() )
		::SetCurrGlosGroup(new String);//(SwGlossaries::GetDefName());

	pMenu->SetActivateHdl(LINK(this,SwGlossaryDlg,EnableHdl));
	pMenu->SetSelectHdl(LINK(this,SwGlossaryDlg,MenuHdl));
	aEditBtn.SetPopupMenu(pMenu);
	aEditBtn.SetSelectHdl(LINK(this,SwGlossaryDlg,EditHdl));
	aPathBtn.SetClickHdl(LINK(this, SwGlossaryDlg, PathHdl));

	aNameED.SetModifyHdl(LINK(this,SwGlossaryDlg,NameModify));
	aShortNameEdit.SetModifyHdl(LINK(this,SwGlossaryDlg,NameModify));

	aCategoryBox.SetDoubleClickHdl(LINK(this,SwGlossaryDlg, NameDoubleClick));
	aCategoryBox.SetSelectHdl(LINK(this,SwGlossaryDlg,GrpSelect));
	aBibBtn.SetClickHdl(LINK(this,SwGlossaryDlg,BibHdl));
	aShowExampleCB.SetClickHdl(LINK(this, SwGlossaryDlg, ShowPreviewHdl));

	aShortNameEdit.SetMaxTextLen(SHORT_LENGTH);
	aNameED.SetMaxTextLen(LONG_LENGTH);
	FreeResource();

	const SvxAutoCorrCfg* pCfg = SvxAutoCorrCfg::Get();

	aShowExampleCB.Check( pCfg->IsAutoTextPreview());
	ShowPreviewHdl(&aShowExampleCB);

	bIsDocReadOnly = pSh->GetView().GetDocShell()->IsReadOnly() ||
					  pSh->HasReadonlySel();
	if( bIsDocReadOnly )
		aInsertBtn.Enable(sal_False);
	aNameED.GrabFocus();
	aCategoryBox.SetHelpId(HID_MD_GLOS_CATEGORY);
	aCategoryBox.SetStyle(aCategoryBox.GetStyle()|WB_HASBUTTONS|WB_HASBUTTONSATROOT|WB_HSCROLL|WB_VSCROLL|WB_CLIPCHILDREN|WB_SORT);
	aCategoryBox.GetModel()->SetSortMode(SortAscending);
	aCategoryBox.SetHighlightRange();	// ueber volle Breite selektieren
	aCategoryBox.SetNodeDefaultImages( );
	aCategoryBox.SetAccessibleName(SW_RES(STR_ACCESS_SW_CATEGORY));
	aCategoryBox.SetAccessibleRelationLabeledBy(&aInsertTipCB);

	Init();
}
/*--------------------------------------------------------------------
	 Beschreibung:
 --------------------------------------------------------------------*/


SwGlossaryDlg::~SwGlossaryDlg()
{
	SvxAutoCorrCfg* pCfg = SvxAutoCorrCfg::Get();
	pCfg->SetAutoTextPreview(aShowExampleCB.IsChecked()) ;

	aCategoryBox.Clear();
	aEditBtn.SetPopupMenu(0);
	delete pMenu;
	delete pExampleFrame;
}
/*------------------------------------------------------------------------
 Beschreibung:	Auswahl neue Gruppe
------------------------------------------------------------------------*/


IMPL_LINK( SwGlossaryDlg, GrpSelect, SvTreeListBox *, pBox )
{
	SvLBoxEntry* pEntry = pBox->FirstSelected();
	if(!pEntry)
		return 0;
	SvLBoxEntry* pParent = pBox->GetParent(pEntry) ? pBox->GetParent(pEntry) : pEntry;
	GroupUserData* pGroupData = (GroupUserData*)pParent->GetUserData();
	String *pGlosGroup = ::GetCurrGlosGroup();
	(*pGlosGroup) = pGroupData->sGroupName;
	(*pGlosGroup) += GLOS_DELIM;
	(*pGlosGroup) += String::CreateFromInt32(pGroupData->nPathIdx);
	pGlossaryHdl->SetCurGroup(*pGlosGroup);
	// Aktuellen Textbaustein setzen
	bReadOnly = pGlossaryHdl->IsReadOnly();
	EnableShortName( !bReadOnly );
	aEditBtn.Enable(!bReadOnly);
	bIsOld = pGlossaryHdl->IsOld();
	if( pParent != pEntry)
	{
		String aName(pBox->GetEntryText(pEntry));
		aNameED.SetText(aName);
		aShortNameEdit.SetText(*(String*)pEntry->GetUserData());
		pEntry = pBox->GetParent(pEntry);
		aInsertBtn.Enable( !bIsDocReadOnly);
		ShowAutoText(*::GetCurrGlosGroup(), aShortNameEdit.GetText());
	}
	else
	{
		aNameED.SetText(aEmptyStr);
		aShortNameEdit.SetText(aEmptyStr);
		aInsertBtn.Enable(sal_False);
		ShowAutoText(aEmptyStr, aEmptyStr);
	}
	//Controls aktualisieren
	NameModify(&aShortNameEdit);
    if( SfxRequest::HasMacroRecorder( pSh->GetView().GetViewFrame() ) )
	{
        SfxRequest aReq( pSh->GetView().GetViewFrame(), FN_SET_ACT_GLOSSARY );
		String sTemp(*::GetCurrGlosGroup());
		// der nullte Pfad wird nicht aufgezeichnet!
        if('0' == sTemp.GetToken(1, GLOS_DELIM).GetChar(0))
			sTemp = sTemp.GetToken(0, GLOS_DELIM);
		aReq.AppendItem(SfxStringItem(FN_SET_ACT_GLOSSARY, sTemp));
		aReq.Done();
	}
	return 0;
}
/*--------------------------------------------------------------------
	 Beschreibung:
 --------------------------------------------------------------------*/


void SwGlossaryDlg::Apply()
{
	const String aGlosName(aShortNameEdit.GetText());
	if(aGlosName.Len())	pGlossaryHdl->InsertGlossary(aGlosName);
    if( SfxRequest::HasMacroRecorder( pSh->GetView().GetViewFrame() ) )
	{
        SfxRequest aReq( pSh->GetView().GetViewFrame(), FN_INSERT_GLOSSARY );
		String sTemp(*::GetCurrGlosGroup());
		// der nullte Pfad wird nicht aufgezeichnet!
        if('0' == sTemp.GetToken(1, GLOS_DELIM).GetChar(0))
			sTemp = sTemp.GetToken(0, GLOS_DELIM);
		aReq.AppendItem(SfxStringItem(FN_INSERT_GLOSSARY, sTemp));
		aReq.AppendItem(SfxStringItem(FN_PARAM_1, aGlosName));
		aReq.Done();
	}
}
/*--------------------------------------------------------------------
	 Beschreibung:
 --------------------------------------------------------------------*/
/* inline */ void SwGlossaryDlg::EnableShortName(sal_Bool bOn)
{
	aShortNameLbl.Enable(bOn);
	aShortNameEdit.Enable(bOn);
}

/* -----------------26.11.98 16:15-------------------
 * existiert der Titel in der ausgewaehlten Gruppe?
 * --------------------------------------------------*/
SvLBoxEntry* SwGlossaryDlg::DoesBlockExist(const String& rBlock,
				const String& rShort)
{
	//evtl. vorhandenen Eintrag in der TreeListBox suchen
	SvLBoxEntry* pEntry = aCategoryBox.FirstSelected();
    if(pEntry)
    {
        if(aCategoryBox.GetParent(pEntry))
            pEntry = aCategoryBox.GetParent(pEntry);
        sal_uInt32 nChildCount = aCategoryBox.GetChildCount( pEntry );
        for(sal_uInt32 i = 0; i < nChildCount; i++)
        {
            SvLBoxEntry* pChild = aCategoryBox.GetEntry( pEntry, i );
            if(rBlock == aCategoryBox.GetEntryText(pChild) &&
                (!rShort.Len() || rShort == *(String*)pChild->GetUserData()))
            {
                return pChild;
            }
        }
    }
	return 0;
}

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


IMPL_LINK( SwGlossaryDlg, NameModify, Edit *, pEdit )
{
	String aName(aNameED.GetText());
	sal_Bool bNameED = pEdit == &aNameED;
	if( !aName.Len() )
	{
		if(bNameED)
			aShortNameEdit.SetText(aName);
		aInsertBtn.Enable(sal_False);
		return 0;
	}
	String sShortSearch;
	if(!bNameED)
		sShortSearch = pEdit->GetText();
	sal_Bool bNotFound = !DoesBlockExist(aName, sShortSearch);
	if(bNameED)
	{
			// ist der Text durch einen Klick in die Listbox in das
			// Edit gekommem?
		if(bNotFound)
		{
            aShortNameEdit.SetText( lcl_GetValidShortCut( aName ) );
			EnableShortName();
		}
		else
		{
			aShortNameEdit.SetText(pGlossaryHdl->GetGlossaryShortName(aName));
			EnableShortName(!bReadOnly);
		}
		aInsertBtn.Enable(!bNotFound && !bIsDocReadOnly);
	}
	else
	{
		//ShortNameEdit
		if(!bNotFound)
		{
			sal_Bool bEnable = !bNotFound;
			bEnable &= !bIsDocReadOnly;
			aInsertBtn.Enable(bEnable);
		}
	}
	return 0;
}
/*--------------------------------------------------------------------
	 Beschreibung:
 --------------------------------------------------------------------*/


IMPL_LINK_INLINE_START( SwGlossaryDlg, NameDoubleClick, SvTreeListBox*, pBox )
{
	SvLBoxEntry* pEntry = pBox->FirstSelected();
	if(pBox->GetParent(pEntry) && !bIsDocReadOnly)
		EndDialog( RET_OK );
	return 0;
}
IMPL_LINK_INLINE_END( SwGlossaryDlg, NameDoubleClick, SvTreeListBox*, EMPTYARG )
/*--------------------------------------------------------------------
	 Beschreibung:
 --------------------------------------------------------------------*/


IMPL_LINK( SwGlossaryDlg, EnableHdl, Menu *, pMn )
{
	const String aEditText(aNameED.GetText());
	const sal_Bool bHasEntry = aEditText.Len() && aShortNameEdit.GetText().Len();
	const sal_Bool bExists = 0 != DoesBlockExist(aEditText, aShortNameEdit.GetText());
	pMn->EnableItem(FN_GL_DEFINE, bSelection && bHasEntry && !bExists);
	pMn->EnableItem(FN_GL_DEFINE_TEXT, bSelection && bHasEntry && !bExists);
	pMn->EnableItem(FN_GL_COPY_TO_CLIPBOARD, bExists);
	pMn->EnableItem(FN_GL_REPLACE, bSelection && bExists && !bIsOld );
	pMn->EnableItem(FN_GL_REPLACE_TEXT, bSelection && bExists && !bIsOld );
	pMn->EnableItem(FN_GL_EDIT, bExists );
    pMn->EnableItem(FN_GL_RENAME, bExists  );
    pMn->EnableItem(FN_GL_DELETE, bExists  );
	pMn->EnableItem(FN_GL_MACRO, bExists && !bIsOld  &&
									!pGlossaryHdl->IsReadOnly() );

	SvLBoxEntry* pEntry = aCategoryBox.FirstSelected();
	sal_Bool bEnable = sal_False;
	if ( pEntry )
		bEnable = !aCategoryBox.GetParent( pEntry ) && !bIsOld && !pGlossaryHdl->IsReadOnly();
	pMn->EnableItem( FN_GL_IMPORT, bEnable );
	return 1;
}
/*--------------------------------------------------------------------
	 Beschreibung:
 --------------------------------------------------------------------*/


IMPL_LINK( SwGlossaryDlg, MenuHdl, Menu *, pMn )
{
	sal_Bool bNoAttr = sal_False;

	switch(pMn->GetCurItemId())
	{
		case FN_GL_REPLACE:
		case FN_GL_REPLACE_TEXT:
			pGlossaryHdl->NewGlossary(	aNameED.GetText(),
										aShortNameEdit.GetText(),
										sal_False,
										pMn->GetCurItemId() == FN_GL_REPLACE_TEXT);
		break;
		case FN_GL_DEFINE_TEXT:
			bNoAttr = sal_True;
			// Kein break!!!
		case FN_GL_DEFINE:
		{
			const String aStr(aNameED.GetText());
			const String aShortName(aShortNameEdit.GetText());
			if(pGlossaryHdl->HasShortName(aShortName))
			{
				InfoBox(this, SW_RES(MSG_DOUBLE_SHORTNAME)).Execute();
				aShortNameEdit.SetSelection(Selection(0, SELECTION_MAX));
				aShortNameEdit.GrabFocus();
				break;
			}
			if(pGlossaryHdl->NewGlossary(aStr, aShortName, sal_False, bNoAttr ))
			{
				SvLBoxEntry* pEntry = aCategoryBox.FirstSelected();
				if(aCategoryBox.GetParent(pEntry))
					pEntry = aCategoryBox.GetParent(pEntry);

				SvLBoxEntry* pChild = aCategoryBox.InsertEntry(aStr, pEntry);
				pChild->SetUserData(new String(aShortName));
				aNameED.SetText(aStr);
				aShortNameEdit.SetText(aShortName);
				NameModify(&aNameED);		// fuer Schalten der Buttons

                if( SfxRequest::HasMacroRecorder( pSh->GetView().GetViewFrame() ) )
				{
                    SfxRequest aReq(pSh->GetView().GetViewFrame(), FN_NEW_GLOSSARY);
					String sTemp(*::GetCurrGlosGroup());
					// der nullte Pfad wird nicht aufgezeichnet!
                    if('0' == sTemp.GetToken(1, GLOS_DELIM).GetChar(0))
						sTemp = sTemp.GetToken(0, GLOS_DELIM);
					aReq.AppendItem(SfxStringItem(FN_NEW_GLOSSARY, sTemp));
					aReq.AppendItem(SfxStringItem(FN_PARAM_1, aShortName));
					aReq.AppendItem(SfxStringItem(FN_PARAM_2, aStr));
					aReq.Done();
				}
			}
		}
		break;
		case FN_GL_COPY_TO_CLIPBOARD :
		{
			pGlossaryHdl->CopyToClipboard(*pSh, aShortNameEdit.GetText());
		}
		break;
		case FN_GL_EDIT:
		break;
		case FN_GL_RENAME:
		{
			aShortNameEdit.SetText(pGlossaryHdl->GetGlossaryShortName(aNameED.GetText()));
			SwNewGlosNameDlg* pNewNameDlg = new SwNewGlosNameDlg(this, aNameED.GetText(),
											aShortNameEdit.GetText() );
			if( RET_OK == pNewNameDlg->Execute() &&
				pGlossaryHdl->Rename( aShortNameEdit.GetText(),
										pNewNameDlg->GetNewShort(),
										pNewNameDlg->GetNewName()))
			{
				SvLBoxEntry* pEntry = aCategoryBox.FirstSelected();
				SvLBoxEntry* pNewEntry = aCategoryBox.InsertEntry(
						pNewNameDlg->GetNewName(), aCategoryBox.GetParent(pEntry));
				pNewEntry->SetUserData(new String(pNewNameDlg->GetNewShort()));
				delete (String*)pEntry->GetUserData();
				aCategoryBox.GetModel()->Remove(pEntry);
				aCategoryBox.Select(pNewEntry);
				aCategoryBox.MakeVisible(pNewEntry);
			}
			GrpSelect( &aCategoryBox );
			delete pNewNameDlg;
		}
		break;
		case FN_GL_DELETE:
		{
			QueryBox aQuery(this, SW_RES(MSG_QUERY_DELETE));
			if(RET_YES == aQuery.Execute())
			{
				const String aShortName(aShortNameEdit.GetText());
				const String aTitle(aNameED.GetText());
				if(aTitle.Len() && pGlossaryHdl->DelGlossary(aShortName))
				{
					SvLBoxEntry* pChild = DoesBlockExist(aTitle, aShortName);
					DBG_ASSERT(pChild, "Eintrag nicht gefunden!");
					SvLBoxEntry* pParent = aCategoryBox.GetParent(pChild);
					aCategoryBox.Select(pParent);

					aCategoryBox.GetModel()->Remove(pChild);
					aNameED.SetText( aEmptyStr );
					NameModify(&aNameED);
				}
			}
		}
		break;
		case FN_GL_MACRO:
		{
			SfxItemSet aSet( pSh->GetAttrPool(), RES_FRMMACRO, RES_FRMMACRO, SID_EVENTCONFIG, SID_EVENTCONFIG, 0 );

            SvxMacro aStart(aEmptyStr, aEmptyStr, STARBASIC);
			SvxMacro aEnd(aEmptyStr, aEmptyStr, STARBASIC);
			pGlossaryHdl->GetMacros(aShortNameEdit.GetText(), aStart, aEnd );

            SvxMacroItem aItem(RES_FRMMACRO);
			if( aStart.GetMacName().Len() )
				aItem.SetMacro( SW_EVENT_START_INS_GLOSSARY, aStart );
			if( aEnd.GetMacName().Len() )
				aItem.SetMacro( SW_EVENT_END_INS_GLOSSARY, aEnd );

			aSet.Put( aItem );
			aSet.Put( SwMacroAssignDlg::AddEvents( MACASSGN_TEXTBAUST ) );

			const SfxPoolItem* pItem;
			SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
			SfxAbstractDialog* pMacroDlg = pFact->CreateSfxDialog( this, aSet,
				pSh->GetView().GetViewFrame()->GetFrame().GetFrameInterface(), SID_EVENTCONFIG );
			if ( pMacroDlg && pMacroDlg->Execute() == RET_OK &&
				SFX_ITEM_SET == pMacroDlg->GetOutputItemSet()->GetItemState( RES_FRMMACRO, sal_False, &pItem ) )
			{
				const SvxMacroTableDtor& rTbl = ((SvxMacroItem*)pItem)->GetMacroTable();
				pGlossaryHdl->SetMacros( aShortNameEdit.GetText(),
											rTbl.Get( SW_EVENT_START_INS_GLOSSARY ),
											rTbl.Get( SW_EVENT_END_INS_GLOSSARY ) );
			}

			delete pMacroDlg;
		}
		break;

		case FN_GL_IMPORT:
		{
			// call the FileOpenDialog do find WinWord - Files with templates
            FileDialogHelper aDlgHelper( TemplateDescription::FILEOPEN_SIMPLE, 0 );
            uno::Reference < XFilePicker > xFP = aDlgHelper.GetFilePicker();

			SvtPathOptions aPathOpt;
            xFP->setDisplayDirectory(aPathOpt.GetWorkPath() );
			String sWW8( C2S( FILTER_WW8 ) );

            uno::Reference<XFilterManager> xFltMgr(xFP, UNO_QUERY);
			SfxFilterMatcher aMatcher( String::CreateFromAscii(SwDocShell::Factory().GetShortName()) );
			SfxFilterMatcherIter aIter( &aMatcher );
            const SfxFilter* pFilter = aIter.First();
			while ( pFilter )
			{
				if( pFilter->GetUserData() == sWW8 )
				{
                    xFltMgr->appendFilter( pFilter->GetUIName(),
                                ((WildCard&)pFilter->GetWildcard()).GetWildCard() );
                    xFltMgr->setCurrentFilter( pFilter->GetUIName() ) ;
                }

				pFilter = aIter.Next();
			}

            if( aDlgHelper.Execute() == ERRCODE_NONE )
			{
                if( pGlossaryHdl->ImportGlossaries( xFP->getFiles().getConstArray()[0] ))
					Init();
				else
				{
					InfoBox(this, SW_RES( MSG_NO_GLOSSARIES )).Execute();
				}
			}
		}
	   	break;

		default:
			return 0;
	}
	return 1;
}
/*--------------------------------------------------------------------
	 Beschreibung:	Dialog Verwaltung Bereiche
 --------------------------------------------------------------------*/


IMPL_LINK( SwGlossaryDlg, BibHdl, Button *, EMPTYARG )
{
	SwGlossaries* pGloss = ::GetGlossaries();
	if( pGloss->IsGlosPathErr() )
		pGloss->ShowError();
	else
	{
		//check if at least one glossary path is write enabled
		SvtPathOptions aPathOpt;
		String sGlosPath( aPathOpt.GetAutoTextPath() );
		sal_uInt16 nPaths = sGlosPath.GetTokenCount(';');
		sal_Bool bIsWritable = sal_False;
		for(sal_uInt16 nPath = 0; nPath < nPaths; nPath++)
		{
            String sPath = URIHelper::SmartRel2Abs(
                INetURLObject(), sGlosPath.GetToken(nPath, ';'),
                URIHelper::GetMaybeFileHdl());
			try
			{
				Content aTestContent( sPath,
							uno::Reference< XCommandEnvironment >());
				Any aAny = aTestContent.getPropertyValue( C2U("IsReadOnly") );
				if(aAny.hasValue())
				{
					bIsWritable = !*(sal_Bool*)aAny.getValue();
				}
			}
            catch(Exception&)
			{}
			if(bIsWritable)
				break;
		}
		if(bIsWritable)
		{

			SwGlossaryGroupDlg *pDlg = new SwGlossaryGroupDlg( this, pGloss->GetPathArray(), pGlossaryHdl );
			if ( RET_OK == pDlg->Execute() )
			{
				Init();
				//if new groups were created - select one of them
				String sNewGroup = pDlg->GetCreatedGroupName();
				SvLBoxEntry* pEntry = aCategoryBox.First();
				while(sNewGroup.Len() && pEntry)
				{
					if(!aCategoryBox.GetParent(pEntry))
					{
						GroupUserData* pGroupData = (GroupUserData*)pEntry->GetUserData();
						String sGroup = pGroupData->sGroupName;
						sGroup += GLOS_DELIM;
						sGroup += String::CreateFromInt32(pGroupData->nPathIdx);
						if(sGroup == sNewGroup)
						{
							aCategoryBox.Select(pEntry);
							aCategoryBox.MakeVisible(pEntry);
							GrpSelect(&aCategoryBox);
							break;
						}
					}
					pEntry = aCategoryBox.Next(pEntry);
				}

			}
			delete pDlg;
		}
		else
		{
			QueryBox aBox(this, WB_YES_NO, sReadonlyPath);
			if(RET_YES == aBox.Execute())
				PathHdl(&aPathBtn);
		}
	}
	return 0;
}

/*------------------------------------------------------------------------
 Beschreibung:	Initialisierung; aus Ctor und nach Bearbeiten Bereiche
------------------------------------------------------------------------*/


void SwGlossaryDlg::Init()
{
	aCategoryBox.SetUpdateMode( sal_False );
	aCategoryBox.Clear();
	// Textbausteinbereiche anzeigen
	const sal_uInt16 nCnt = pGlossaryHdl->GetGroupCnt();
	SvLBoxEntry* pSelEntry = 0;
    const String sSelStr(::GetCurrGlosGroup()->GetToken(0, GLOS_DELIM));
    const sal_uInt16 nSelPath = static_cast< sal_uInt16 >(::GetCurrGlosGroup()->GetToken(1, GLOS_DELIM).ToInt32());
	for(sal_uInt16 nId = 0; nId < nCnt; ++nId )
	{
		String sTitle;
		String sGroupName(pGlossaryHdl->GetGroupName(nId, &sTitle));
        if(!sGroupName.Len())
            continue;
		if(!sTitle.Len())
			sTitle = sGroupName.GetToken( 0, GLOS_DELIM );
		SvLBoxEntry* pEntry = aCategoryBox.InsertEntry( sTitle );
        sal_uInt16 nPath = static_cast< sal_uInt16 >(sGroupName.GetToken( 1, GLOS_DELIM ).ToInt32());

		GroupUserData* pData = new GroupUserData;
		pData->sGroupName = sGroupName.GetToken(0, GLOS_DELIM);
		pData->nPathIdx = nPath;
		pData->bReadonly = pGlossaryHdl->IsReadOnly(&sGroupName);

		pEntry->SetUserData(pData);
		if(sSelStr == pData->sGroupName && nSelPath == nPath)
			pSelEntry = pEntry;

		//Eintraege fuer die Gruppen auffuellen
		{
			pGlossaryHdl->SetCurGroup(sGroupName, sal_False, sal_True);
			const sal_uInt16 nCount = pGlossaryHdl->GetGlossaryCnt();
			for(sal_uInt16 i = 0; i < nCount; ++i)
			{
                String sGroupTitle(pGlossaryHdl->GetGlossaryName(i));
				SvLBoxEntry* pChild = aCategoryBox.InsertEntry(
                                    sGroupTitle, pEntry);
				pChild->SetUserData(new String(pGlossaryHdl->GetGlossaryShortName(i)));
			}
		}
	}
		// Aktuelle Gruppe setzen und Textbausteine anzeigen
	if(!pSelEntry)
	{
		//find a non-readonly group
		SvLBoxEntry* pSearch = aCategoryBox.First();
		while(pSearch)
		{
			if(!aCategoryBox.GetParent(pSearch))
			{
				GroupUserData* pData = (GroupUserData*)pSearch->GetUserData();
				if(!pData->bReadonly)
				{
					pSelEntry = pSearch;
					break;
				}
			}
			pSearch = aCategoryBox.Next(pSearch);
		}
		if(!pSelEntry)
			pSelEntry = aCategoryBox.GetEntry(0);
	}
	if(pSelEntry)
	{
		aCategoryBox.Expand(pSelEntry);
		aCategoryBox.Select(pSelEntry);
		aCategoryBox.MakeVisible(pSelEntry);
		GrpSelect(&aCategoryBox);
	}
	//JP 16.11.99: the SvxTreeListBox has a Bug. The Box dont recalc the
	//		outputsize, when all entries are insertet. The result is, that
	//		the Focus/Highlight rectangle is to large and paintet over the
	//		HScrollbar. -> Fix: call the resize
	aCategoryBox.Resize();

	aCategoryBox.GetModel()->Resort();
	aCategoryBox.SetUpdateMode( sal_True );
	aCategoryBox.Update();

	const SvxAutoCorrCfg* pCfg = SvxAutoCorrCfg::Get();
	aFileRelCB.Check( pCfg->IsSaveRelFile() );
	aFileRelCB.SetClickHdl(LINK(this, SwGlossaryDlg, CheckBoxHdl));
	aNetRelCB.Check( pCfg->IsSaveRelNet() );
	aNetRelCB.SetClickHdl(LINK(this, SwGlossaryDlg, CheckBoxHdl));
	aInsertTipCB.Check( pCfg->IsAutoTextTip() );
	aInsertTipCB.SetClickHdl(LINK(this, SwGlossaryDlg, CheckBoxHdl));
}
/*------------------------------------------------------------------------
 Beschreibung:
------------------------------------------------------------------------*/


IMPL_LINK_INLINE_START( SwGlossaryDlg, EditHdl, Button *, EMPTYARG )
{
//EndDialog darf nicht im MenuHdl aufgerufen werden
	if(aEditBtn.GetCurItemId() == FN_GL_EDIT )
	{
		SwTextBlocks *pGroup = ::GetGlossaries()->GetGroupDoc (  GetCurrGrpName () );
		sal_Bool bRet = pGlossaryHdl->ConvertToNew ( *pGroup );
		delete pGroup;
		if ( bRet )
			EndDialog(RET_EDIT);
	}
	return 0;
}
IMPL_LINK_INLINE_END( SwGlossaryDlg, EditHdl, Button *, EMPTYARG )

/*------------------------------------------------------------------------
 Beschreibung:	KeyInput fuer ShortName - Edits ohne Spaces
------------------------------------------------------------------------*/

IMPL_LINK( SwNewGlosNameDlg, Modify, Edit *, pBox )
{
	String aName(aNewName.GetText());
	SwGlossaryDlg* pDlg = (SwGlossaryDlg*)GetParent();

	if( pBox == &aNewName )
        aNewShort.SetText( lcl_GetValidShortCut( aName ) );

	sal_Bool bEnable = aName.Len() && aNewShort.GetText().Len() &&
		(!pDlg->DoesBlockExist(aName, aNewShort.GetText())
			|| aName == aOldName.GetText());
	aOk.Enable(bEnable);
	return 0;
}
/*------------------------------------------------------------------------
 Beschreibung:
------------------------------------------------------------------------*/

IMPL_LINK( SwNewGlosNameDlg, Rename, Button *, EMPTYARG )
{
	SwGlossaryDlg* pDlg = (SwGlossaryDlg*)GetParent();
	String sNew = aNewShort.GetText();
	GetAppCharClass().toUpper(sNew);
	if( pDlg->pGlossaryHdl->HasShortName(aNewShort.GetText())
		&& sNew != aOldShort.GetText() )
	{
		InfoBox(this, SW_RES(MSG_DOUBLE_SHORTNAME)).Execute();
		aNewShort.GrabFocus();
	}
	else
		EndDialog(sal_True);
	return 0;
}

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

IMPL_LINK( SwGlossaryDlg, CheckBoxHdl, CheckBox *, pBox )
{
	SvxAutoCorrCfg* pCfg = SvxAutoCorrCfg::Get();
	sal_Bool bCheck = pBox->IsChecked();
	if( pBox == &aInsertTipCB )
		pCfg->SetAutoTextTip(bCheck);
	else if(pBox == &aFileRelCB)
		pCfg->SetSaveRelFile(bCheck);
	else
		pCfg->SetSaveRelNet(bCheck);
	return 0;
}

/* -----------------26.11.98 15:18-------------------
 * TreeListBox fuer Gruppen und Bausteine
 * --------------------------------------------------*/
SwGlTreeListBox::SwGlTreeListBox(Window* pParent, const ResId& rResId) :
	SvTreeListBox(pParent, rResId),
	sReadonly	  (SW_RES(ST_READONLY)),
	pDragEntry(0)
{
	FreeResource();
	SetDragDropMode( SV_DRAGDROP_CTRL_MOVE|SV_DRAGDROP_CTRL_COPY );
}
/* -----------------30.11.98 10:49-------------------
 *
 * --------------------------------------------------*/
void SwGlTreeListBox::Clear()
{
	SvLBoxEntry* pEntry = First();
	while(pEntry)
	{
		if(GetParent(pEntry))
			delete (String*)pEntry->GetUserData();
		else
			delete (GroupUserData*)pEntry->GetUserData();
		pEntry = Next(pEntry);
	}
	SvTreeListBox::Clear();
}

/*-----------------10.06.97 14.52-------------------

--------------------------------------------------*/
void SwGlTreeListBox::RequestHelp( const HelpEvent& rHEvt )
{
	Point aPos( ScreenToOutputPixel( rHEvt.GetMousePosPixel() ));
	SvLBoxEntry* pEntry = GetEntry( aPos );
	// Hilfe gibt es nur fuer die Gruppennamen
	if(pEntry)
	{
		SvLBoxTab* pTab;
		SvLBoxItem* pItem = GetItem( pEntry, aPos.X(), &pTab );
		if(pItem)
		{
			aPos = GetEntryPosition( pEntry );
		 	Size aSize(pItem->GetSize( this, pEntry ));
			aPos.X() = GetTabPos( pEntry, pTab );

			if((aPos.X() + aSize.Width()) > GetSizePixel().Width())
				aSize.Width() = GetSizePixel().Width() - aPos.X();
			aPos = OutputToScreenPixel(aPos);
		 	Rectangle aItemRect( aPos, aSize );
			String sMsg;
			if(!GetParent(pEntry))
			{
				GroupUserData* pData = (GroupUserData*)pEntry->GetUserData();
				const SvStrings* pPathArr = ::GetGlossaries()->GetPathArray();
				if(pPathArr->Count())
				{
					sMsg = (*(*pPathArr)[pData->nPathIdx]);
					sMsg += INET_PATH_TOKEN;
					sMsg += pData->sGroupName;
					sMsg += SwGlossaries::GetExtension();
					INetURLObject aTmp(sMsg);
					sMsg = aTmp.GetPath();

					if(pData->bReadonly)
					{
						sMsg += ' ';
						sMsg += '(';
						sMsg += sReadonly;
						sMsg += ')';
					}


				}
			}
			else
				sMsg = *(String*)pEntry->GetUserData();
			Help::ShowQuickHelp( this, aItemRect, sMsg,
						QUICKHELP_LEFT|QUICKHELP_VCENTER );
		}
	}
}
/* -----------------26.11.98 14:42-------------------
 *
 * --------------------------------------------------*/
DragDropMode SwGlTreeListBox::NotifyStartDrag(
                    TransferDataContainer& /*rContainer*/,
					SvLBoxEntry* pEntry )
{
	DragDropMode  eRet;
	pDragEntry = pEntry;
	if(!GetParent(pEntry))
		eRet = SV_DRAGDROP_NONE;
	else
	{
		SwGlossaryDlg* pDlg = (SwGlossaryDlg*)Window::GetParent();
		SvLBoxEntry* pParent = GetParent(pEntry);

		GroupUserData* pGroupData = (GroupUserData*)pParent->GetUserData();
		String sEntry(pGroupData->sGroupName);
		sEntry += GLOS_DELIM;
		sEntry += String::CreateFromInt32(pGroupData->nPathIdx);
        sal_Int8 nDragOption = DND_ACTION_COPY;
		eRet = SV_DRAGDROP_CTRL_COPY;
		if(!pDlg->pGlossaryHdl->IsReadOnly(&sEntry))
		{
			eRet |= SV_DRAGDROP_CTRL_MOVE;
            nDragOption |= DND_ACTION_MOVE;
		}
        SetDragOptions( nDragOption );
	}
	return eRet;
}
/* -----------------27.11.98 09:35-------------------
 *
 * --------------------------------------------------*/
sal_Bool    SwGlTreeListBox::NotifyAcceptDrop( SvLBoxEntry* pEntry)
{
	// TODO: Readonly - Ueberpruefung fehlt noch!
	SvLBoxEntry* pSrcParent = GetParent(pEntry) ? GetParent(pEntry) : pEntry;
	SvLBoxEntry* pDestParent =
		GetParent(pDragEntry ) ? GetParent(pDragEntry ) : pDragEntry ;
	return pDestParent != pSrcParent;

}
/* -----------------26.11.98 14:42-------------------
 *
 * --------------------------------------------------*/
sal_Bool  SwGlTreeListBox::NotifyMoving(   SvLBoxEntry*  pTarget,
									SvLBoxEntry*  pEntry,
                                    SvLBoxEntry*& /*rpNewParent*/,
                                    sal_uLong&        /*rNewChildPos*/
								)
{
	pDragEntry = 0;
	if(!pTarget) //An den Anfang verschieben
	{
		pTarget = GetEntry(0);
	}
	// 1. wird in verschiedene Gruppen verschoben?
	// 2. darf in beiden Gruppen geschrieben werden?
	SvLBoxEntry* pSrcParent = GetParent(pEntry);
	SvLBoxEntry* pDestParent =
		GetParent(pTarget) ? GetParent(pTarget) : pTarget;
	sal_Bool bRet = sal_False;
	if(pDestParent != pSrcParent)
	{
		SwGlossaryDlg* pDlg = (SwGlossaryDlg*)Window::GetParent();
		SwWait aWait( *pDlg->pSh->GetView().GetDocShell(), true );

		GroupUserData* pGroupData = (GroupUserData*)pSrcParent->GetUserData();
		String sSourceGroup(pGroupData->sGroupName);
		sSourceGroup += GLOS_DELIM;
		sSourceGroup += String::CreateFromInt32(pGroupData->nPathIdx);
		pDlg->pGlossaryHdl->SetCurGroup(sSourceGroup);
		String sTitle(GetEntryText(pEntry));
		String sShortName(*(String*)pEntry->GetUserData());

		GroupUserData* pDestData = (GroupUserData*)pDestParent->GetUserData();
		String sDestName = pDestData->sGroupName;
		sDestName += GLOS_DELIM;
		sDestName += String::CreateFromInt32(pDestData->nPathIdx);
		bRet = pDlg->pGlossaryHdl->CopyOrMove( sSourceGroup,  sShortName,
						sDestName, sTitle, sal_True );
		if(bRet)
		{
			SvLBoxEntry* pChild = InsertEntry(sTitle, pDestParent);
			pChild->SetUserData(new String(sShortName));
			GetModel()->Remove(pEntry);
		}
	}
	return sal_False; //sonst wird der Eintrag automatisch vorgenommen
}
/* -----------------26.11.98 14:42-------------------
 *
 * --------------------------------------------------*/
sal_Bool  SwGlTreeListBox::NotifyCopying(   SvLBoxEntry*  pTarget,
									SvLBoxEntry*  pEntry,
                                    SvLBoxEntry*& /*rpNewParent*/,
                                    sal_uLong&        /*rNewChildPos*/
								)
{
	pDragEntry = 0;
	// 1. wird in verschiedene Gruppen verschoben?
	// 2. darf in beiden Gruppen geschrieben werden?
	if(!pTarget) //An den Anfang verschieben
	{
		pTarget = GetEntry(0);
	}
	SvLBoxEntry* pSrcParent = GetParent(pEntry);
	SvLBoxEntry* pDestParent =
		GetParent(pTarget) ? GetParent(pTarget) : pTarget;
	sal_Bool bRet = sal_False;
	if(pDestParent != pSrcParent)
	{
		SwGlossaryDlg* pDlg = (SwGlossaryDlg*)Window::GetParent();
		SwWait aWait( *pDlg->pSh->GetView().GetDocShell(), true );

		GroupUserData* pGroupData = (GroupUserData*)pSrcParent->GetUserData();
		String sSourceGroup(pGroupData->sGroupName);
		sSourceGroup += GLOS_DELIM;
		sSourceGroup += String::CreateFromInt32(pGroupData->nPathIdx);

		pDlg->pGlossaryHdl->SetCurGroup(sSourceGroup);
		String sTitle(GetEntryText(pEntry));
		String sShortName(*(String*)pEntry->GetUserData());

		GroupUserData* pDestData = (GroupUserData*)pDestParent->GetUserData();
		String sDestName = pDestData->sGroupName;
		sDestName += GLOS_DELIM;
		sDestName += String::CreateFromInt32(pDestData->nPathIdx);

		bRet = pDlg->pGlossaryHdl->CopyOrMove( sSourceGroup,  sShortName,
						sDestName, sTitle, sal_False );
		if(bRet)
		{
			SvLBoxEntry* pChild = InsertEntry(sTitle, pDestParent);
			pChild->SetUserData(new String(sShortName));
		}
	}
	return sal_False; //sonst wird der Eintrag automatisch vorgenommen
}


/*-----------------10.06.97 15.18-------------------

--------------------------------------------------*/
String SwGlossaryDlg::GetCurrGrpName() const
{
	SvLBoxEntry* pEntry = aCategoryBox.FirstSelected();
	String sRet;
	if(pEntry)
	{
		pEntry =
			aCategoryBox.GetParent(pEntry) ? aCategoryBox.GetParent(pEntry) : pEntry;
		GroupUserData* pGroupData = (GroupUserData*)pEntry->GetUserData();
		sRet = pGroupData->sGroupName;
		sRet += GLOS_DELIM;
		sRet += String::CreateFromInt32(pGroupData->nPathIdx);
	}
	return sRet;
}

/*-----------------11.06.97 08.17-------------------

--------------------------------------------------*/
IMPL_LINK( SwGlossaryDlg, PathHdl, Button *, pBtn )
{
	SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
	if(pFact)
	{
        AbstractSvxMultiPathDialog* pDlg = pFact->CreateSvxMultiPathDialog( pBtn );
        DBG_ASSERT(pDlg, "Dialogdiet fail!");
		SvtPathOptions aPathOpt;
		String sGlosPath( aPathOpt.GetAutoTextPath() );
		pDlg->SetPath(sGlosPath);
		if(RET_OK == pDlg->Execute())
		{
			String sTmp(pDlg->GetPath());
			if(sTmp != sGlosPath)
			{
				aPathOpt.SetAutoTextPath( sTmp );
				::GetGlossaries()->UpdateGlosPath( sal_True );
				Init();
			}
		}
		delete pDlg;
	}
	return 0;
}
/* -----------------28.07.99 13:48-------------------

 --------------------------------------------------*/
IMPL_LINK( SwGlossaryDlg, ShowPreviewHdl, CheckBox *, pBox )
{
	sal_Bool bCreated = sal_False;
	if(pBox->IsChecked())
	{
		//create example
		if(!pExampleFrame)
		{
			Link aLink(LINK(this, SwGlossaryDlg, PreviewLoadedHdl));
			pExampleFrame = new SwOneExampleFrame( aExampleWIN,
							EX_SHOW_ONLINE_LAYOUT, &aLink );
			bCreated = sal_True;
		}
	}

    sal_Bool bShow = pBox->IsChecked() && !bCreated;
    aExampleWIN.Show( bShow );
    aExampleDummyWIN.Show(!bShow);
	if( ::GetCurrGlosGroup() )
		ShowAutoText(*::GetCurrGlosGroup(), aShortNameEdit.GetText());

	return 0;
};
/* -----------------18.11.99 17:09-------------------

 --------------------------------------------------*/
IMPL_LINK( SwGlossaryDlg, PreviewLoadedHdl,  void *, EMPTYARG )
{
    sal_Bool bShow = aShowExampleCB.IsChecked();
    aExampleWIN.Show( bShow );
    aExampleDummyWIN.Show(!bShow);
    ResumeShowAutoText();
	return 0;
}

/* -----------------28.07.99 16:28-------------------

 --------------------------------------------------*/
void SwGlossaryDlg::ShowAutoText(const String& rGroup, const String& rShortName)
{
	if(aExampleWIN.IsVisible())
	{
		SetResumeData(rGroup, rShortName);
		//try to make an Undo()
		pExampleFrame->ClearDocument( sal_True );
	}
}
/* -----------------------------21.12.00 11:33--------------------------------

 ---------------------------------------------------------------------------*/
void	SwGlossaryDlg::ResumeShowAutoText()
{
	String sGroup, sShortName;
	if(GetResumeData(sGroup, sShortName) && aExampleWIN.IsVisible())
	{
		if(!_xAutoText.is())
		{
			uno::Reference< lang::XMultiServiceFactory >
									xMgr = getProcessServiceFactory();
			//now the AutoText ListBoxes have to be filled

            uno::Reference< uno::XInterface >  xAText = xMgr->createInstance( C2U("com.sun.star.text.AutoTextContainer") );
			_xAutoText = uno::Reference< container::XNameAccess >(xAText, uno::UNO_QUERY);
		}

		uno::Reference< XTextCursor > & xCrsr = pExampleFrame->GetTextCursor();
		if(xCrsr.is())
		{
			if(sShortName.Len())
			{
				uno::Any aGroup = _xAutoText->getByName(sGroup);
                uno::Reference< XAutoTextGroup >  xGroup;
				OUString uShortName(sShortName);
                if((aGroup >>= xGroup) && xGroup->hasByName(uShortName))
				{
					uno::Any aEntry(xGroup->getByName(uShortName));
                    uno::Reference< XAutoTextEntry >  xEntry;
                    aEntry >>= xEntry;
					uno::Reference< XTextRange >  xRange(xCrsr, uno::UNO_QUERY);
					xEntry->applyTo(xRange);
				}
			}
		}
	}
	ResetResumeData();
}