summaryrefslogtreecommitdiff
path: root/sw/source/ui/index/cnttab.cxx
diff options
context:
space:
mode:
Diffstat (limited to 'sw/source/ui/index/cnttab.cxx')
-rw-r--r--sw/source/ui/index/cnttab.cxx4553
1 files changed, 4553 insertions, 0 deletions
diff --git a/sw/source/ui/index/cnttab.cxx b/sw/source/ui/index/cnttab.cxx
new file mode 100644
index 000000000000..905caaf6f0ef
--- /dev/null
+++ b/sw/source/ui/index/cnttab.cxx
@@ -0,0 +1,4553 @@
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2000, 2010 Oracle and/or its affiliates.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org. If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 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;
+ }
+
+ 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;
+ }
+ 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));
+}
+/*-- 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()));
+ }
+
+ 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);
+ 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));
+ }
+ 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);
+ 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));
+ }
+
+ 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 postion 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();
+ }
+ }
+}
+/* -----------------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;
+}
+
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-22 03:11:11 +0000