xref: /trunk/main/sw/source/ui/dialog/swdlgfact.cxx (revision 31949d5fbc6efdf22c453892eb861d254fb3db87)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/

// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sw.hxx"

#ifdef SW_DLLIMPLEMENTATION
#undef SW_DLLIMPLEMENTATION
#endif

#include "swdlgfact.hxx"
#include <svl/style.hxx>
#ifndef _SVX_SVXIDS_HRC
#include <svx/svxids.hrc>
#endif
#include "dialog.hrc"
#include "misc.hrc"
#include "chrdlg.hrc"
#include "fldui.hrc"
#include "table.hrc"
#include "frmui.hrc"
#include "dbui.hrc"
#include "globals.hrc"
#include "fldui.hrc"
#include "envelp.hrc"
#include "dochdl.hrc"
#include <index.hrc>
#include <regionsw.hrc>
#include <fmtui.hrc>

#include <wordcountdialog.hxx>
#include "abstract.hxx" // add for SwInsertAbstractDlg
#include "addrdlg.hxx" // add for SwAddrDlg
#include "ascfldlg.hxx" // add for SwAsciiFilterDlg
#include "bookmark.hxx" //add for SwInsertBookmarkDlg
#include "break.hxx" //add for SwBreakDlg
#include "changedb.hxx" //add for SwChangeDBDlg
#include "chrdlg.hxx" // add for SwCharDlg
#include "convert.hxx" //add for SwConvertTableDlg
#include "cption.hxx" //add for SwCaptionDialog
#include "dbinsdlg.hxx" //add for  SwInsertDBColAutoPilot
#include "docfnote.hxx" //add for SwFootNoteOptionDlg
#include "docstdlg.hxx" //add for SwDocStatPage
#include "DropDownFieldDialog.hxx" //add for DropDownFieldDialog
#include "envlop.hxx" //add for SwEnvDlg
#include "label.hxx" //add for SwLabDlg
#include "drpcps.hxx" //add for SwDropCapsDlg
#include "swuipardlg.hxx" //add for SwParaDlg
#include "pattern.hxx" //add for SwBackgroundDlg
#include "rowht.hxx" //add for SwTableHeightDlg
#include "selglos.hxx" //add for SwSelGlossaryDlg
#include "splittbl.hxx" //add for SwSplitTblDlg
#include "srtdlg.hxx" //add for SwSortDlg
#include "tautofmt.hxx" //add for SwAutoFormatDlg
#include "tblnumfm.hxx" //add for SwNumFmtDlg
#include "uiborder.hxx" //add for SwBorderDlg
#include "wrap.hxx" //add for SwWrapDlg
#include "colwd.hxx" //add for SwTableWidthDlg
#include "tabledlg.hxx" //add for SwTableTabDlg
#include "fldtdlg.hxx" //add for SwFldDlg
#include "fldedt.hxx" //add for SwFldEditDlg
#include "swrenamexnameddlg.hxx" //add for SwRenameXNamedDlg
#include "swmodalredlineacceptdlg.hxx" //add for SwModalRedlineAcceptDlg
#include <frmdlg.hxx> //add for SwFrmDlg
#include <tmpdlg.hxx> //add for SwTemplateDlg
#include <glossary.hxx> //add for SwGlossaryDlg
#include <inpdlg.hxx> //add for SwFldInputDlg
#include <insfnote.hxx> //add for SwInsFootNoteDlg
#include <insrule.hxx> //add for SwInsertGrfRulerDlg
#include <instable.hxx> //add for SwInsTableDlg
#include <javaedit.hxx> //add for SwJavaEditDialog
#include <linenum.hxx> //add for SwLineNumberingDlg
#include <mailmrge.hxx> //add for SwMailMergeDlg, SwMailMergeCreateFromDlg, SwMailMergeFieldConnectionsDlg
#include <mergetbl.hxx> //add for SwMergeTblDlg
#include <multmrk.hxx> //add for SwMultiTOXMarkDlg
#include <num.hxx> //add for SwSvxNumBulletTabDialog
#include <outline.hxx> //add for SwOutlineTabDialog
#include <column.hxx> //add for SwColumnDlg
#include <cnttab.hxx> //add for SwMultiTOXTabDialog
#include <swuicnttab.hxx> //add for SwMultiTOXTabDialog
#include <regionsw.hxx> //add for SwEditRegionDlg, SwInsertSectionTabDialog
#include <optcomp.hxx> //add for SwCompatibilityOptPage
#include <optload.hxx> //add for SwLoadOptPage
#include <optpage.hxx> //add for OptPage
#include <swuiidxmrk.hxx> //add for SwIndexMarkDlg, SwAuthMarkDlg, SwIndexMarkModalDlg, SwAuthMarkModalDlg
#include <svx/dialogs.hrc>
#include <mailmergewizard.hxx>
#include <mailconfigpage.hxx>

using namespace ::com::sun::star;

IMPL_ABSTDLG_BASE(AbstractSwWordCountDialog_Impl);
IMPL_ABSTDLG_BASE(AbstractSwInsertAbstractDlg_Impl);
IMPL_ABSTDLG_BASE(AbstractSfxDialog_Impl);
IMPL_ABSTDLG_BASE(AbstractSwAsciiFilterDlg_Impl);
IMPL_ABSTDLG_BASE(VclAbstractDialog_Impl);
IMPL_ABSTDLG_BASE(AbstractSplitTableDialog_Impl);
IMPL_ABSTDLG_BASE(AbstractSwBreakDlg_Impl); //add for SwBreakDlg
IMPL_ABSTDLG_BASE(AbstractTabDialog_Impl); //add for SwCharDlg, SwFootNoteOptionDlg, SwEnvDlg  SwParaDlg SwTableTabDlg
IMPL_ABSTDLG_BASE(AbstractSwConvertTableDlg_Impl); //add for SwConvertTableDlg
IMPL_ABSTDLG_BASE(AbstractSwInsertDBColAutoPilot_Impl); //add for SwInsertDBColAutoPilot
IMPL_ABSTDLG_BASE(AbstractDropDownFieldDialog_Impl); //add for DropDownFieldDialog
IMPL_ABSTDLG_BASE(AbstractSwLabDlg_Impl);//add for SwLabDlg
IMPL_ABSTDLG_BASE(AbstractSwSelGlossaryDlg_Impl);//add for SwSelGlossaryDlg
IMPL_ABSTDLG_BASE(AbstractSwAutoFormatDlg_Impl); //add for SwAutoFormatDlg
IMPL_ABSTDLG_BASE(AbstractSwFldDlg_Impl); //add for SwFldDlg
IMPL_ABSTDLG_BASE(AbstractSwRenameXNamedDlg_Impl); //add for SwRenameXNamedDlg
IMPL_ABSTDLG_BASE(AbstractSwModalRedlineAcceptDlg_Impl); //add for SwModalRedlineAcceptDlg
IMPL_ABSTDLG_BASE(AbstractGlossaryDlg_Impl);
IMPL_ABSTDLG_BASE(AbstractFldInputDlg_Impl);
IMPL_ABSTDLG_BASE(AbstractInsFootNoteDlg_Impl);
IMPL_ABSTDLG_BASE(AbstractInsertGrfRulerDlg_Impl);
IMPL_ABSTDLG_BASE(AbstractInsTableDlg_Impl);
IMPL_ABSTDLG_BASE(AbstractJavaEditDialog_Impl);
IMPL_ABSTDLG_BASE(AbstractMailMergeDlg_Impl);
IMPL_ABSTDLG_BASE(AbstractMailMergeCreateFromDlg_Impl);
IMPL_ABSTDLG_BASE(AbstractMailMergeFieldConnectionsDlg_Impl);
IMPL_ABSTDLG_BASE(AbstractMultiTOXTabDialog_Impl);
IMPL_ABSTDLG_BASE(AbstractEditRegionDlg_Impl);
IMPL_ABSTDLG_BASE(AbstractInsertSectionTabDialog_Impl);
IMPL_ABSTDLG_BASE(AbstractIndexMarkFloatDlg_Impl);
IMPL_ABSTDLG_BASE(AbstractAuthMarkFloatDlg_Impl);

// AbstractTabDialog_Impl begin
void AbstractTabDialog_Impl::SetCurPageId( sal_uInt16 nId )
{
    pDlg->SetCurPageId( nId );
}

const SfxItemSet* AbstractTabDialog_Impl::GetOutputItemSet() const
{
    return pDlg->GetOutputItemSet();
}

const sal_uInt16* AbstractTabDialog_Impl::GetInputRanges(const SfxItemPool& pItem )
{
    return pDlg->GetInputRanges( pItem );
}

void AbstractTabDialog_Impl::SetInputSet( const SfxItemSet* pInSet )
{
     pDlg->SetInputSet( pInSet );
}
//From class Window.
void AbstractTabDialog_Impl::SetText( const XubString& rStr )
{
    pDlg->SetText( rStr );
}
String AbstractTabDialog_Impl::GetText() const
{
    return pDlg->GetText();
}

//add for AbstractTabDialog_Impl end

void    AbstractSwWordCountDialog_Impl::SetValues(const SwDocStat& rCurrent, const SwDocStat& rDoc)
{
    pDlg->SetValues(rCurrent, rDoc);
}

//add for SwInsertAbstractDlg begin
sal_uInt8 AbstractSwInsertAbstractDlg_Impl::GetLevel() const
{
    return pDlg->GetLevel();
}
sal_uInt8 AbstractSwInsertAbstractDlg_Impl::GetPara() const
{
    return pDlg->GetPara();
}
//add for SwInsertAbstractDlg end

//add for SwAddrDlg, SwDropCapsDlg ,SwBackgroundDlg, SwNumFmtDlg SwBorderDlg SwWrapDlg  SwFldEditDlg begin
const SfxItemSet* AbstractSfxDialog_Impl::GetOutputItemSet() const
{
    return pDlg->GetOutputItemSet();
}

void AbstractSfxDialog_Impl::SetText( const XubString& rStr )
{
    pDlg->SetText( rStr );
}
String AbstractSfxDialog_Impl::GetText() const
{
    return pDlg->GetText();
}

//add for SwAddrDlg, SwDropCapsDlg ,SwBackgroundDlg, SwNumFmtDlg SwBorderDlg SwWrapDlg SwFldEditDlg  end

//add for SwAsciiFilterDlg begin
void AbstractSwAsciiFilterDlg_Impl::FillOptions( SwAsciiOptions& rOptions )
{
    pDlg->FillOptions(rOptions);
}
//add for SwAsciiFilterDlg end

//add for SwSplitTblDlg
sal_uInt16 AbstractSplitTableDialog_Impl::GetSplitMode()
{
    return pDlg->GetSplitMode();
}
//add for SwBreakDlg begin
String AbstractSwBreakDlg_Impl::GetTemplateName()
{
    return pDlg->GetTemplateName();
}

sal_uInt16 AbstractSwBreakDlg_Impl:: GetKind()
{
    return pDlg->GetKind();
}

sal_uInt16 AbstractSwBreakDlg_Impl:: GetPageNumber()
{
    return pDlg->GetPageNumber();
}
//add for SwBreakDlg end

//add for SwConvertTableDlg begin
void AbstractSwConvertTableDlg_Impl::GetValues( sal_Unicode& rDelim,SwInsertTableOptions& rInsTblFlags,
                                                SwTableAutoFmt *& prTAFmt )
{
    pDlg->GetValues(rDelim,rInsTblFlags, prTAFmt);
}
//add for SwConvertTableDlg end

//add for SwInsertDBColAutoPilot begin
void AbstractSwInsertDBColAutoPilot_Impl::DataToDoc( const uno::Sequence< uno::Any >& rSelection,
        uno::Reference< sdbc::XDataSource> rxSource,
        uno::Reference< sdbc::XConnection> xConnection,
        uno::Reference< sdbc::XResultSet > xResultSet)
{
    pDlg->DataToDoc(rSelection, rxSource, xConnection, xResultSet);
}
//add for SwInsertDBColAutoPilot end

// add for DropDownFieldDialog begin
ByteString      AbstractDropDownFieldDialog_Impl::GetWindowState( sal_uLong nMask  ) const
{
    return pDlg->GetWindowState(nMask);
}
void       AbstractDropDownFieldDialog_Impl::SetWindowState( const ByteString& rStr )
{
    pDlg->SetWindowState(rStr);
}
//add for DropDownFieldDialog end

//add for SwLabDlg begin

void AbstractSwLabDlg_Impl::SetCurPageId( sal_uInt16 nId )
{
    pDlg->SetCurPageId( nId );
}

const SfxItemSet* AbstractSwLabDlg_Impl::GetOutputItemSet() const
{
    return pDlg->GetOutputItemSet();
}

const sal_uInt16* AbstractSwLabDlg_Impl::GetInputRanges(const SfxItemPool& pItem )
{
    return pDlg->GetInputRanges( pItem );
}

void AbstractSwLabDlg_Impl::SetInputSet( const SfxItemSet* pInSet )
{
     pDlg->SetInputSet( pInSet );
}

void AbstractSwLabDlg_Impl::SetText( const XubString& rStr )
{
    pDlg->SetText( rStr );
}
String AbstractSwLabDlg_Impl::GetText() const
{
    return pDlg->GetText();
}
const String& AbstractSwLabDlg_Impl::GetBusinessCardStr() const
{
    return pDlg->GetBusinessCardStr();
}
Printer * AbstractSwLabDlg_Impl::GetPrt()
{
    return pDlg->GetPrt();
}
//add for SwLabDlg end


//add for SwSelGlossaryDlg begin

void AbstractSwSelGlossaryDlg_Impl::InsertGlos(const String &rRegion, const String &rGlosName)
{
    pDlg->InsertGlos( rRegion, rGlosName );
}
sal_uInt16 AbstractSwSelGlossaryDlg_Impl::GetSelectedIdx() const
{
    return pDlg->GetSelectedIdx();
}
void AbstractSwSelGlossaryDlg_Impl::SelectEntryPos(sal_uInt16 nIdx)
{
    pDlg->SelectEntryPos( nIdx );
}

//add for SwSelGlossaryDlg end

//add for SwAutoFormatDlg begin

void AbstractSwAutoFormatDlg_Impl::FillAutoFmtOfIndex( SwTableAutoFmt*& rToFill ) const
{
    pDlg->FillAutoFmtOfIndex(rToFill);
}
//add for SwAutoFormatDlg end

//add for SwFldDlg begin
void AbstractSwFldDlg_Impl::SetCurPageId( sal_uInt16 nId )
{
    pDlg->SetCurPageId( nId );
}

const SfxItemSet* AbstractSwFldDlg_Impl::GetOutputItemSet() const
{
    return pDlg->GetOutputItemSet();
}

const sal_uInt16* AbstractSwFldDlg_Impl::GetInputRanges(const SfxItemPool& pItem )
{
    return pDlg->GetInputRanges( pItem );
}

void AbstractSwFldDlg_Impl::SetInputSet( const SfxItemSet* pInSet )
{
     pDlg->SetInputSet( pInSet );
}

void AbstractSwFldDlg_Impl::SetText( const XubString& rStr )
{
    pDlg->SetText( rStr );
}
String AbstractSwFldDlg_Impl::GetText() const
{
    return pDlg->GetText();
}
void AbstractSwFldDlg_Impl::Start( sal_Bool bShowl )
{
    pDlg->Start( bShowl );
}

void AbstractSwFldDlg_Impl::Initialize(SfxChildWinInfo *pInfo)
{
    pDlg->Initialize( pInfo );
}

void AbstractSwFldDlg_Impl::ReInitDlg()
{
    pDlg->ReInitDlg();
}
void AbstractSwFldDlg_Impl::ActivateDatabasePage()
{
    pDlg->ActivateDatabasePage();
}
Window* AbstractSwFldDlg_Impl::GetWindow()
{
    return (Window*)pDlg;
}
void    AbstractSwFldDlg_Impl::ShowPage( sal_uInt16 nId )
{
    pDlg->ShowPage(nId);
}
//add for SwFldD end

//add for SwRenameXNamedDlg begin

void AbstractSwRenameXNamedDlg_Impl::SetForbiddenChars( const String& rSet )
{
    pDlg->SetForbiddenChars( rSet );
}

void    AbstractSwRenameXNamedDlg_Impl::SetAlternativeAccess(
             STAR_REFERENCE( container::XNameAccess ) & xSecond,
             STAR_REFERENCE( container::XNameAccess ) & xThird )
{
    pDlg->SetAlternativeAccess( xSecond, xThird);
}
//add for SwRenameXNamedDlg end

//add for SwModalRedlineAcceptDlg begin

void    AbstractSwModalRedlineAcceptDlg_Impl::AcceptAll( sal_Bool bAccept )
{
    pDlg->AcceptAll( bAccept);
}
//add for SwModalRedlineAcceptDlg end

// AbstractGlossaryDlg_Impl begin
String AbstractGlossaryDlg_Impl::GetCurrGrpName() const
{
    return pDlg->GetCurrGrpName();
}

String AbstractGlossaryDlg_Impl::GetCurrShortName() const
{
    return pDlg->GetCurrShortName();
}
// AbstractGlossaryDlg_Impl end

// AbstractFldInputDlg_Impl begin
void AbstractFldInputDlg_Impl::SetWindowState( const ByteString& rStr )
{
    pDlg->SetWindowState( rStr );
}

ByteString AbstractFldInputDlg_Impl::GetWindowState( sal_uLong nMask ) const
{
    return pDlg->GetWindowState( nMask );
}
// AbstractFldInputDlg_Impl end

// AbstractInsFootNoteDlg_Impl begin
String AbstractInsFootNoteDlg_Impl::GetFontName()
{
    return pDlg->GetFontName();
}
sal_Bool AbstractInsFootNoteDlg_Impl::IsEndNote()
{
    return pDlg->IsEndNote();
}
String AbstractInsFootNoteDlg_Impl::GetStr()
{
    return pDlg->GetStr();
}
void AbstractInsFootNoteDlg_Impl::SetHelpId( const rtl::OString& sHelpId )
{
    pDlg->SetHelpId( sHelpId );
}
void AbstractInsFootNoteDlg_Impl::SetText( const XubString& rStr )
{
    pDlg->SetText( rStr );
}
// AbstractInsFootNoteDlg_Impl end

// AbstractInsertGrfRulerDlg_Impl begin
String AbstractInsertGrfRulerDlg_Impl::GetGraphicName()
{
    return pDlg->GetGraphicName();
}
sal_Bool AbstractInsertGrfRulerDlg_Impl::IsSimpleLine()
{
    return pDlg->IsSimpleLine();
}
sal_Bool AbstractInsertGrfRulerDlg_Impl::HasImages() const
{
    return pDlg->HasImages();
}
// AbstractInsertGrfRulerDlg_Impl end

// AbstractInsTableDlg_Impl begin
void AbstractInsTableDlg_Impl::GetValues( String& rName, sal_uInt16& rRow, sal_uInt16& rCol,
                                SwInsertTableOptions& rInsTblFlags, String& rTableAutoFmtName,
                                SwTableAutoFmt *& prTAFmt )
{
    pDlg->GetValues( rName, rRow, rCol, rInsTblFlags, rTableAutoFmtName, prTAFmt);
}
// AbstractInsTableDlg_Impl end

// AbstractJavaEditDialog_Impl begin
String AbstractJavaEditDialog_Impl::GetText()
{
    return pDlg->GetText();
}
String AbstractJavaEditDialog_Impl::GetType()
{
    return pDlg->GetType();
}
sal_Bool AbstractJavaEditDialog_Impl::IsUrl()
{
    return pDlg->IsUrl();
}
sal_Bool AbstractJavaEditDialog_Impl::IsNew()
{
    return pDlg->IsNew();
}
sal_Bool AbstractJavaEditDialog_Impl::IsUpdate()
{
    return pDlg->IsUpdate();
}
// AbstractJavaEditDialog_Impl end

// AbstractMailMergeDlg_Impl begin
sal_uInt16 AbstractMailMergeDlg_Impl::GetMergeType()
{
    return pDlg->GetMergeType();
}
const ::rtl::OUString& AbstractMailMergeDlg_Impl::GetSaveFilter() const
{
    return pDlg->GetSaveFilter();
}

const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any > AbstractMailMergeDlg_Impl::GetSelection() const
{
    return pDlg->GetSelection();
}
uno::Reference< sdbc::XResultSet> AbstractMailMergeDlg_Impl::GetResultSet() const
{
    return pDlg->GetResultSet();
}
bool AbstractMailMergeDlg_Impl::IsSaveIndividualDocs() const
{
    return pDlg->IsSaveIndividualDocs();
}
bool AbstractMailMergeDlg_Impl::IsGenerateFromDataBase() const
{
    return pDlg->IsGenerateFromDataBase();
}
String AbstractMailMergeDlg_Impl::GetColumnName() const
{
    return pDlg->GetColumnName();
}
String AbstractMailMergeDlg_Impl::GetPath() const
{
    return pDlg->GetPath();
}

// AbstractMailMergeDlg_Impl end
// AbstractMailMergeCreateFromDlg_Impl begin
sal_Bool AbstractMailMergeCreateFromDlg_Impl::IsThisDocument() const
{
    return pDlg->IsThisDocument();
}
// AbstractMailMergeCreateFromDlg_Impl end
//AbstractMailMergeFieldConnectionsDlg_Impl begin
sal_Bool AbstractMailMergeFieldConnectionsDlg_Impl::IsUseExistingConnections() const
{
    return pDlg->IsUseExistingConnections();
}
// AbstractMailMergeFieldConnectionsDlg_Impl end

// AbstractMultiTOXTabDialog_Impl begin
SwForm* AbstractMultiTOXTabDialog_Impl::GetForm(CurTOXType eType)
{
    return pDlg->GetForm(eType);
}
CurTOXType AbstractMultiTOXTabDialog_Impl::GetCurrentTOXType() const
{
    return pDlg->GetCurrentTOXType();
}
SwTOXDescription& AbstractMultiTOXTabDialog_Impl::GetTOXDescription(CurTOXType eTOXTypes)
{
    return pDlg->GetTOXDescription(eTOXTypes);
}
const SfxItemSet* AbstractMultiTOXTabDialog_Impl::GetOutputItemSet() const
{
    return pDlg->GetOutputItemSet();
}
// AbstractMultiTOXTabDialog_Impl end

// AbstractEditRegionDlg_Impl begin
void AbstractEditRegionDlg_Impl::SelectSection(const String& rSectionName)
{
    pDlg->SelectSection(rSectionName);
}
// AbstractEditRegionDlg_Impl end
//AbstractInsertSectionTabDialog_Impl begin
void
AbstractInsertSectionTabDialog_Impl::SetSectionData(SwSectionData const& rSect)
{
    pDlg->SetSectionData(rSect);
}
// AbstractInsertSectionTabDialog_Impl end

//AbstractIndexMarkFloatDlg_Impl begin
void AbstractIndexMarkFloatDlg_Impl::ReInitDlg(SwWrtShell& rWrtShell)
{
    pDlg->ReInitDlg( rWrtShell);
}
Window* AbstractIndexMarkFloatDlg_Impl::GetWindow()
{
    return (Window*)pDlg;
}
// AbstractIndexMarkFloatDlg_Impl end

//AbstractAuthMarkFloatDlg_Impl begin
void AbstractAuthMarkFloatDlg_Impl::ReInitDlg(SwWrtShell& rWrtShell)
{
    pDlg->ReInitDlg( rWrtShell);
}
Window* AbstractAuthMarkFloatDlg_Impl::GetWindow()
{
    return (Window*)pDlg;
}
// AbstractAuthMarkFloatDlg_Impl end

AbstractMailMergeWizard_Impl::~AbstractMailMergeWizard_Impl()
{
    delete pDlg;
}

void AbstractMailMergeWizard_Impl::StartExecuteModal( const Link& rEndDialogHdl )
{
    aEndDlgHdl = rEndDialogHdl;
    pDlg->StartExecuteModal(
        LINK( this, AbstractMailMergeWizard_Impl, EndDialogHdl ) );
}

long AbstractMailMergeWizard_Impl::GetResult()
{
    return pDlg->GetResult();
}

#ifdef DBG_UTIL
IMPL_LINK( AbstractMailMergeWizard_Impl, EndDialogHdl, SwMailMergeWizard*, pDialog )
#else
IMPL_LINK( AbstractMailMergeWizard_Impl, EndDialogHdl, SwMailMergeWizard*, EMPTYARG )
#endif
{
    DBG_ASSERT( pDialog == pDlg, "wrong dialog passed to EndDialogHdl!" );

    aEndDlgHdl.Call( this );
    aEndDlgHdl = Link();

    return 0L;
}

void AbstractMailMergeWizard_Impl::SetReloadDocument(const String& rURL)
{
    pDlg->SetReloadDocument(rURL);
}
const String&       AbstractMailMergeWizard_Impl::GetReloadDocument() const
{
    return pDlg->GetReloadDocument();
}
sal_Bool AbstractMailMergeWizard_Impl::ShowPage( sal_uInt16 nLevel )
{
    return pDlg->skipUntil(nLevel);
}
sal_uInt16 AbstractMailMergeWizard_Impl::GetRestartPage() const
{
    return pDlg->GetRestartPage();
}

//-------------- SwAbstractDialogFactory implementation--------------

AbstractSwWordCountDialog* SwAbstractDialogFactory_Impl::CreateSwWordCountDialog(Window* pParent)
{
    SwWordCountDialog* pDlg = new SwWordCountDialog( pParent );
    return new AbstractSwWordCountDialog_Impl( pDlg );
}

//add for SwInsertAbstractDlg begin
AbstractSwInsertAbstractDlg * SwAbstractDialogFactory_Impl::CreateSwInsertAbstractDlg( Window* pParent,
                                                                                      int nResId )
{
    SwInsertAbstractDlg* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_INSERT_ABSTRACT :
            pDlg = new SwInsertAbstractDlg( pParent);
            break;
        default:
            break;
    }

    if ( pDlg )
        return new AbstractSwInsertAbstractDlg_Impl( pDlg );
    return 0;
}
//add for SwInsertAbstractDlg end

SfxAbstractDialog* SwAbstractDialogFactory_Impl::CreateSfxDialog( Window* pParent,
                                                                        const SfxItemSet& rSet,
                                    const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame >&,
                                                                        sal_uInt32 nResId
                                                                )
{
    SfxModalDialog* pDlg=NULL;
    switch ( nResId )
    {
        case RC_DLG_ADDR :
            pDlg = new SwAddrDlg( pParent, rSet );
            break;
        case DLG_SWDROPCAPS :
            pDlg = new SwDropCapsDlg( pParent, rSet );
            break;
        case RC_SWDLG_BACKGROUND :
            pDlg = new SwBackgroundDlg( pParent, rSet );
            break;
        case RC_DLG_SWNUMFMTDLG :
            pDlg = new SwNumFmtDlg( pParent, rSet );
            break;
        default:
            break;
    }

    if ( pDlg )
        return new AbstractSfxDialog_Impl( pDlg );
    return 0;
}

// add for SwAsciiFilterDlg begin
AbstractSwAsciiFilterDlg* SwAbstractDialogFactory_Impl::CreateSwAsciiFilterDlg( Window* pParent,
                                                                               SwDocShell& rDocSh,
                                                                                SvStream* pStream,
                                                                                int nResId )
{
    SwAsciiFilterDlg* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_ASCII_FILTER :
            pDlg = new SwAsciiFilterDlg( pParent, rDocSh, pStream );
            break;

        default:
            break;
    }

    if ( pDlg )
        return new AbstractSwAsciiFilterDlg_Impl( pDlg );
    return 0;
}

//add for SwAsciiFilterDlg end

// add for SwInsertBookmarkDlg begin
VclAbstractDialog* SwAbstractDialogFactory_Impl::CreateSwInsertBookmarkDlg( Window *pParent,
                                                                           SwWrtShell &rSh,
                                                                           SfxRequest& rReq,
                                                                           int nResId )
{
    Dialog* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_INSERT_BOOKMARK :
            pDlg = new SwInsertBookmarkDlg( pParent, rSh, rReq );
            break;

        default:
            break;
    }

    if ( pDlg )
        return new VclAbstractDialog_Impl( pDlg );
    return 0;
}

//add for SwInsertBookmarkDlg end

//add for SwBreakDlg begin

AbstractSwBreakDlg * SwAbstractDialogFactory_Impl::CreateSwBreakDlg ( Window *pParent,
                                                                     SwWrtShell &rSh,
                                                                     int nResId )
{
    SwBreakDlg* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_BREAK :
            pDlg = new SwBreakDlg( pParent, rSh );
            break;

        default:
            break;
    }

    if ( pDlg )
        return new AbstractSwBreakDlg_Impl( pDlg );
    return 0;
}
//add for SwBreakDlg end

// add for SwChangeDBDlg begin
VclAbstractDialog   * SwAbstractDialogFactory_Impl::CreateSwChangeDBDlg( SwView& rVw, int nResId  )
{
    Dialog* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_CHANGE_DB :
            pDlg = new SwChangeDBDlg( rVw );
            break;

        default:
            break;
    }

    if ( pDlg )
        return new VclAbstractDialog_Impl( pDlg );
    return 0;
}

// add for SwChangeDBDlg end

// add for SwCharDlg begin
SfxAbstractTabDialog *  SwAbstractDialogFactory_Impl::CreateSwCharDlg(Window* pParent, SwView& pVw, const SfxItemSet& rCoreSet, int nResId, // add for SwCharDlg
                                                const String* pFmtStr , sal_Bool bIsDrwTxtDlg )
{

    SfxTabDialog* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_CHAR :
            pDlg = new SwCharDlg( pParent, pVw, rCoreSet, pFmtStr, bIsDrwTxtDlg );
            break;
        default:
            break;
    }

    if ( pDlg )
        return new AbstractTabDialog_Impl( pDlg );
    return 0;

}
// add for SwCharDlg end

//add for SwConvertTableDlg begin
AbstractSwConvertTableDlg* SwAbstractDialogFactory_Impl::CreateSwConvertTableDlg (
                                    SwView& rView,int nResId, bool bToTable )
{
    SwConvertTableDlg* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_CONV_TEXT_TABLE :
            pDlg = new SwConvertTableDlg( rView, bToTable );
            break;
        default:
            break;
    }

    if ( pDlg )
        return new AbstractSwConvertTableDlg_Impl( pDlg );
    return 0;
}

//add for  SwConvertTableDlg end

//add for SwCaptionDialog begin
VclAbstractDialog * SwAbstractDialogFactory_Impl::CreateSwCaptionDialog ( Window *pParent, SwView &rV,int nResId)
{
    Dialog* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_CAPTION :
            pDlg = new SwCaptionDialog( pParent, rV );
            break;

        default:
            break;
    }

    if ( pDlg )
        return new VclAbstractDialog_Impl( pDlg );
    return 0;
}
//add for SwCaptionDialog end

//add for  SwInsertDBColAutoPilot begin

AbstractSwInsertDBColAutoPilot* SwAbstractDialogFactory_Impl::CreateSwInsertDBColAutoPilot( SwView& rView, // add for SwInsertDBColAutoPilot
        uno::Reference< sdbc::XDataSource> rxSource,
        uno::Reference<sdbcx::XColumnsSupplier> xColSupp,
        const SwDBData& rData,  int nResId)
{
    SwInsertDBColAutoPilot* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_AP_INSERT_DB_SEL :
            pDlg = new SwInsertDBColAutoPilot( rView, rxSource, xColSupp, rData );
            break;

        default:
            break;
    }

    if ( pDlg )
        return new AbstractSwInsertDBColAutoPilot_Impl( pDlg );
    return 0;
}
//add for  SwInsertDBColAutoPilot end
//add for  SwFootNoteOptionDlg begin
SfxAbstractTabDialog *  SwAbstractDialogFactory_Impl::CreateSwFootNoteOptionDlg( Window *pParent, SwWrtShell &rSh,int nResId)
{
    SfxTabDialog* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_DOC_FOOTNOTE :
            pDlg = new SwFootNoteOptionDlg( pParent, rSh );
            break;

        default:
            break;
    }

    if ( pDlg )
        return new AbstractTabDialog_Impl( pDlg );
    return 0;
}
//add for  SwFootNoteOptionDlg begin


//add for DropDownFieldDialog begin

AbstractDropDownFieldDialog *  SwAbstractDialogFactory_Impl::CreateDropDownFieldDialog ( Window *pParent, SwWrtShell &rSh, //add for DropDownFieldDialog
                                SwField* pField,int nResId, sal_Bool bNextButton )
{
    sw::DropDownFieldDialog* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_FLD_DROPDOWN :
            pDlg = new sw::DropDownFieldDialog( pParent, rSh, pField, bNextButton );
            break;

        default:
            break;
    }

    if ( pDlg )
        return new AbstractDropDownFieldDialog_Impl( pDlg );
    return 0;
}
//add for DropDownFieldDialog end

//add for SwEnvDlg begin
SfxAbstractTabDialog* SwAbstractDialogFactory_Impl::CreateSwEnvDlg ( Window* pParent, const SfxItemSet& rSet,
                                                                 SwWrtShell* pWrtSh, Printer* pPrt,
                                                                 sal_Bool bInsert,int nResId ) //add for SwEnvDlg
{
    SfxTabDialog* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_ENV :
            pDlg = new SwEnvDlg( pParent, rSet, pWrtSh,pPrt, bInsert  );
            break;

        default:
            break;
    }

    if ( pDlg )
        return new AbstractTabDialog_Impl( pDlg );
    return 0;
}
//add for SwEnvDlg end

//add for SwLabDlg begin

AbstractSwLabDlg* SwAbstractDialogFactory_Impl::CreateSwLabDlg ( Window* pParent, const SfxItemSet& rSet, //add for SwLabDlg
                                                    SwNewDBMgr* pNewDBMgr, sal_Bool bLabel,int nResId  )
{
    SwLabDlg* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_LAB :
            pDlg = new SwLabDlg( pParent, rSet, pNewDBMgr,bLabel  );
            break;

        default:
            break;
    }

    if ( pDlg )
        return new AbstractSwLabDlg_Impl( pDlg );
    return 0;
}

SwLabDlgMethod SwAbstractDialogFactory_Impl::GetSwLabDlgStaticMethod ()
{
    return SwLabDlg::UpdateFieldInformation;
}

//add for SwLabDlg end

//add for SwParaDlg begin
SfxAbstractTabDialog* SwAbstractDialogFactory_Impl::CreateSwParaDlg ( Window *pParent, SwView& rVw,
                                                    const SfxItemSet& rCoreSet  ,
                                                    sal_uInt8 nDialogMode,
                                                    int nResId,
                                                    const String *pCollName,
                                                    sal_Bool bDraw , sal_uInt16 nDefPage)
{
    SfxTabDialog* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_DRAWPARA :
        case DLG_PARA :
            pDlg = new SwParaDlg( pParent, rVw, rCoreSet,nDialogMode, pCollName, bDraw, nDefPage );
            break;

        default:
            break;
    }

    if ( pDlg )
        return new AbstractTabDialog_Impl( pDlg );
    return 0;
}
//add for SwParaDlg end

//add for SwTableHeightDlg SwSortDlg   begin
VclAbstractDialog * SwAbstractDialogFactory_Impl::CreateVclAbstractDialog ( Window *pParent, SwWrtShell &rSh, int nResId )
{
    Dialog* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_ROW_HEIGHT :
            pDlg = new SwTableHeightDlg( pParent, rSh);
            break;

        case DLG_SORTING :
            pDlg = new SwSortDlg( pParent, rSh);
            break;
        case DLG_COLUMN :
            pDlg = new SwColumnDlg( pParent, rSh );
            break;
        case DLG_EDIT_AUTHMARK :
            pDlg = new SwAuthMarkModalDlg( pParent, rSh );
            break;
        default:
            break;
    }

    if ( pDlg )
        return new VclAbstractDialog_Impl( pDlg );
    return 0;
}
//add for SwTableHeightDlg SwSortDlg ,end
//add for SwSplitTblDlg  begin
AbstractSplitTableDialog * SwAbstractDialogFactory_Impl::CreateSplitTblDialog ( Window *pParent, SwWrtShell &rSh )
{
    return new AbstractSplitTableDialog_Impl( new SwSplitTblDlg( pParent, rSh) );
}
//add SwSplitTblDlg end

//add for SwSelGlossaryDlg begin
AbstractSwSelGlossaryDlg * SwAbstractDialogFactory_Impl::CreateSwSelGlossaryDlg ( Window * pParent, const String &rShortName, int nResId )
{
    SwSelGlossaryDlg* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_SEL_GLOS :
            pDlg = new SwSelGlossaryDlg( pParent, rShortName);
            break;

        default:
            break;
    }

    if ( pDlg )
        return new AbstractSwSelGlossaryDlg_Impl( pDlg );
    return 0;
}

//add for SwSelGlossaryDlg end

//add for SwAutoFormatDlg begin
AbstractSwAutoFormatDlg * SwAbstractDialogFactory_Impl::CreateSwAutoFormatDlg( Window* pParent, SwWrtShell* pShell,
                                                                                    int nResId,
                                                                                    sal_Bool bSetAutoFmt,
                                                                                    const SwTableAutoFmt* pSelFmt )
{
    SwAutoFormatDlg* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_AUTOFMT_TABLE :
            pDlg = new SwAutoFormatDlg( pParent, pShell,bSetAutoFmt,pSelFmt);
            break;

        default:
            break;
    }

    if ( pDlg )
        return new AbstractSwAutoFormatDlg_Impl( pDlg );
    return 0;
}
//add for SwAutoFormatDlg end

//add for SwBorderDlg begin
SfxAbstractDialog * SwAbstractDialogFactory_Impl::CreateSwBorderDlg (Window* pParent, SfxItemSet& rSet, sal_uInt16 nType,int nResId )
{
    SfxModalDialog* pDlg=NULL;
    switch ( nResId )
    {
        case RC_DLG_SWBORDERDLG :
            pDlg = new SwBorderDlg( pParent, rSet, nType );
            break;
        default:
            break;
    }

    if ( pDlg )
        return new AbstractSfxDialog_Impl( pDlg );
    return 0;
}
//add for SwBorderDlg end

//add for SwWrapDlg begin
SfxAbstractDialog* SwAbstractDialogFactory_Impl::CreateSwWrapDlg ( Window* pParent, SfxItemSet& rSet, SwWrtShell* pSh, sal_Bool bDrawMode, int nResId )
{
    SfxModalDialog* pDlg=NULL;
    switch ( nResId )
    {
        case RC_DLG_SWWRAPDLG :
            pDlg = new SwWrapDlg( pParent, rSet, pSh, bDrawMode );
            break;
        default:
            break;
    }

    if ( pDlg )
        return new AbstractSfxDialog_Impl( pDlg );
    return 0;
}
//add for SwWrapDlg end

//add for SwTableWidthDlg begin
VclAbstractDialog * SwAbstractDialogFactory_Impl::CreateSwTableWidthDlg ( Window *pParent, SwTableFUNC &rFnc , int nResId )
{
    Dialog* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_COL_WIDTH :
            pDlg = new SwTableWidthDlg( pParent, rFnc);
            break;

        default:
            break;
    }

    if ( pDlg )
        return new VclAbstractDialog_Impl( pDlg );
    return 0;
}
//add for SwTableWidthDlg end

 //add for SwTableTabDlg begin
SfxAbstractTabDialog* SwAbstractDialogFactory_Impl::CreateSwTableTabDlg( Window* pParent, SfxItemPool& Pool,
                                                        const SfxItemSet* pItemSet, SwWrtShell* pSh,int nResId )
{
    SfxTabDialog* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_FORMAT_TABLE :
            pDlg = new SwTableTabDlg( pParent, Pool, pItemSet,pSh );
            break;

        default:
            break;
    }

    if ( pDlg )
        return new AbstractTabDialog_Impl( pDlg );
    return 0;
}
 //add for SwTableTabDlg end

//add for SwFldDlg begin
AbstractSwFldDlg * SwAbstractDialogFactory_Impl::CreateSwFldDlg ( SfxBindings* pB, SwChildWinWrapper* pCW, Window *pParent, int nResId )
{
    SwFldDlg* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_FLD_INSERT :
            pDlg = new SwFldDlg( pB, pCW,pParent);
            break;

        default:
            break;
    }

    if ( pDlg )
        return new AbstractSwFldDlg_Impl( pDlg );
    return 0;
}
//add for SwFldDlg end

//add for SwFldEditDlg begin
SfxAbstractDialog*   SwAbstractDialogFactory_Impl::CreateSwFldEditDlg ( SwView& rVw, int nResId )
{
    SfxModalDialog* pDlg=NULL;
    switch ( nResId )
    {
        case RC_DLG_SWFLDEDITDLG :
            pDlg = new SwFldEditDlg( rVw );
            break;
        default:
            break;
    }

    if ( pDlg )
        return new AbstractSfxDialog_Impl( pDlg );
    return 0;
}
//add for SwFldEditDlg

//add for SwRenameXNamedDlg begin
AbstractSwRenameXNamedDlg * SwAbstractDialogFactory_Impl::CreateSwRenameXNamedDlg( Window* pParent,
                                                                STAR_REFERENCE( container::XNamed ) & xNamed,
                                                                STAR_REFERENCE( container::XNameAccess ) & xNameAccess,int nResId )
{
    SwRenameXNamedDlg* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_RENAME_XNAMED :
            pDlg = new SwRenameXNamedDlg( pParent,xNamed, xNameAccess);
            break;
        default:
            break;
    }

    if ( pDlg )
        return new AbstractSwRenameXNamedDlg_Impl( pDlg );
    return 0;
}

//add for SwRenameXNamedDlg end

//add for SwModalRedlineAcceptDlg begin
AbstractSwModalRedlineAcceptDlg * SwAbstractDialogFactory_Impl::CreateSwModalRedlineAcceptDlg ( Window *pParent, int nResId )
{
    SwModalRedlineAcceptDlg* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_MOD_REDLINE_ACCEPT :
            pDlg = new SwModalRedlineAcceptDlg( pParent );
            break;
        default:
            break;
    }

    if ( pDlg )
        return new AbstractSwModalRedlineAcceptDlg_Impl( pDlg );
    return 0;
}
//add for SwModalRedlineAcceptDlg end

VclAbstractDialog * SwAbstractDialogFactory_Impl::CreateSwVclDialog( int nResId,
                                                Window* pParent, sal_Bool& rWithPrev ) //add for SwMergeTblDlg
{
    Dialog* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_MERGE_TABLE :
            pDlg = new SwMergeTblDlg( pParent, rWithPrev );
            break;
        default:
            break;
    }
    if ( pDlg )
        return new VclAbstractDialog_Impl( pDlg );
    return 0;
}
SfxAbstractTabDialog* SwAbstractDialogFactory_Impl::CreateFrmTabDialog( int nResId,
                                                SfxViewFrame *pFrame, Window *pParent,
                                                const SfxItemSet& rCoreSet,
                                                sal_Bool            bNewFrm,
                                                sal_uInt16          nResType,
                                                sal_Bool            bFmt,
                                                sal_uInt16          nDefPage,
                                                const String*   pFmtStr ) //add for SwFrmDlg
{
    SfxTabDialog* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_FRM_GRF :
        case DLG_FRM_OLE :
        case DLG_FRM_STD :
            pDlg = new SwFrmDlg( pFrame, pParent, rCoreSet, bNewFrm, nResType, bFmt, nDefPage, pFmtStr );
            break;
        default:
            break;
    }

    if ( pDlg )
        return new AbstractTabDialog_Impl( pDlg );
    return 0;
}

SfxAbstractTabDialog* SwAbstractDialogFactory_Impl::CreateTemplateDialog( int nResId,
                                                Window*             pParent,
                                                SfxStyleSheetBase&  rBase,
                                                sal_uInt16              nRegion,
                                                const sal_uInt16 nSlot,
                                                SwWrtShell*         pActShell,
                                                sal_Bool                bNew ) //add for SwTemplateDlg
{
    SfxTabDialog* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_TEMPLATE_BASE :
            pDlg = new SwTemplateDlg( pParent, rBase, nRegion, nSlot, pActShell, bNew );
            break;
        default:
            break;
    }

    if ( pDlg )
        return new AbstractTabDialog_Impl( pDlg );
    return 0;
}

AbstractGlossaryDlg* SwAbstractDialogFactory_Impl::CreateGlossaryDlg( int nResId,
                                                SfxViewFrame* pViewFrame,
                                                SwGlossaryHdl* pGlosHdl,
                                                SwWrtShell *pWrtShell) //add for SwGlossaryDlg
{
    SwGlossaryDlg* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_RENAME_GLOS :
            pDlg = new SwGlossaryDlg( pViewFrame, pGlosHdl, pWrtShell );
            break;
        default:
            break;
    }
    if ( pDlg )
        return new AbstractGlossaryDlg_Impl( pDlg );
    return 0;
}

AbstractFldInputDlg* SwAbstractDialogFactory_Impl::CreateFldInputDlg( int nResId,
                                                Window *pParent, SwWrtShell &rSh,
                                                SwField* pField, sal_Bool bNextButton ) //add for SwFldInputDlg
{
    SwFldInputDlg* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_FLD_INPUT :
            pDlg = new SwFldInputDlg( pParent, rSh, pField, bNextButton );
            break;
        default:
            break;
    }
    if ( pDlg )
        return new AbstractFldInputDlg_Impl( pDlg );
    return 0;
}

AbstractInsFootNoteDlg* SwAbstractDialogFactory_Impl::CreateInsFootNoteDlg( int nResId,
                                                Window * pParent, SwWrtShell &rSh, sal_Bool bEd ) //add for SwInsFootNoteDlg
{
    SwInsFootNoteDlg* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_INS_FOOTNOTE :
            pDlg = new SwInsFootNoteDlg( pParent, rSh, bEd );
            break;
        default:
            break;
    }
    if ( pDlg )
        return new AbstractInsFootNoteDlg_Impl( pDlg );
    return 0;
}

VclAbstractDialog * SwAbstractDialogFactory_Impl::CreateVclSwViewDialog( int nResId,
                                            SwView& rView, sal_Bool /*bCol*/ ) //add for SwInsRowColDlg, SwLineNumberingDlg
{
    Dialog* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_LINE_NUMBERING :
            pDlg = new SwLineNumberingDlg( &rView );
            break;
        default:
            break;
    }

    if ( pDlg )
        return new VclAbstractDialog_Impl( pDlg );
    return 0;
}

AbstractInsertGrfRulerDlg * SwAbstractDialogFactory_Impl::CreateInsertGrfRulerDlg( int nResId,
                                            Window * pParent ) //add for SwInsertGrfRulerDlg
{
    SwInsertGrfRulerDlg* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_INSERT_RULER :
            pDlg = new SwInsertGrfRulerDlg( pParent );
            break;
        default:
            break;
    }

    if ( pDlg )
        return new AbstractInsertGrfRulerDlg_Impl( pDlg );
    return 0;
}

AbstractInsTableDlg * SwAbstractDialogFactory_Impl::CreateInsTableDlg( int nResId,
                                            SwView& rView ) //add for SwInsTableDlg
{
    SwInsTableDlg* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_INSERT_TABLE :
            pDlg = new SwInsTableDlg( rView );
            break;
        default:
            break;
    }
    if ( pDlg )
        return new AbstractInsTableDlg_Impl( pDlg );
    return 0;
}

AbstractJavaEditDialog * SwAbstractDialogFactory_Impl::CreateJavaEditDialog( int nResId,
                                                Window* pParent, SwWrtShell* pWrtSh ) //add for SwJavaEditDialog
{
    SwJavaEditDialog* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_JAVAEDIT :
            pDlg = new SwJavaEditDialog( pParent, pWrtSh );
            break;
        default:
            break;
    }
    if ( pDlg )
        return new AbstractJavaEditDialog_Impl( pDlg );
    return 0;
}

AbstractMailMergeDlg * SwAbstractDialogFactory_Impl::CreateMailMergeDlg( int nResId,
                                                Window* pParent, SwWrtShell& rSh,
                                                const String& rSourceName,
                                                const String& rTblName,
                                                sal_Int32 nCommandType,
                                                const uno::Reference< sdbc::XConnection>& xConnection,
                                                uno::Sequence< uno::Any >* pSelection ) //add for SwMailMergeDlg
{
    SwMailMergeDlg* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_MAILMERGE :
            pDlg = new SwMailMergeDlg( pParent, rSh, rSourceName, rTblName, nCommandType, xConnection, pSelection );
            break;
        default:
            break;
    }
    if ( pDlg )
        return new AbstractMailMergeDlg_Impl( pDlg );
    return 0;
}
AbstractMailMergeCreateFromDlg * SwAbstractDialogFactory_Impl::CreateMailMergeCreateFromDlg( int nResId,
                                                                    Window* pParent ) //add for SwMailMergeCreateFromDlg
{
    SwMailMergeCreateFromDlg* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_MERGE_CREATE :
            pDlg = new SwMailMergeCreateFromDlg( pParent );
            break;
        default:
            break;
    }
    if ( pDlg )
        return new AbstractMailMergeCreateFromDlg_Impl( pDlg );
    return 0;
}
AbstractMailMergeFieldConnectionsDlg * SwAbstractDialogFactory_Impl::CreateMailMergeFieldConnectionsDlg( int nResId,
                                                            Window* pParent ) //add for SwMailMergeFieldConnectionsDlg
{
    SwMailMergeFieldConnectionsDlg* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_MERGE_FIELD_CONNECTIONS :
            pDlg = new SwMailMergeFieldConnectionsDlg( pParent );
            break;
        default:
            break;
    }
    if ( pDlg )
        return new AbstractMailMergeFieldConnectionsDlg_Impl( pDlg );
    return 0;
}

VclAbstractDialog * SwAbstractDialogFactory_Impl::CreateMultiTOXMarkDlg( int nResId,
                                                Window* pParent, SwTOXMgr &rTOXMgr ) //add for SwMultiTOXMarkDlg
{
    Dialog* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_MULTMRK :
            pDlg = new SwMultiTOXMarkDlg( pParent, rTOXMgr );
            break;
        default:
            break;
    }
    if ( pDlg )
        return new VclAbstractDialog_Impl( pDlg );
    return 0;
}
SfxAbstractTabDialog* SwAbstractDialogFactory_Impl::CreateSwTabDialog( int nResId,
                                                Window* pParent,
                                                const SfxItemSet* pSwItemSet,
                                                SwWrtShell & rWrtSh ) //add for SwSvxNumBulletTabDialog, SwOutlineTabDialog
{
    SfxTabDialog* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_SVXTEST_NUM_BULLET :
            pDlg = new SwSvxNumBulletTabDialog( pParent, pSwItemSet, rWrtSh );
            break;
        case DLG_TAB_OUTLINE :
            pDlg = new SwOutlineTabDialog( pParent, pSwItemSet, rWrtSh );
            break;

        default:
            break;
    }
    if ( pDlg )
        return new AbstractTabDialog_Impl( pDlg );
    return 0;
}
AbstractMultiTOXTabDialog * SwAbstractDialogFactory_Impl::CreateMultiTOXTabDialog( int nResId,
                                                Window* pParent, const SfxItemSet& rSet,
                                                SwWrtShell &rShell,
                                                SwTOXBase* pCurTOX, sal_uInt16 nToxType,
                                                sal_Bool bGlobal ) //add for SwMultiTOXTabDialog
{
    SwMultiTOXTabDialog* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_MULTI_TOX :
            pDlg = new SwMultiTOXTabDialog( pParent, rSet, rShell, pCurTOX, nToxType, bGlobal );
            break;
        default:
            break;
    }
    if ( pDlg )
        return new AbstractMultiTOXTabDialog_Impl( pDlg );
    return 0;
}
AbstractEditRegionDlg * SwAbstractDialogFactory_Impl::CreateEditRegionDlg( int nResId,
                                                Window* pParent, SwWrtShell& rWrtSh ) //add for SwEditRegionDlg
{
    SwEditRegionDlg* pDlg=NULL;
    switch ( nResId )
    {
        case MD_EDIT_REGION :
            pDlg = new SwEditRegionDlg( pParent, rWrtSh );
            break;
        default:
            break;
    }
    if ( pDlg )
        return new AbstractEditRegionDlg_Impl( pDlg );
    return 0;
}
AbstractInsertSectionTabDialog * SwAbstractDialogFactory_Impl::CreateInsertSectionTabDialog( int nResId,
                                                    Window* pParent, const SfxItemSet& rSet, SwWrtShell& rSh) //add for SwInsertSectionTabDialog
{
    SwInsertSectionTabDialog* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_INSERT_SECTION :
            pDlg = new SwInsertSectionTabDialog( pParent, rSet, rSh );
            break;
        default:
            break;
    }
    if ( pDlg )
        return new AbstractInsertSectionTabDialog_Impl( pDlg );
    return 0;
}

AbstractMarkFloatDlg * SwAbstractDialogFactory_Impl::CreateIndexMarkFloatDlg( int nResId,
                                                    SfxBindings* pBindings,
                                                    SfxChildWindow* pChild,
                                                    Window *pParent,
                                                    SfxChildWinInfo* pInfo,
                                                    sal_Bool bNew ) //add for SwIndexMarkFloatDlg
{
    SwIndexMarkFloatDlg* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_INSIDXMARK_CJK :
        case DLG_INSIDXMARK :
            pDlg = new SwIndexMarkFloatDlg( pBindings, pChild, pParent, pInfo, bNew );
            break;
        default:
            break;
    }
    if ( pDlg )
        return new AbstractIndexMarkFloatDlg_Impl( pDlg );
    return 0;
}

AbstractMarkFloatDlg * SwAbstractDialogFactory_Impl::CreateAuthMarkFloatDlg( int nResId,
                                                    SfxBindings* pBindings,
                                                    SfxChildWindow* pChild,
                                                    Window *pParent,
                                                    SfxChildWinInfo* pInfo,
                                                    sal_Bool bNew ) //add for SwAuthMarkFloatDlg
{
    SwAuthMarkFloatDlg* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_INSAUTHMARK :
            pDlg = new SwAuthMarkFloatDlg( pBindings, pChild, pParent, pInfo, bNew );
            break;
        default:
            break;
    }
    if ( pDlg )
        return new AbstractAuthMarkFloatDlg_Impl( pDlg );
    return 0;
}

//add for SwIndexMarkModalDlg begin
VclAbstractDialog * SwAbstractDialogFactory_Impl::CreateIndexMarkModalDlg( int nResId,
                                                Window *pParent, SwWrtShell& rSh, SwTOXMark* pCurTOXMark ) //add for SwIndexMarkModalDlg
{
    Dialog* pDlg=NULL;
    switch ( nResId )
    {
        case DLG_EDIT_IDXMARK_CJK :
        case DLG_EDIT_IDXMARK :
            pDlg = new SwIndexMarkModalDlg( pParent, rSh, pCurTOXMark );
            break;

        default:
            break;
    }

    if ( pDlg )
        return new VclAbstractDialog_Impl( pDlg );
    return 0;
}
//add for SwIndexMarkModalDlg end
AbstractMailMergeWizard*    SwAbstractDialogFactory_Impl::CreateMailMergeWizard(
                                    SwView& rView, SwMailMergeConfigItem& rConfigItem)
{
    return new AbstractMailMergeWizard_Impl( new SwMailMergeWizard(rView, rConfigItem));
}

//add for static func in SwGlossaryDlg
GlossaryGetCurrGroup    SwAbstractDialogFactory_Impl::GetGlossaryCurrGroupFunc( sal_uInt16 nId )
{
    switch ( nId )
    {
        case DLG_RENAME_GLOS :
            return SwGlossaryDlg::GetCurrGroup;
        default:
            break;
    }
    return 0;
}
GlossarySetActGroup SwAbstractDialogFactory_Impl::SetGlossaryActGroupFunc( sal_uInt16 nId )
{
    switch ( nId )
    {
        case DLG_RENAME_GLOS :
            return SwGlossaryDlg::SetActGroup;
        default:
            break;
    }
    return 0;
}

//------------------ Factories for TabPages
CreateTabPage SwAbstractDialogFactory_Impl::GetTabPageCreatorFunc( sal_uInt16 nId )
{
    CreateTabPage pRet = 0;
    switch ( nId )
    {
        case TP_OPTCOMPATIBILITY_PAGE :
        case RID_SW_TP_OPTCOMPATIBILITY_PAGE :
            pRet = SwCompatibilityOptPage::Create;
            break;
        case TP_OPTLOAD_PAGE :
        case RID_SW_TP_OPTLOAD_PAGE :
            pRet = SwLoadOptPage::Create;
            break;
        case TP_OPTCAPTION_PAGE:
        case RID_SW_TP_OPTCAPTION_PAGE:
            return SwCaptionOptPage::Create;
        case TP_CONTENT_OPT :
        case RID_SW_TP_CONTENT_OPT:
        case RID_SW_TP_HTML_CONTENT_OPT:
            pRet = SwContentOptPage::Create;
            break;
        case TP_OPTSHDWCRSR :
        case RID_SW_TP_OPTSHDWCRSR:
        case RID_SW_TP_HTML_OPTSHDWCRSR:
            pRet = SwShdwCrsrOptionsTabPage::Create;
            break;
        case RID_SW_TP_REDLINE_OPT :
        case TP_REDLINE_OPT :
            pRet = SwRedlineOptionsTabPage::Create;
            break;
        case RID_SW_TP_OPTTEST_PAGE :
        case TP_OPTTEST_PAGE :
#ifdef DBG_UTIL
            pRet = SwTestTabPage::Create;
#endif
            break;
        case TP_OPTPRINT_PAGE :
        case RID_SW_TP_HTML_OPTPRINT_PAGE:
        case RID_SW_TP_OPTPRINT_PAGE:
            pRet = SwAddPrinterTabPage::Create;
            break;
        case TP_STD_FONT :
        case RID_SW_TP_STD_FONT:
        case RID_SW_TP_STD_FONT_CJK:
        case RID_SW_TP_STD_FONT_CTL:
            pRet = SwStdFontTabPage::Create;
            break;
        case TP_OPTTABLE_PAGE :
        case RID_SW_TP_HTML_OPTTABLE_PAGE:
        case RID_SW_TP_OPTTABLE_PAGE:
            pRet = SwTableOptionsTabPage::Create;
            break;
        case TP_DOC_STAT :
            pRet = SwDocStatPage::Create;
            break;
        case RID_SW_TP_MAILCONFIG:
            pRet = SwMailConfigPage::Create;
        break;
    }

    return pRet;
}

GetTabPageRanges SwAbstractDialogFactory_Impl::GetTabPageRangesFunc( sal_uInt16 nId )
{
    switch ( nId )
    {
    case 1 : //RID_SVXPAGE_TEXTANIMATION :
            //return SvxTextAnimationPage::GetRanges;
            break;
        default:
            break;
    }

    return 0;
}

/* vim: set noet sw=4 ts=4: */