| /************************************************************** |
| * |
| * 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(AbstarctSwLabDlg_Impl);//add for SwLabDlg |
| IMPL_ABSTDLG_BASE(AbstarctSwSelGlossaryDlg_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 AbstarctSwLabDlg_Impl::SetCurPageId( sal_uInt16 nId ) |
| { |
| pDlg->SetCurPageId( nId ); |
| } |
| |
| const SfxItemSet* AbstarctSwLabDlg_Impl::GetOutputItemSet() const |
| { |
| return pDlg->GetOutputItemSet(); |
| } |
| |
| const sal_uInt16* AbstarctSwLabDlg_Impl::GetInputRanges(const SfxItemPool& pItem ) |
| { |
| return pDlg->GetInputRanges( pItem ); |
| } |
| |
| void AbstarctSwLabDlg_Impl::SetInputSet( const SfxItemSet* pInSet ) |
| { |
| pDlg->SetInputSet( pInSet ); |
| } |
| |
| void AbstarctSwLabDlg_Impl::SetText( const XubString& rStr ) |
| { |
| pDlg->SetText( rStr ); |
| } |
| String AbstarctSwLabDlg_Impl::GetText() const |
| { |
| return pDlg->GetText(); |
| } |
| const String& AbstarctSwLabDlg_Impl::GetBusinessCardStr() const |
| { |
| return pDlg->GetBusinessCardStr(); |
| } |
| Printer * AbstarctSwLabDlg_Impl::GetPrt() |
| { |
| return pDlg->GetPrt(); |
| } |
| //add for SwLabDlg end |
| |
| |
| //add for SwSelGlossaryDlg begin |
| |
| void AbstarctSwSelGlossaryDlg_Impl::InsertGlos(const String &rRegion, const String &rGlosName) |
| { |
| pDlg->InsertGlos( rRegion, rGlosName ); |
| } |
| sal_uInt16 AbstarctSwSelGlossaryDlg_Impl::GetSelectedIdx() const |
| { |
| return pDlg->GetSelectedIdx(); |
| } |
| void AbstarctSwSelGlossaryDlg_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 |
| |
| AbstarctSwLabDlg* 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 AbstarctSwLabDlg_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 |
| AbstarctSwSelGlossaryDlg * 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 AbstarctSwSelGlossaryDlg_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, |
| sal_Bool bColumn, |
| SwWrtShell* pActShell, |
| sal_Bool bNew ) //add for SwTemplateDlg |
| { |
| SfxTabDialog* pDlg=NULL; |
| switch ( nResId ) |
| { |
| case DLG_TEMPLATE_BASE : |
| pDlg = new SwTemplateDlg( pParent, rBase, nRegion, bColumn, 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; |
| } |
