svx/source/cui/dlgfact.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: dlgfact.cxx,v $
  10  * $Revision: 1.48 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_svx.hxx"
  33
  34 #ifdef SVX_DLLIMPLEMENTATION
  35 #undef SVX_DLLIMPLEMENTATION
  36 #endif
  37
  38 #include "numfmt.hxx" //add for SvxNumberFormatTabPage
  39
  40 #include "dlgfact.hxx"
  41
  42 // class ResId
  43 #include <tools/rc.hxx>
  44 #include <sfx2/basedlgs.hxx>
  45 #include <sfx2/app.hxx>
  46 #include <sfx2/request.hxx>
  47 #include <svx/optimprove.hxx>
  48 #include "splitcelldlg.hxx"
  49 #include <svx/dialogs.hrc>
  50 #include "fmresids.hrc"
  51 #include "gallery.hrc"
  52 //#include "imapdlg.hrc"
  53 // dialogs and tabpages
  54 #include "dstribut.hxx"
  55 #include "cuigaldlg.hxx"
  56 #include "cuiimapwnd.hxx"
  57 #include "hlmarkwn.hxx"
  58 #include "cuicharmap.hxx"
  59 #include "srchxtra.hxx"
  60 #include "textanim.hxx"
  61 #include "autocdlg.hxx"
  62 #include "treeopt.hxx"
  63 #include "internationaloptions.hxx"
  64 #include "labdlg.hxx"
  65 #include "dstribut.hxx"
  66 #include "hangulhanjadlg.hxx" //add for HangulHanjaConversionDialog
  67 #include "showcols.hxx" //add for FmShowColsDialog
  68 #include "zoom.hxx" //add for SvxZoomDialog
  69 #include "cuigaldlg.hxx"                //add for Gallery 6 Dialogs and 1 TabPage
  70 #include "cuiimapwnd.hxx"               //add for URLDlg
  71 #include "hlmarkwn.hxx"         //add for SvxHlinkDlgMarkWnd
  72 #include "srchxtra.hxx"         //add for SvxSearchFormatDialog
  73 #include "transfrm.hxx" //add for SvxTransformTabDialog
  74 #include "bbdlg.hxx" //add for SvxBorderBackgroundDlg
  75 #include "cuisrchdlg.hxx" //add for SvxJSearchOptionsDialog
  76 #include "cuitbxform.hxx" //add for FmInputRecordNoDialog
  77 #include "optdict.hxx" //add for SvxNewDictionaryDialog
  78 #include "dlgname.hxx" //add for SvxNameDialog & SvxMessDialog
  79 #include "multipat.hxx" //add for SvxMultiPathDialog
  80 #include "multifil.hxx" //add for SvxMultiFileDialog
  81 #include "cuihyperdlg.hxx" //add for SvxHpLinkDlg
  82 #include "cuifmsearch.hxx" //add  for FmSearchDialog
  83 #include "cuigrfflt.hxx"        //add for GraphicFilterDialog
  84 #include "cuitabarea.hxx" //add for SvxAreaTabDialog
  85 #include "cuitabline.hxx" //add for SvxLineTabDialog
  86 #include "measure.hxx" //add for SvxMeasureDialog
  87 #include "connect.hxx" //add for SvxConnectionDialog
  88 #include "dbregister.hxx" // add for DatabaseRegistrationDialog
  89 #include "cuioptgenrl.hxx"      //add for SvxGeneralTabPage
  90 #include <optasian.hxx>
  91 #include "insdlg.hxx"
  92 #include "pastedlg.hxx"
  93 #include "linkdlg.hxx"
  94 #include "SpellDialog.hxx"
  95 #include "cfg.hxx"    //add for SvxConfigDialog
  96
  97 #include "numpages.hxx" // add for
  98 #include "paragrph.hxx" //add for
  99 #include "tabstpge.hxx" // add  for
 100 #include "textattr.hxx" // add for SvxTextAttrPage
 101 #include "align.hxx" //add for SvxAlignmentTabPage
 102 #include "backgrnd.hxx" //add for SvxBackgroundTabPage
 103 #include "border.hxx" //add for SvxBorderTabPage
 104 #include "chardlg.hxx" //add for SvxCharNamePage,SvxCharEffectsPage,SvxCharPositionPage,SvxCharTwoLinesPage
 105 #include "page.hxx" //add for SvxPageDescPage
 106 #include "postdlg.hxx" //add for SvxPostItDialog
 107 #include "grfpage.hxx" //add for SvxGrfCropPage
 108 #include "scriptdlg.hxx" // for ScriptOrgDialog
 109 #include "selector.hxx" // for SvxScriptSelectorDialog
 110 #include "macropg.hxx" // for SvxMacroAssignDlg
 111 #include "sdrcelldlg.hxx"
 112 #include "newtabledlg.hxx"
 113 #include "macroass.hxx"
 114 #include "acccfg.hxx"
 115 #include "insrc.hxx"
 116
 117 using namespace ::com::sun::star;
 118 using namespace ::com::sun::star::frame;
 119 using namespace ::com::sun::star::container;
 120
 121 using ::com::sun::star::uno::Reference;
 122
 123 using namespace svx;
 124 // AbstractTabDialog implementations just forwards everything to the dialog
 125 IMPL_ABSTDLG_BASE(AbstractSfxDialog_Impl)
 126 IMPL_ABSTDLG_BASE(VclAbstractDialog_Impl)
 127 IMPL_ABSTDLG_BASE(VclAbstractRefreshableDialog_Impl);
 128 IMPL_ABSTDLG_BASE(AbstractTabDialog_Impl);
 129 IMPL_ABSTDLG_BASE(AbstractSvxDistributeDialog_Impl);
 130 IMPL_ABSTDLG_BASE(AbstractHangulHanjaConversionDialog_Impl);
 131 IMPL_ABSTDLG_BASE(AbstractFmShowColsDialog_Impl);
 132
 133 AbstractSvxZoomDialog_Impl::~AbstractSvxZoomDialog_Impl()                                                       \
 134 {
 135     delete pDlg;
 136 }
 137 short AbstractSvxZoomDialog_Impl::Execute()
 138 {
 139     return pDlg->Execute();
 140 }
 141
 142 //IMPL_ABSTDLG_BASE(AbstractSvxZoomDialog_Impl);
 143 IMPL_ABSTDLG_BASE(AbstractSearchProgress_Impl);
 144 IMPL_ABSTDLG_BASE(AbstractTakeProgress_Impl);
 145 IMPL_ABSTDLG_BASE(AbstractTitleDialog_Impl);
 146 IMPL_ABSTDLG_BASE(AbstractScriptSelectorDialog_Impl);
 147 IMPL_ABSTDLG_BASE(AbstractGalleryIdDialog_Impl);
 148 IMPL_ABSTDLG_BASE(AbstractURLDlg_Impl);
 149 IMPL_ABSTDLG_BASE(AbstractSvxHlinkDlgMarkWnd_Impl);
 150 IMPL_ABSTDLG_BASE(AbstractSvxSearchSimilarityDialog_Impl);
 151 IMPL_ABSTDLG_BASE(AbstractSvxTransformTabDialog_Impl);
 152 IMPL_ABSTDLG_BASE(AbstractSvxCaptionDialog_Impl);
 153 IMPL_ABSTDLG_BASE(AbstractSvxJSearchOptionsDialog_Impl);
 154 IMPL_ABSTDLG_BASE(AbstractFmInputRecordNoDialog_Impl);
 155 IMPL_ABSTDLG_BASE(AbstractSvxNewDictionaryDialog_Impl);
 156 IMPL_ABSTDLG_BASE(AbstractSvxNameDialog_Impl);
 157
 158 // #i68101#
 159 IMPL_ABSTDLG_BASE(AbstractSvxObjectNameDialog_Impl);
 160 IMPL_ABSTDLG_BASE(AbstractSvxObjectTitleDescDialog_Impl);
 161
 162 IMPL_ABSTDLG_BASE(AbstractSvxMessDialog_Impl);
 163 IMPL_ABSTDLG_BASE(AbstractSvxMultiPathDialog_Impl);
 164 IMPL_ABSTDLG_BASE(AbstractSvxMultiFileDialog_Impl);
 165 IMPL_ABSTDLG_BASE(AbstractSvxHpLinkDlg_Impl);
 166 IMPL_ABSTDLG_BASE(AbstractFmSearchDialog_Impl);
 167 IMPL_ABSTDLG_BASE(AbstractGraphicFilterDialog_Impl);
 168 IMPL_ABSTDLG_BASE(AbstractSvxAreaTabDialog_Impl);
 169 IMPL_ABSTDLG_BASE(AbstractPasteDialog_Impl);
 170 IMPL_ABSTDLG_BASE(AbstractInsertObjectDialog_Impl);
 171 IMPL_ABSTDLG_BASE(AbstractLinksDialog_Impl);
 172 IMPL_ABSTDLG_BASE(AbstractSpellDialog_Impl);
 173 IMPL_ABSTDLG_BASE(AbstractSvxPostItDialog_Impl);
 174
 175 //////////////////////////////////////////////////////////////////////////
 176 // VclAbstractDialog2_Impl
 177 //////////////////////////////////////////////////////////////////////////
 178
 179 // virtual
 180 VclAbstractDialog2_Impl::~VclAbstractDialog2_Impl()
 181 {
 182     delete m_pDlg;
 183 }
 184
 185 // virtual
 186 void  VclAbstractDialog2_Impl::StartExecuteModal( const Link& rEndDialogHdl )
 187 {
 188     m_aEndDlgHdl = rEndDialogHdl;
 189     m_pDlg->StartExecuteModal(
 190         LINK( this, VclAbstractDialog2_Impl, EndDialogHdl ) );
 191 }
 192
 193 // virtual
 194 long VclAbstractDialog2_Impl::GetResult()
 195 {
 196     return m_pDlg->GetResult();
 197 }
 198
 199 IMPL_LINK( VclAbstractDialog2_Impl, EndDialogHdl, Dialog*, pDlg )
 200 {
 201     if ( pDlg != m_pDlg )
 202     {
 203         DBG_ERRORFILE( "VclAbstractDialog2_Impl::EndDialogHdl(): wrong dialog" );
 204     }
 205
 206     m_aEndDlgHdl.Call( this );
 207     m_aEndDlgHdl = Link();
 208
 209     return 0L;
 210 }
 211
 212 //////////////////////////////////////////////////////////////////////////
 213
 214 void AbstractTabDialog_Impl::SetCurPageId( USHORT nId )
 215 {
 216     pDlg->SetCurPageId( nId );
 217 }
 218
 219 const SfxItemSet* AbstractTabDialog_Impl::GetOutputItemSet() const
 220 {
 221     return pDlg->GetOutputItemSet();
 222 }
 223 //add by CHINA001
 224 const USHORT* AbstractTabDialog_Impl::GetInputRanges(const SfxItemPool& pItem )
 225 {
 226     return pDlg->GetInputRanges( pItem );
 227 }
 228 //add by CHINA001
 229 void AbstractTabDialog_Impl::SetInputSet( const SfxItemSet* pInSet )
 230 {
 231      pDlg->SetInputSet( pInSet );
 232 }
 233 //From class Window.
 234 void AbstractTabDialog_Impl::SetText( const XubString& rStr )
 235 {
 236     pDlg->SetText( rStr );
 237 }
 238 String AbstractTabDialog_Impl::GetText() const
 239 {
 240     return pDlg->GetText();
 241 }
 242
 243 // AbstractTabDialog_Impl end
 244
 245 const SfxItemSet* AbstractSfxDialog_Impl::GetOutputItemSet() const
 246 {
 247     return pDlg->GetOutputItemSet();
 248 }
 249
 250 void AbstractSfxDialog_Impl::SetText( const XubString& rStr )
 251 {
 252     pDlg->SetText( rStr );
 253 }
 254
 255 String AbstractSfxDialog_Impl::GetText() const
 256 {
 257     return pDlg->GetText();
 258 }
 259
 260 //for SvxDistributeDialog begin
 261 SvxDistributeHorizontal AbstractSvxDistributeDialog_Impl::GetDistributeHor()const
 262 {
 263     return pDlg->GetDistributeHor();
 264 }
 265 SvxDistributeVertical AbstractSvxDistributeDialog_Impl::GetDistributeVer()const
 266 {
 267     return pDlg->GetDistributeVer();
 268 }
 269 //for SvxDistributeDialog end
 270
 271 // for HangulHanjaConversionDialog begin
 272 void AbstractHangulHanjaConversionDialog_Impl::EndDialog(long nResult)
 273 {
 274     pDlg->EndDialog(nResult);
 275 }
 276
 277 void AbstractHangulHanjaConversionDialog_Impl::EnableRubySupport( sal_Bool _bVal )
 278 {
 279     pDlg->EnableRubySupport(_bVal);
 280 }
 281
 282 void AbstractHangulHanjaConversionDialog_Impl::SetByCharacter( sal_Bool _bByCharacter )
 283 {
 284     pDlg->SetByCharacter(_bByCharacter);
 285 }
 286
 287 void AbstractHangulHanjaConversionDialog_Impl::SetConversionDirectionState( sal_Bool _bTryBothDirections, HangulHanjaConversion::ConversionDirection _ePrimaryConversionDirection )
 288 {
 289     pDlg->SetConversionDirectionState(_bTryBothDirections, _ePrimaryConversionDirection);
 290 }
 291
 292 void AbstractHangulHanjaConversionDialog_Impl::SetConversionFormat( HangulHanjaConversion::ConversionFormat _eType )
 293 {
 294      pDlg->SetConversionFormat(_eType);
 295 }
 296
 297 void AbstractHangulHanjaConversionDialog_Impl::SetOptionsChangedHdl( const Link& _rHdl )
 298 {
 299      pDlg->SetOptionsChangedHdl(_rHdl );
 300 }
 301
 302 void AbstractHangulHanjaConversionDialog_Impl::SetIgnoreHdl( const Link& _rHdl )
 303 {
 304      pDlg->SetIgnoreHdl(_rHdl );
 305 }
 306
 307 void AbstractHangulHanjaConversionDialog_Impl::SetIgnoreAllHdl( const Link& _rHdl )
 308 {
 309      pDlg->SetIgnoreAllHdl(_rHdl );
 310 }
 311
 312 void AbstractHangulHanjaConversionDialog_Impl::SetChangeHdl( const Link& _rHdl )
 313 {
 314     pDlg->SetChangeHdl(_rHdl );
 315 }
 316
 317 void AbstractHangulHanjaConversionDialog_Impl::SetChangeAllHdl( const Link& _rHdl )
 318 {
 319     pDlg->SetChangeAllHdl(_rHdl );
 320 }
 321
 322 void AbstractHangulHanjaConversionDialog_Impl::SetClickByCharacterHdl( const Link& _rHdl )
 323 {
 324      pDlg->SetClickByCharacterHdl(_rHdl );
 325 }
 326
 327 void AbstractHangulHanjaConversionDialog_Impl::SetConversionFormatChangedHdl( const Link& _rHdl )
 328 {
 329     pDlg->SetConversionFormatChangedHdl(_rHdl );
 330 }
 331 void AbstractHangulHanjaConversionDialog_Impl::SetFindHdl( const Link& _rHdl )
 332 {
 333      pDlg->SetFindHdl(_rHdl );
 334 }
 335
 336 sal_Bool AbstractHangulHanjaConversionDialog_Impl::GetUseBothDirections( ) const
 337 {
 338     return pDlg->GetUseBothDirections();
 339 }
 340
 341 HangulHanjaConversion::ConversionDirection AbstractHangulHanjaConversionDialog_Impl::GetDirection( HangulHanjaConversion::ConversionDirection _eDefaultDirection ) const
 342 {
 343     return pDlg->GetDirection( _eDefaultDirection );
 344 }
 345
 346 void AbstractHangulHanjaConversionDialog_Impl::SetCurrentString(
 347                     const String& _rNewString,
 348                     const ::com::sun::star::uno::Sequence< ::rtl::OUString >& _rSuggestions,
 349                     bool _bOriginatesFromDocument
 350                 )
 351 {
 352      pDlg->SetCurrentString(_rNewString,_rSuggestions,_bOriginatesFromDocument);
 353 }
 354 String   AbstractHangulHanjaConversionDialog_Impl::GetCurrentString( ) const
 355 {
 356     return pDlg->GetCurrentString();
 357 }
 358 HangulHanjaConversion::ConversionFormat  AbstractHangulHanjaConversionDialog_Impl::GetConversionFormat( ) const
 359 {
 360     return pDlg->GetConversionFormat();
 361 }
 362
 363 void AbstractHangulHanjaConversionDialog_Impl::FocusSuggestion( )
 364 {
 365     pDlg->FocusSuggestion();
 366 }
 367
 368 String  AbstractHangulHanjaConversionDialog_Impl::GetCurrentSuggestion( ) const
 369 {
 370     return pDlg->GetCurrentSuggestion();
 371 }
 372
 373 Reference < com::sun::star::embed::XEmbeddedObject > AbstractInsertObjectDialog_Impl::GetObject()
 374 {
 375    return pDlg->GetObject();
 376 }
 377
 378 BOOL AbstractInsertObjectDialog_Impl::IsCreateNew()
 379 {
 380     return pDlg->IsCreateNew();
 381 }
 382
 383 ::Reference< ::com::sun::star::io::XInputStream > AbstractInsertObjectDialog_Impl::GetIconIfIconified( ::rtl::OUString* pGraphicMediaType )
 384 {
 385    return pDlg->GetIconIfIconified( pGraphicMediaType );
 386 }
 387
 388 void AbstractPasteDialog_Impl::Insert( SotFormatStringId nFormat, const String & rFormatName )
 389 {
 390     pDlg->Insert( nFormat, rFormatName );
 391 }
 392
 393 void AbstractPasteDialog_Impl::SetObjName( const SvGlobalName & rClass, const String & rObjName )
 394 {
 395     pDlg->SetObjName( rClass, rObjName );
 396 }
 397
 398 ULONG AbstractPasteDialog_Impl::GetFormat( const TransferableDataHelper& aHelper,
 399                         const DataFlavorExVector* pFormats,
 400                         const TransferableObjectDescriptor* pDesc )
 401 {
 402     return pDlg->GetFormat( aHelper, pFormats, pDesc );
 403 }
 404
 405 // for HangulHanjaConversionDialog end
 406 // for FmShowColsDialog begin
 407 void  AbstractFmShowColsDialog_Impl::SetColumns(const ::Reference< ::com::sun::star::container::XIndexContainer>& xCols)
 408 {
 409      pDlg->SetColumns(xCols);
 410 }
 411
 412 //for FmShowColsDialog end
 413
 414 //for SvxZoomDialog begin
 415 void AbstractSvxZoomDialog_Impl::SetLimits( USHORT nMin, USHORT nMax )
 416 {
 417     pDlg->SetLimits( nMin, nMax );
 418 }
 419
 420 void AbstractSvxZoomDialog_Impl::HideButton( USHORT nBtnId )
 421 {
 422     pDlg->HideButton( nBtnId );
 423 }
 424
 425 const SfxItemSet* AbstractSvxZoomDialog_Impl::GetOutputItemSet() const
 426 {
 427     return pDlg->GetOutputItemSet();
 428 }
 429
 430 //for SvxZoomDialog end
 431 // svx::SvxSpellDialog
 432 /*-- 04.05.2004 08:26:12---------------------------------------------------
 433
 434   -----------------------------------------------------------------------*/
 435 void AbstractSpellDialog_Impl::SetLanguage( sal_uInt16 nLang )
 436 {
 437     pDlg->SetLanguage(nLang);
 438 }
 439 /*-- 04.05.2004 08:26:13---------------------------------------------------
 440
 441   -----------------------------------------------------------------------*/
 442 sal_Bool AbstractSpellDialog_Impl::Close()
 443 {
 444     return pDlg->Close();
 445 }
 446 /*-- 04.05.2004 08:26:13---------------------------------------------------
 447
 448   -----------------------------------------------------------------------*/
 449 void  AbstractSpellDialog_Impl::Invalidate()
 450 {
 451     pDlg->InvalidateDialog();
 452 }
 453 /*-- 04.05.2004 08:26:13---------------------------------------------------
 454
 455   -----------------------------------------------------------------------*/
 456 Window*     AbstractSpellDialog_Impl::GetWindow()
 457 {
 458     return pDlg;
 459 }
 460 /*-- 04.05.2004 08:26:13---------------------------------------------------
 461
 462   -----------------------------------------------------------------------*/
 463 SfxBindings& AbstractSpellDialog_Impl::GetBindings()
 464 {
 465     return pDlg->GetBindings();
 466 }
 467 // end svx::SvxSpellDialog
 468
 469 //for SvxSpellCheckDialog begin
 470 //STRIP001 void AbstractSvxSpellCheckDialog_Impl::SetNewEditWord( const String& _rNew )
 471 //STRIP001 {
 472 //STRIP001 return pDlg->SetNewEditWord(_rNew );
 473 //STRIP001 }
 474 //STRIP001
 475 //STRIP001 void AbstractSvxSpellCheckDialog_Impl::SetLanguage( sal_uInt16 nLang )
 476 //STRIP001 {
 477 //STRIP001 return pDlg->SetLanguage( nLang );
 478 //STRIP001 }
 479 //STRIP001
 480 //STRIP001 void AbstractSvxSpellCheckDialog_Impl::HideAutoCorrect()
 481 //STRIP001 {
 482 //STRIP001 return pDlg->HideAutoCorrect();
 483 //STRIP001 }
 484 //STRIP001
 485 //STRIP001 String AbstractSvxSpellCheckDialog_Impl::GetNewEditWord()
 486 //STRIP001 {
 487 //STRIP001 return pDlg->GetNewEditWord();
 488 //STRIP001 }
 489 //STRIP001
 490 //STRIP001 void AbstractSvxSpellCheckDialog_Impl::SetNewEditWord( const String& _rNew )
 491 //STRIP001 {
 492 //STRIP001 return pDlg->SetNewEditWord( _rNew );
 493 //STRIP001 }
 494 //STRIP001
 495 //for SvxSpellCheckDialog end
 496
 497 //for SearchProgress begin
 498 void AbstractSearchProgress_Impl::Update()
 499 {
 500      pDlg->Update();
 501 }
 502
 503 void AbstractSearchProgress_Impl::Sync()
 504 {
 505      pDlg-> Sync();
 506 }
 507
 508 void AbstractSearchProgress_Impl::SetFileType( const String& rType )
 509 {
 510      pDlg->SetFileType( rType );
 511 }
 512
 513 void AbstractSearchProgress_Impl::SetDirectory( const INetURLObject& rURL )
 514 {
 515      pDlg->SetDirectory( rURL );
 516 }
 517 PLinkStub       AbstractSearchProgress_Impl::GetLinkStubCleanUpHdl()
 518 {
 519     return SearchProgress::LinkStubCleanUpHdl;
 520 }
 521 //for SearchProgress end
 522
 523 //for TakeProgress begin
 524 void AbstractTakeProgress_Impl::Update()
 525 {
 526      pDlg->Update();
 527 }
 528
 529 void AbstractTakeProgress_Impl::Sync()
 530 {
 531      pDlg-> Sync();
 532 }
 533
 534 void AbstractTakeProgress_Impl::SetFile( const INetURLObject& rURL )
 535 {
 536      pDlg->SetFile( rURL );
 537 }
 538
 539 PLinkStub       AbstractTakeProgress_Impl::GetLinkStubCleanUpHdl()
 540 {
 541     return TakeProgress::LinkStubCleanUpHdl;
 542 }
 543 //for TakeProgress end
 544
 545 //for TitleDialog begin
 546 String AbstractTitleDialog_Impl::GetTitle() const
 547 {
 548     return pDlg->GetTitle();
 549 }
 550 //for TitleDialog end
 551
 552 //for GalleryIdDialog begin
 553 ULONG AbstractGalleryIdDialog_Impl::GetId() const
 554 {
 555     return pDlg->GetId();
 556 }
 557 //for GalleryIdDialog end
 558
 559 //for VclAbstracRefreshableDialog begin
 560 void VclAbstractRefreshableDialog_Impl::Update()
 561 {
 562     pDlg->Update();
 563 }
 564
 565 void VclAbstractRefreshableDialog_Impl::Sync()
 566 {
 567      pDlg-> Sync();
 568 }
 569 //for VclAbstracRefreshableDialog end
 570
 571 //for URLDlg begin
 572 String AbstractURLDlg_Impl::GetURL() const
 573 {
 574     return pDlg->GetURL();
 575 }
 576
 577 String AbstractURLDlg_Impl::GetAltText() const
 578 {
 579     return pDlg->GetAltText();
 580 }
 581
 582 String AbstractURLDlg_Impl::GetDesc() const
 583 {
 584     return pDlg->GetDesc();
 585 }
 586
 587 String AbstractURLDlg_Impl::GetTarget() const
 588 {
 589     return pDlg->GetTarget();
 590 }
 591
 592 String AbstractURLDlg_Impl::GetName() const
 593 {
 594     return pDlg->GetName();
 595 }
 596 //for URLDlg end
 597
 598 // AbstractSvxHlinkDlgMarkWnd_Impl begin
 599
 600 void AbstractSvxHlinkDlgMarkWnd_Impl::Hide( USHORT nFlags )
 601 {
 602     ((Window*)pDlg)->Hide( nFlags );
 603 }
 604
 605 void AbstractSvxHlinkDlgMarkWnd_Impl::SetSizePixel( const Size& rNewSize )
 606 {
 607     pDlg->SetSizePixel( rNewSize );
 608 }
 609
 610 Size AbstractSvxHlinkDlgMarkWnd_Impl::GetSizePixel() const
 611 {
 612     return pDlg->GetSizePixel();
 613 }
 614
 615 BOOL AbstractSvxHlinkDlgMarkWnd_Impl::IsVisible( ) const
 616 {
 617     return (( Window* )pDlg)->IsVisible();
 618 }
 619
 620 void AbstractSvxHlinkDlgMarkWnd_Impl::Invalidate( USHORT nFlags )
 621 {
 622     (( Window* )pDlg)->Invalidate(nFlags);
 623 }
 624
 625 BOOL AbstractSvxHlinkDlgMarkWnd_Impl::MoveTo( Point aNewPos )const
 626 {
 627     return pDlg->MoveTo(aNewPos);
 628 }
 629
 630 BOOL AbstractSvxHlinkDlgMarkWnd_Impl::ConnectToDialog( BOOL bDoit  )const
 631 {
 632     return pDlg->ConnectToDialog(bDoit);
 633 }
 634
 635 void AbstractSvxHlinkDlgMarkWnd_Impl::RefreshTree ( String aStrURL )
 636 {
 637     pDlg->RefreshTree(aStrURL);
 638 }
 639
 640 void AbstractSvxHlinkDlgMarkWnd_Impl::SelectEntry ( String aStrMark )
 641 {
 642     pDlg->SelectEntry(aStrMark);
 643 }
 644
 645 USHORT AbstractSvxHlinkDlgMarkWnd_Impl::SetError( USHORT nError)
 646 {
 647     return pDlg->SetError(nError);
 648 }
 649
 650 // AbstractSvxHlinkDlgMarkWnd_Impl end
 651
 652 //for SvxSearchSimilarityDialog begin
 653 USHORT AbstractSvxSearchSimilarityDialog_Impl::GetOther()
 654 {
 655     return pDlg->GetOther();
 656 }
 657
 658 USHORT AbstractSvxSearchSimilarityDialog_Impl::GetShorter()
 659 {
 660     return pDlg->GetShorter();
 661 }
 662
 663 USHORT AbstractSvxSearchSimilarityDialog_Impl::GetLonger()
 664 {
 665     return pDlg-> GetLonger();
 666 }
 667
 668 BOOL AbstractSvxSearchSimilarityDialog_Impl::IsRelaxed()
 669 {
 670     return pDlg-> IsRelaxed();
 671 }
 672 //for SvxSearchSimilarityDialog end
 673
 674 // AbstractSvxTransformTabDialog implementations just forwards everything to the dialog
 675 void AbstractSvxTransformTabDialog_Impl::SetCurPageId( USHORT nId )
 676 {
 677     pDlg->SetCurPageId( nId );
 678 }
 679 const SfxItemSet* AbstractSvxTransformTabDialog_Impl::GetOutputItemSet() const
 680 {
 681     return pDlg->GetOutputItemSet();
 682 }
 683 //
 684 const USHORT* AbstractSvxTransformTabDialog_Impl::GetInputRanges(const SfxItemPool& pItem )
 685 {
 686     return pDlg->GetInputRanges( pItem );
 687 }
 688 //
 689 void AbstractSvxTransformTabDialog_Impl::SetInputSet( const SfxItemSet* pInSet )
 690 {
 691      pDlg->SetInputSet( pInSet );
 692 }
 693 //From class Window.
 694 void AbstractSvxTransformTabDialog_Impl::SetText( const XubString& rStr )
 695 {
 696     pDlg->SetText( rStr );
 697 }
 698 String AbstractSvxTransformTabDialog_Impl::GetText() const
 699 {
 700     return pDlg->GetText();
 701 }
 702 void AbstractSvxTransformTabDialog_Impl::SetValidateFramePosLink( const Link& rLink )
 703 {
 704     pDlg->SetValidateFramePosLink( rLink );
 705 }
 706 // AbstractSvxTransformTabDialog end
 707
 708 // AbstractSvxCaptionDialog implementations just forwards everything to the dialog
 709 void AbstractSvxCaptionDialog_Impl::SetCurPageId( USHORT nId )
 710 {
 711     pDlg->SetCurPageId( nId );
 712 }
 713 const SfxItemSet* AbstractSvxCaptionDialog_Impl::GetOutputItemSet() const
 714 {
 715     return pDlg->GetOutputItemSet();
 716 }
 717 //
 718 const USHORT* AbstractSvxCaptionDialog_Impl::GetInputRanges(const SfxItemPool& pItem )
 719 {
 720     return pDlg->GetInputRanges( pItem );
 721 }
 722 //
 723 void AbstractSvxCaptionDialog_Impl::SetInputSet( const SfxItemSet* pInSet )
 724 {
 725      pDlg->SetInputSet( pInSet );
 726 }
 727 //From class Window.
 728 void AbstractSvxCaptionDialog_Impl::SetText( const XubString& rStr )
 729 {
 730     pDlg->SetText( rStr );
 731 }
 732 String AbstractSvxCaptionDialog_Impl::GetText() const
 733 {
 734     return pDlg->GetText();
 735 }
 736 void AbstractSvxCaptionDialog_Impl::SetValidateFramePosLink( const Link& rLink )
 737 {
 738     pDlg->SetValidateFramePosLink( rLink );
 739 }
 740 // SvxAbstractCaptionDialog end
 741
 742 //for SvxJSearchOptionsDialog begin
 743 INT32 AbstractSvxJSearchOptionsDialog_Impl::GetTransliterationFlags() const
 744 {
 745     return pDlg->GetTransliterationFlags();
 746 }
 747 //for SvxJSearchOptionsDialog end
 748
 749 //for FmInputRecordNoDialog begin
 750 void AbstractFmInputRecordNoDialog_Impl::SetValue(long nNew)
 751 {
 752     pDlg->SetValue(nNew);
 753 }
 754
 755 long AbstractFmInputRecordNoDialog_Impl::GetValue() const
 756 {
 757     return pDlg->GetValue();
 758 }
 759 //for FmInputRecordNoDialog end
 760
 761 //for SvxNewDictionaryDialog begin
 762 ::Reference<
 763         ::com::sun::star::linguistic2::XDictionary > AbstractSvxNewDictionaryDialog_Impl::GetNewDictionary()
 764 {
 765     return pDlg->GetNewDictionary();
 766 }
 767 //for SvxNewDictionaryDialog end
 768
 769 //for SvxNameDialog begin
 770 void AbstractSvxNameDialog_Impl::GetName( String& rName )
 771 {
 772     pDlg->GetName( rName );
 773 }
 774 void AbstractSvxNameDialog_Impl::SetCheckNameHdl( const Link& rLink, bool bCheckImmediately )
 775 {
 776     aCheckNameHdl = rLink;
 777     if( rLink.IsSet() )
 778         pDlg->SetCheckNameHdl( LINK(this, AbstractSvxNameDialog_Impl, CheckNameHdl), bCheckImmediately );
 779     else
 780         pDlg->SetCheckNameHdl( Link(), bCheckImmediately );
 781 }
 782 void AbstractSvxNameDialog_Impl::SetEditHelpId(ULONG nHelpId)
 783 {
 784     pDlg->SetEditHelpId( nHelpId );
 785 }
 786 void AbstractSvxNameDialog_Impl::SetHelpId( ULONG nHelpId )
 787 {
 788     pDlg->SetHelpId( nHelpId );
 789 }
 790 void AbstractSvxNameDialog_Impl::SetText( const XubString& rStr )
 791 {
 792     pDlg->SetText( rStr );
 793 }
 794 IMPL_LINK( AbstractSvxNameDialog_Impl, CheckNameHdl, Window*, EMPTYARG )
 795 {
 796     if( aCheckNameHdl.IsSet() )
 797         return aCheckNameHdl.Call(this);
 798     return 0;
 799 }
 800 //for SvxNameDialog end
 801
 802 ///////////////////////////////////////////////////////////////////////////////////////////////
 803 // #i68101#
 804
 805 void AbstractSvxObjectNameDialog_Impl::GetName(String& rName)
 806 {
 807     pDlg->GetName(rName);
 808 }
 809
 810 void AbstractSvxObjectNameDialog_Impl::SetCheckNameHdl(const Link& rLink, bool bCheckImmediately)
 811 {
 812     aCheckNameHdl = rLink;
 813
 814     if(rLink.IsSet())
 815     {
 816         pDlg->SetCheckNameHdl(LINK(this, AbstractSvxObjectNameDialog_Impl, CheckNameHdl), bCheckImmediately);
 817     }
 818     else
 819     {
 820         pDlg->SetCheckNameHdl(Link(), bCheckImmediately);
 821     }
 822 }
 823
 824 IMPL_LINK(AbstractSvxObjectNameDialog_Impl, CheckNameHdl, Window*, EMPTYARG)
 825 {
 826     if(aCheckNameHdl.IsSet())
 827     {
 828         return aCheckNameHdl.Call(this);
 829     }
 830
 831     return 0;
 832 }
 833
 834 ///////////////////////////////////////////////////////////////////////////////////////////////
 835 // #i68101#
 836
 837 void AbstractSvxObjectTitleDescDialog_Impl::GetTitle(String& rTitle)
 838 {
 839     pDlg->GetTitle(rTitle);
 840 }
 841
 842 void AbstractSvxObjectTitleDescDialog_Impl::GetDescription(String& rDescription)
 843 {
 844     pDlg->GetDescription(rDescription);
 845 }
 846
 847 ///////////////////////////////////////////////////////////////////////////////////////////////
 848
 849 //for SvxMessDialog begin
 850 void AbstractSvxMessDialog_Impl::SetButtonText( USHORT nBtnId, const String& rNewTxt )
 851 {
 852     pDlg->SetButtonText( nBtnId, rNewTxt );
 853 }
 854 //for SvxMessDialog end
 855
 856 //for SvxMultiPathDialog begin
 857 String AbstractSvxMultiPathDialog_Impl::GetPath() const
 858 {
 859     return pDlg->GetPath();
 860 }
 861
 862 void AbstractSvxMultiPathDialog_Impl::SetPath( const String& rPath )
 863 {
 864     pDlg->SetPath( rPath );
 865 }
 866
 867 void AbstractSvxMultiPathDialog_Impl::EnableRadioButtonMode()
 868 {
 869     pDlg->EnableRadioButtonMode();
 870 }
 871
 872 void AbstractSvxMultiPathDialog_Impl::SetTitle( const String& rNewTitle )
 873 {
 874     pDlg->SetText( rNewTitle );
 875 }
 876 //for SvxMultiPathDialog end
 877
 878 //for SvxMultiFileDialog begin
 879 String AbstractSvxMultiFileDialog_Impl::GetPath() const
 880 {
 881     return pDlg->GetPath();
 882 }
 883
 884 void AbstractSvxMultiFileDialog_Impl::SetPath( const String& rPath )
 885 {
 886     pDlg->SetPath( rPath );
 887 }
 888
 889 String AbstractSvxMultiFileDialog_Impl::GetFiles() const
 890 {
 891     return pDlg->GetFiles();
 892 }
 893
 894 void AbstractSvxMultiFileDialog_Impl::SetFiles( const String& rPath )
 895 {
 896     pDlg->SetFiles( rPath );
 897 }
 898
 899 void AbstractSvxMultiFileDialog_Impl::SetClassPathMode()
 900 {
 901     pDlg->SetClassPathMode();
 902 }
 903
 904 void AbstractSvxMultiFileDialog_Impl::EnableRadioButtonMode()
 905 {
 906     pDlg->EnableRadioButtonMode();
 907 }
 908
 909 void AbstractSvxMultiFileDialog_Impl::SetTitle( const String& rNewTitle )
 910 {
 911     pDlg->SetText( rNewTitle );
 912 }
 913
 914 void AbstractSvxMultiFileDialog_Impl::SetHelpId( ULONG nHelpId )
 915 {
 916     pDlg->SetHelpId( nHelpId );
 917 }
 918 //for SvxMultiFileDialog end
 919
 920 //for SvxHpLinkDlg begin
 921 Window * AbstractSvxHpLinkDlg_Impl::GetWindow()
 922 {
 923     return (Window *)pDlg;
 924 }
 925
 926 sal_Bool AbstractSvxHpLinkDlg_Impl::QueryClose()
 927 {
 928     return pDlg->QueryClose();
 929 }
 930 //for SvxHpLinkDlg end
 931
 932
 933 //for FmSearchDialog begin
 934 void AbstractFmSearchDialog_Impl::SetFoundHandler(const Link& lnk)
 935 {
 936     pDlg->SetFoundHandler(lnk);
 937 }
 938 void AbstractFmSearchDialog_Impl::SetCanceledNotFoundHdl(const Link& lnk)
 939 {
 940     pDlg->SetCanceledNotFoundHdl(lnk);
 941 }
 942 void AbstractFmSearchDialog_Impl::SetActiveField(const String& strField)
 943 {
 944     pDlg->SetActiveField(strField);
 945 }
 946 //for FmSearchDialog end
 947
 948 //for GraphicFilterDialog begin
 949 Graphic AbstractGraphicFilterDialog_Impl::GetFilteredGraphic( const Graphic& rGraphic, double fScaleX, double fScaleY )
 950 {
 951     return pDlg->GetFilteredGraphic( rGraphic, fScaleX, fScaleY );
 952 }
 953 //for GraphicFilterDialog end
 954
 955 // AbstractSvxAreaTabDialog implementations just forwards everything to the dialog
 956 void AbstractSvxAreaTabDialog_Impl::SetCurPageId( USHORT nId )
 957 {
 958     pDlg->SetCurPageId( nId );
 959 }
 960
 961 const SfxItemSet* AbstractSvxAreaTabDialog_Impl::GetOutputItemSet() const
 962 {
 963     return pDlg->GetOutputItemSet();
 964 }
 965 //add by CHINA001
 966 const USHORT* AbstractSvxAreaTabDialog_Impl::GetInputRanges(const SfxItemPool& pItem )
 967 {
 968     return pDlg->GetInputRanges( pItem );
 969 }
 970 //add by CHINA001
 971 void AbstractSvxAreaTabDialog_Impl::SetInputSet( const SfxItemSet* pInSet )
 972 {
 973      pDlg->SetInputSet( pInSet );
 974 }
 975 //From class Window.
 976 void AbstractSvxAreaTabDialog_Impl::SetText( const XubString& rStr )
 977 {
 978     pDlg->SetText( rStr );
 979 }
 980 String AbstractSvxAreaTabDialog_Impl::GetText() const
 981 {
 982     return pDlg->GetText();
 983 }
 984
 985 void AbstractSvxAreaTabDialog_Impl::DontDeleteColorTable()
 986 {
 987     return pDlg->DontDeleteColorTable();
 988 }
 989 // AbstractSvxAreaTabDialog_Impl end
 990
 991 // add SvxPostItDialog begin
 992 void AbstractSvxPostItDialog_Impl::SetText( const XubString& rStr )
 993 {
 994     pDlg->SetText( rStr );
 995 }
 996 const SfxItemSet* AbstractSvxPostItDialog_Impl::GetOutputItemSet() const
 997 {
 998     return pDlg->GetOutputItemSet();
 999 }
1000 void AbstractSvxPostItDialog_Impl::EnableTravel(BOOL bNext, BOOL bPrev)
1001 {
1002     pDlg->EnableTravel( bNext, bPrev );
1003 }
1004 String AbstractSvxPostItDialog_Impl::GetNote()
1005 {
1006     return pDlg->GetNote();
1007 }
1008 void AbstractSvxPostItDialog_Impl::SetNote(const String& rTxt)
1009 {
1010     pDlg->SetNote( rTxt );
1011 }
1012 void AbstractSvxPostItDialog_Impl::ShowLastAuthor(const String& rAuthor, const String& rDate)
1013 {
1014     pDlg->ShowLastAuthor( rAuthor, rDate );
1015 }
1016 void AbstractSvxPostItDialog_Impl::DontChangeAuthor()
1017 {
1018     pDlg->DontChangeAuthor();
1019 }
1020 void AbstractSvxPostItDialog_Impl::HideAuthor()
1021 {
1022     pDlg->HideAuthor();
1023 }
1024 void AbstractSvxPostItDialog_Impl::SetReadonlyPostIt(BOOL bDisable)
1025 {
1026     pDlg->SetReadonlyPostIt( bDisable );
1027 }
1028 BOOL AbstractSvxPostItDialog_Impl::IsOkEnabled() const
1029 {
1030     return pDlg->IsOkEnabled();
1031 }
1032 void AbstractSvxPostItDialog_Impl::SetNextHdl( const Link& rLink )
1033 {
1034     aNextHdl = rLink;
1035     if( rLink.IsSet() )
1036         pDlg->SetNextHdl( LINK(this, AbstractSvxPostItDialog_Impl, NextHdl ) );
1037     else
1038         pDlg->SetNextHdl( Link() );
1039 }
1040 void AbstractSvxPostItDialog_Impl::SetPrevHdl( const Link& rLink )
1041 {
1042     aPrevHdl = rLink;
1043     if( rLink.IsSet() )
1044         pDlg->SetPrevHdl( LINK(this, AbstractSvxPostItDialog_Impl, PrevHdl ) );
1045     else
1046         pDlg->SetPrevHdl( Link() );
1047 }
1048 IMPL_LINK( AbstractSvxPostItDialog_Impl, NextHdl, Window*, EMPTYARG )
1049 {
1050     if( aNextHdl.IsSet() )
1051         aNextHdl.Call(this);
1052     return 0;
1053 }
1054 IMPL_LINK( AbstractSvxPostItDialog_Impl, PrevHdl, Window*, EMPTYARG )
1055 {
1056     if( aPrevHdl.IsSet() )
1057         aPrevHdl.Call(this);
1058     return 0;
1059 }
1060 Window * AbstractSvxPostItDialog_Impl::GetWindow()
1061 {
1062     return (Window *)pDlg;
1063 }
1064
1065 // SvxPostItDialog end
1066
1067 //--------------------------------------------------------------
1068 // Create dialogs with simplest interface
1069 VclAbstractDialog* AbstractDialogFactory_Impl::CreateVclDialog( Window* pParent, sal_uInt32 nResId )
1070 {
1071     Dialog* pDlg=NULL;
1072     switch ( nResId )
1073     {
1074         case SID_OPTIONS_TREEDIALOG :
1075         case SID_OPTIONS_DATABASES :
1076         case SID_LANGUAGE_OPTIONS :
1077         {
1078             bool bActivateLastSelection = false;
1079             if (nResId == SID_OPTIONS_TREEDIALOG)
1080                 bActivateLastSelection = true;
1081             Reference< frame::XFrame > xFrame;
1082             OfaTreeOptionsDialog* pOptDlg = new OfaTreeOptionsDialog( pParent, xFrame, bActivateLastSelection );
1083             if (nResId == SID_OPTIONS_DATABASES)
1084             {
1085                 pOptDlg->ActivatePage(SID_SB_DBREGISTEROPTIONS);
1086             }
1087             else if (nResId == SID_LANGUAGE_OPTIONS)
1088             {
1089                 //open the tab page "tools/options/languages"
1090                 pOptDlg->ActivatePage(OFA_TP_LANGUAGES_FOR_SET_DOCUMENT_LANGUAGE);
1091             }
1092             pDlg = pOptDlg;
1093         }
1094         break;
1095         default:
1096             break;
1097     }
1098
1099     if ( pDlg )
1100         return new VclAbstractDialog_Impl( pDlg );
1101     return 0;
1102 }
1103
1104 // dialogs that use SfxBindings
1105 VclAbstractDialog* AbstractDialogFactory_Impl::CreateSfxDialog( Window* /*pParent*/, const SfxBindings&, sal_uInt32 )
1106 {
1107     return 0;
1108 }
1109
1110 VclAbstractDialog* AbstractDialogFactory_Impl::CreateFrameDialog(
1111     Window* pParent, const Reference< frame::XFrame >& rxFrame,
1112     sal_uInt32 nResId, const String& rParameter )
1113 {
1114     Dialog* pDlg = NULL;
1115     if ( SID_OPTIONS_TREEDIALOG == nResId || SID_OPTIONS_DATABASES == nResId )
1116     {
1117         // only activate last page if we dont want to activate a special page
1118         bool bActivateLastSelection = ( nResId != SID_OPTIONS_DATABASES && rParameter.Len() == 0 );
1119         OfaTreeOptionsDialog* pOptDlg = new OfaTreeOptionsDialog( pParent, rxFrame, bActivateLastSelection );
1120         if ( nResId == SID_OPTIONS_DATABASES )
1121             pOptDlg->ActivatePage(SID_SB_DBREGISTEROPTIONS);
1122         else if ( rParameter.Len() > 0 )
1123             pOptDlg->ActivatePage( rParameter );
1124         pDlg = pOptDlg;
1125     }
1126
1127     if ( pDlg )
1128         return new VclAbstractDialog_Impl( pDlg );
1129     else
1130         return NULL;
1131 }
1132
1133 // TabDialog outside the drawing layer
1134 SfxAbstractTabDialog* AbstractDialogFactory_Impl::CreateTabDialog( sal_uInt32 nResId,
1135                                                 Window* pParent,
1136                                                 const SfxItemSet* pAttrSet,
1137                                                 SfxViewFrame* ,
1138                                                 bool /*bEditFmt*/,
1139                                                 const String * )
1140 {
1141     SfxTabDialog* pDlg=NULL;
1142     switch ( nResId )
1143     {
1144         case RID_OFA_AUTOCORR_DLG :
1145             pDlg = new OfaAutoCorrDlg( pParent, pAttrSet );
1146             break;
1147         case RID_SVXDLG_CUSTOMIZE :
1148             pDlg = new SvxConfigDialog( pParent, pAttrSet );
1149             break;
1150         default:
1151             break;
1152     }
1153
1154     if ( pDlg )
1155         return new AbstractTabDialog_Impl( pDlg );
1156     return 0;
1157 }
1158
1159 SfxAbstractTabDialog* AbstractDialogFactory_Impl::CreateTabDialog( sal_uInt32 nResId,
1160                                                 Window* pParent,
1161                                                 const SfxItemSet* pAttrSet,
1162                                                 const Reference< frame::XFrame >& xViewFrame,
1163                                                 bool /*bEditFmt*/,
1164                                                 const String * )
1165 {
1166     SfxTabDialog* pDlg=NULL;
1167     switch ( nResId )
1168     {
1169         case RID_OFA_AUTOCORR_DLG :
1170             pDlg = new OfaAutoCorrDlg( pParent, pAttrSet );
1171             break;
1172         case RID_SVXDLG_CUSTOMIZE :
1173             {
1174                 SvxConfigDialog* pDlg1 = new SvxConfigDialog( pParent, pAttrSet );
1175                 pDlg1->SetFrame(xViewFrame);
1176                 pDlg = (SfxTabDialog*)pDlg1;
1177             }
1178             break;
1179         default:
1180             break;
1181     }
1182
1183     if ( pDlg )
1184         return new AbstractTabDialog_Impl( pDlg );
1185     return 0;
1186 }
1187
1188 // TabDialog that use functionality of the drawing layer
1189 SfxAbstractTabDialog* AbstractDialogFactory_Impl::CreateTextTabDialog( Window* pParent,
1190                                             const SfxItemSet* pAttrSet,
1191                                             sal_uInt32 nResId,
1192                                             SdrView* pView,
1193                                             SdrModel* )
1194 {
1195     SfxTabDialog* pDlg=NULL;
1196     switch ( nResId )
1197     {
1198         case RID_SVXDLG_TEXT :
1199             pDlg = new SvxTextTabDialog( pParent, pAttrSet, pView );
1200             break;
1201         default:
1202             break;
1203     }
1204
1205     if ( pDlg )
1206         return new AbstractTabDialog_Impl( pDlg );
1207     return 0;
1208 }
1209
1210 //TabDialog that use functionality of the drawing layer and add AnchorTypes  -- for SvxCaptionTabDialog CHINA001
1211 AbstractSvxCaptionDialog*       AbstractDialogFactory_Impl::CreateCaptionDialog( Window* pParent,
1212                                             const SdrView* pView,
1213                                             sal_uInt32 nResId,
1214                                             USHORT nAnchorTypes )
1215 {
1216     SvxCaptionTabDialog* pDlg=NULL;
1217     switch ( nResId )
1218     {
1219         case RID_SVXDLG_CAPTION :
1220             pDlg = new SvxCaptionTabDialog( pParent, pView, nAnchorTypes );
1221             break;
1222         default:
1223             break;
1224     }
1225
1226     if ( pDlg )
1227         return new AbstractSvxCaptionDialog_Impl( pDlg );
1228     return 0;
1229 }
1230
1231 AbstractSvxDistributeDialog*    AbstractDialogFactory_Impl::CreateSvxDistributeDialog(Window* pParent,
1232                                             const SfxItemSet& rAttr,
1233                                             sal_uInt32 nResId,
1234                                             SvxDistributeHorizontal eHor ,
1235                                             SvxDistributeVertical eVer)
1236 {
1237     SvxDistributeDialog* pDlg=NULL;
1238     switch ( nResId )
1239     {
1240         case RID_SVXPAGE_DISTRIBUTE :
1241             pDlg = new SvxDistributeDialog( pParent, rAttr, eHor, eVer);
1242             break;
1243         default:
1244             break;
1245     }
1246
1247     if ( pDlg )
1248         return new AbstractSvxDistributeDialog_Impl( pDlg );
1249     return 0;
1250 }
1251
1252 AbstractHangulHanjaConversionDialog* AbstractDialogFactory_Impl::CreateHangulHanjaConversionDialog(Window* pParent,
1253                                                                                                    HangulHanjaConversion::ConversionDirection _ePrimaryDirection,
1254                                                                                                     sal_uInt32 nResId)
1255 {
1256     HangulHanjaConversionDialog* pDlg=NULL;
1257     switch ( nResId )
1258     {
1259         case RID_SVX_MDLG_HANGULHANJA :
1260             pDlg = new HangulHanjaConversionDialog( pParent, _ePrimaryDirection);
1261             break;
1262         default:
1263             break;
1264     }
1265
1266     if ( pDlg )
1267         return new AbstractHangulHanjaConversionDialog_Impl( pDlg );
1268     return 0;
1269 }
1270
1271 AbstractFmShowColsDialog * AbstractDialogFactory_Impl::CreateFmShowColsDialog( Window* pParent,  //add for FmShowColsDialog
1272                                              sal_uInt32 nResId)
1273 {
1274    FmShowColsDialog* pDlg=NULL;
1275     switch ( nResId )
1276     {
1277         case RID_SVX_DLG_SHOWGRIDCOLUMNS :
1278             pDlg = new FmShowColsDialog( pParent);
1279             break;
1280         default:
1281             break;
1282     }
1283
1284     if ( pDlg )
1285         return new AbstractFmShowColsDialog_Impl( pDlg );
1286     return 0;
1287 }
1288 AbstractSvxZoomDialog * AbstractDialogFactory_Impl::CreateSvxZoomDialog( Window* pParent,  //add for SvxZoomDialog
1289                                             const SfxItemSet& rCoreSet,
1290                                             sal_uInt32 nResId)
1291 {
1292    SvxZoomDialog* pDlg=NULL;
1293     switch ( nResId )
1294     {
1295         case RID_SVXDLG_ZOOM :
1296             pDlg = new SvxZoomDialog( pParent, rCoreSet);
1297             break;
1298         default:
1299             break;
1300     }
1301
1302     if ( pDlg )
1303         return new AbstractSvxZoomDialog_Impl( pDlg );
1304     return 0;
1305 }
1306
1307 /*-- 04.05.2004 08:18:17---------------------------------------------------
1308
1309   -----------------------------------------------------------------------*/
1310 AbstractSpellDialog *  AbstractDialogFactory_Impl::CreateSvxSpellDialog(
1311                         Window* pParent,
1312                         SfxBindings* pBindings,
1313                         svx::SpellDialogChildWindow* pSpellChildWindow )
1314 {
1315     svx::SpellDialog* pDlg = new svx::SpellDialog(pSpellChildWindow, pParent, pBindings);
1316     return new AbstractSpellDialog_Impl(pDlg);
1317 }
1318
1319 //CHINA001 GalleryDialog start
1320 VclAbstractRefreshableDialog * AbstractDialogFactory_Impl::CreateActualizeProgressDialog( Window* pParent,  //add for ActualizeProgress
1321                                             GalleryTheme* pThm,
1322                                             sal_uInt32 nResId)
1323 {
1324    Dialog* pDlg=NULL;
1325     switch ( nResId )
1326     {
1327         case RID_SVXDLG_GALLERY_ACTUALIZE_PROGRESS :
1328             pDlg = new ActualizeProgress( pParent, pThm);
1329             break;
1330         default:
1331             break;
1332     }
1333
1334     if ( pDlg )
1335         return new VclAbstractRefreshableDialog_Impl( pDlg );
1336     return 0;
1337 }
1338
1339 AbstractSearchProgress * AbstractDialogFactory_Impl::CreateSearchProgressDialog( Window* pParent,  //add for SearchProgress
1340                                             const INetURLObject& rStartURL,
1341                                             sal_uInt32 nResId)
1342 {
1343    SearchProgress* pDlg=NULL;
1344     switch ( nResId )
1345     {
1346         case RID_SVXDLG_GALLERY_SEARCH_PROGRESS :
1347             pDlg = new SearchProgress( pParent, rStartURL);
1348             break;
1349         default:
1350             break;
1351     }
1352
1353     if ( pDlg )
1354         return new AbstractSearchProgress_Impl( pDlg );
1355     return 0;
1356 }
1357
1358 AbstractTakeProgress * AbstractDialogFactory_Impl::CreateTakeProgressDialog( Window* pParent,  //add for TakeProgress
1359                                             sal_uInt32 nResId)
1360 {
1361    TakeProgress* pDlg=NULL;
1362     switch ( nResId )
1363     {
1364         case RID_SVXDLG_GALLERY_TAKE_PROGRESS :
1365             pDlg = new TakeProgress( pParent );
1366             break;
1367         default:
1368             break;
1369     }
1370
1371     if ( pDlg )
1372         return new AbstractTakeProgress_Impl( pDlg );
1373     return 0;
1374 }
1375
1376 VclAbstractDialog*
1377 AbstractDialogFactory_Impl::CreateScriptErrorDialog(
1378     Window* pParent, ::com::sun::star::uno::Any aException )
1379 {
1380     return new SvxScriptErrorDialog( pParent, aException );
1381 }
1382
1383 AbstractScriptSelectorDialog*
1384 AbstractDialogFactory_Impl::CreateScriptSelectorDialog(
1385     Window* pParent, BOOL bShowSlots, const Reference< frame::XFrame >& _rxFrame )
1386 {
1387     SvxScriptSelectorDialog* pDlg = NULL;
1388
1389     pDlg = new SvxScriptSelectorDialog( pParent, bShowSlots, _rxFrame );
1390
1391     if (pDlg)
1392     {
1393         return new AbstractScriptSelectorDialog_Impl( pDlg );
1394     }
1395     return 0;
1396 }
1397
1398 String AbstractScriptSelectorDialog_Impl::GetScriptURL() const
1399 {
1400     if (pDlg)
1401         return pDlg->GetScriptURL();
1402     return String();
1403 }
1404
1405 void AbstractScriptSelectorDialog_Impl::SetRunLabel()
1406 {
1407     if (pDlg)
1408         pDlg->SetRunLabel();
1409     return;
1410 }
1411
1412 VclAbstractDialog * AbstractDialogFactory_Impl::CreateSvxScriptOrgDialog( Window* pParent,  //add for SvxScriptOrgDialog
1413                                             const String& rLanguage)
1414 {
1415     Dialog* pDlg=NULL;
1416
1417     pDlg = new SvxScriptOrgDialog( pParent, rLanguage);
1418
1419     if ( pDlg )
1420         return new VclAbstractDialog_Impl( pDlg );
1421     return 0;
1422 }
1423
1424 AbstractTitleDialog * AbstractDialogFactory_Impl::CreateTitleDialog( Window* pParent,  //add for TitleDialog
1425                                             const String& rOldText,
1426                                             sal_uInt32 nResId)
1427 {
1428    TitleDialog* pDlg=NULL;
1429     switch ( nResId )
1430     {
1431         case RID_SVXDLG_GALLERY_TITLE :
1432             pDlg = new TitleDialog( pParent, rOldText);
1433             break;
1434         default:
1435             break;
1436     }
1437
1438     if ( pDlg )
1439         return new AbstractTitleDialog_Impl( pDlg );
1440     return 0;
1441 }
1442
1443 AbstractGalleryIdDialog * AbstractDialogFactory_Impl::CreateGalleryIdDialog( Window* pParent,  //add for SvxZoomDialog
1444                                             GalleryTheme* pThm,
1445                                             sal_uInt32 nResId)
1446 {
1447    GalleryIdDialog* pDlg=NULL;
1448     switch ( nResId )
1449     {
1450         case RID_SVXDLG_GALLERY_THEMEID :
1451             pDlg = new GalleryIdDialog( pParent, pThm);
1452             break;
1453         default:
1454             break;
1455     }
1456
1457     if ( pDlg )
1458         return new AbstractGalleryIdDialog_Impl( pDlg );
1459     return 0;
1460 }
1461
1462 VclAbstractDialog2 * AbstractDialogFactory_Impl::CreateGalleryThemePropertiesDialog( Window* pParent,  //add for GalleryThemeProperties
1463                                             ExchangeData* pData,
1464                                             SfxItemSet* pItemSet,
1465                                             sal_uInt32 nResId)
1466 {
1467     Dialog* pDlg=NULL;
1468     switch ( nResId )
1469     {
1470         case RID_SVXTABDLG_GALLERYTHEME :
1471             pDlg = new GalleryThemeProperties( pParent, pData, pItemSet);
1472             break;
1473         default:
1474             break;
1475     }
1476
1477     if ( pDlg )
1478         return new VclAbstractDialog2_Impl( pDlg );
1479     return 0;
1480 }
1481 //CHINA001 GalleryDialog end
1482
1483 AbstractURLDlg * AbstractDialogFactory_Impl::CreateURLDialog( Window* pParent,  //add for URLDlg
1484                                             const String& rURL, const String& rAltText, const String& rDescription,
1485                                             const String& rTarget, const String& rName,
1486                                             TargetList& rTargetList )
1487 {
1488     URLDlg* pDlg = new URLDlg( pParent, rURL, rAltText, rDescription, rTarget, rName, rTargetList);
1489     return new AbstractURLDlg_Impl( pDlg );
1490 }
1491 //CHINA001 URLDlg end
1492
1493 //CHINA001 SvxHlinkDlgMarkWnd begin
1494 AbstractSvxHlinkDlgMarkWnd* AbstractDialogFactory_Impl::CreateSvxHlinkDlgMarkWndDialog( SvxHyperlinkTabPageBase* pParent, sal_uInt32 nResId )
1495 {
1496     SvxHlinkDlgMarkWnd* pDlg=NULL;
1497     switch ( nResId )
1498     {
1499         case RID_SVXFLOAT_HYPERLINK_MARKWND :
1500             pDlg = new  SvxHlinkDlgMarkWnd( pParent );
1501             break;
1502         default:
1503             break;
1504     }
1505
1506     if ( pDlg )
1507         return new AbstractSvxHlinkDlgMarkWnd_Impl( pDlg );
1508     return 0;
1509 }
1510 //CHINA001 SvxHlinkDlgMarkWnd end
1511
1512 SfxAbstractDialog* AbstractDialogFactory_Impl::CreateSfxDialog( sal_uInt32 nResId,
1513                                             Window* pParent,
1514                                             const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame >& ,
1515                                             const SfxItemSet* pAttrSet )
1516 {
1517     SfxModalDialog* pDlg=NULL;
1518     switch ( nResId )
1519     {
1520         case RID_SVXDLG_CHARMAP :
1521             pDlg = new SvxCharacterMap( pParent, TRUE, pAttrSet );
1522             break;
1523         default:
1524             break;
1525     }
1526
1527     if ( pDlg )
1528         return new AbstractSfxDialog_Impl( pDlg );
1529     return 0;
1530 }
1531 //CHINA001  SvxCharacterMap end
1532
1533 //CHINA001  SvxSearchFormatDialog begin
1534 SfxAbstractTabDialog* AbstractDialogFactory_Impl::CreateTabItemDialog( Window* pParent,
1535                                             const SfxItemSet& rSet,
1536                                             sal_uInt32 nResId)
1537 {
1538     SfxTabDialog* pDlg=NULL;
1539     switch ( nResId )
1540     {
1541         case RID_SVXDLG_SEARCHFORMAT :
1542             pDlg = new SvxSearchFormatDialog( pParent, rSet );
1543             break;
1544         default:
1545             break;
1546     }
1547
1548     if ( pDlg )
1549         return new AbstractTabDialog_Impl( pDlg );
1550     return 0;
1551 }
1552 //CHINA001  SvxSearchFormatDialog end
1553
1554 //CHINA001  SvxSearchAttributeDialog begin
1555 VclAbstractDialog*              AbstractDialogFactory_Impl::CreateSvxSearchAttributeDialog( Window* pParent,
1556                                             SearchAttrItemList& rLst,
1557                                             const USHORT* pWhRanges,
1558                                             sal_uInt32 nResId ) //add for SvxSearchAttributeDialog
1559 {
1560     Dialog* pDlg=NULL;
1561     switch ( nResId )
1562     {
1563         case RID_SVXDLG_SEARCHATTR :
1564             pDlg = new SvxSearchAttributeDialog( pParent, rLst, pWhRanges);
1565             break;
1566         default:
1567             break;
1568     }
1569
1570     if ( pDlg )
1571         return new VclAbstractDialog_Impl( pDlg );
1572     return 0;
1573 }
1574 //CHINA001  SvxSearchAttributeDialog end
1575
1576 //CHINA001  SvxSearchSimilarityDialog begin
1577 AbstractSvxSearchSimilarityDialog * AbstractDialogFactory_Impl::CreateSvxSearchSimilarityDialog( Window* pParent,
1578                                                             BOOL bRelax,
1579                                                             USHORT nOther,
1580                                                             USHORT nShorter,
1581                                                             USHORT nLonger)
1582 {
1583     SvxSearchSimilarityDialog* pDlg = new SvxSearchSimilarityDialog( pParent, bRelax, nOther, nShorter, nLonger );
1584     if ( pDlg )
1585         return new AbstractSvxSearchSimilarityDialog_Impl( pDlg );
1586     return NULL;
1587 }
1588 //CHINA001  SvxSearchSimilarityDialog end
1589
1590 //CHINA001  SvxBorderBackgroundDlg begin
1591 SfxAbstractTabDialog* AbstractDialogFactory_Impl::CreateSvxBorderBackgroundDlg( Window* pParent,
1592                                             const SfxItemSet& rCoreSet,
1593                                             sal_uInt32 nResId,
1594                                             BOOL bEnableSelector)
1595 {
1596     SfxTabDialog* pDlg=NULL;
1597     switch ( nResId )
1598     {
1599         case RID_SVXDLG_BBDLG :
1600             pDlg = new SvxBorderBackgroundDlg( pParent, rCoreSet, bEnableSelector);
1601             break;
1602         default:
1603             break;
1604     }
1605
1606     if ( pDlg )
1607         return new AbstractTabDialog_Impl( pDlg );
1608     return 0;
1609 }
1610 //CHINA001  SvxBorderBackgroundDlg end
1611
1612 //CHINA001  SvxTransformTabDialog begin
1613 AbstractSvxTransformTabDialog* AbstractDialogFactory_Impl::CreateSvxTransformTabDialog( Window* pParent,
1614                                                                               const SfxItemSet* pAttr,
1615                                                                                 const SdrView* pView,
1616                                                                                 sal_uInt32 nResId,
1617                                                                                 USHORT nAnchorTypes )
1618 {
1619     SvxTransformTabDialog* pDlg=NULL;
1620     switch ( nResId )
1621     {
1622         case RID_SVXDLG_TRANSFORM :
1623             pDlg = new SvxTransformTabDialog( pParent, pAttr,pView, nAnchorTypes);
1624             break;
1625         default:
1626             break;
1627     }
1628
1629     if ( pDlg )
1630         return new AbstractSvxTransformTabDialog_Impl( pDlg );
1631     return 0;
1632 }
1633
1634 //CHINA001  SvxTransformTabDialog end
1635
1636 //CHINA001  SchTransformTabDialog begin
1637 SfxAbstractTabDialog* AbstractDialogFactory_Impl::CreateSchTransformTabDialog( Window* pParent,
1638                                                                 const SfxItemSet* pAttr,
1639                                                                 const SdrView* pSdrView,
1640                                                                 sal_uInt32 nResId,
1641                                                                 bool bSizeTabPage
1642                                                                 )
1643 {
1644     SfxTabDialog* pDlg=NULL;
1645     switch ( nResId )
1646     {
1647         case RID_SCH_TransformTabDLG_SVXPAGE_ANGLE :
1648             {
1649             pDlg = new SvxTransformTabDialog( pParent, pAttr,pSdrView, bSizeTabPage ? SVX_OBJ_NOPROTECT :  SVX_OBJ_NOPROTECT|SVX_OBJ_NORESIZE);
1650             pDlg->RemoveTabPage( RID_SVXPAGE_ANGLE );
1651             pDlg->RemoveTabPage( RID_SVXPAGE_SLANT );
1652             }
1653             break;
1654         case RID_SCH_TransformTabDLG_SVXPAGE_SLANT:
1655             {
1656             pDlg = new  SvxTransformTabDialog( pParent, pAttr,pSdrView, bSizeTabPage ? SVX_OBJ_NOPROTECT :  SVX_OBJ_NOPROTECT|SVX_OBJ_NORESIZE);
1657             pDlg->RemoveTabPage( RID_SVXPAGE_SLANT );
1658             }
1659             break;
1660         default:
1661             break;
1662     }
1663
1664     if ( pDlg )
1665         return new AbstractTabDialog_Impl( pDlg );
1666     return 0;
1667 }
1668 //CHINA001  SchTransformTabDialog end
1669
1670 //CHINA001  SvxJSearchOptionsDialog begin
1671 AbstractSvxJSearchOptionsDialog * AbstractDialogFactory_Impl::CreateSvxJSearchOptionsDialog( Window* pParent,
1672                                                             const SfxItemSet& rOptionsSet, USHORT nUniqueId,
1673                                                             INT32 nInitialFlags,
1674                                                             sal_uInt32 nResId)
1675 {
1676     SvxJSearchOptionsDialog* pDlg=NULL;
1677     switch ( nResId )
1678     {
1679         case RID_SVXPAGE_JSEARCH_OPTIONS :
1680             pDlg = new SvxJSearchOptionsDialog( pParent, rOptionsSet, nUniqueId, nInitialFlags );
1681             break;
1682         default:
1683             break;
1684     }
1685
1686     if ( pDlg )
1687         return new AbstractSvxJSearchOptionsDialog_Impl( pDlg );
1688     return 0;
1689 }
1690 //CHINA001  SvxJSearchOptionsDialog end
1691
1692 //CHINA001  FmInputRecordNoDialog begin
1693 AbstractFmInputRecordNoDialog * AbstractDialogFactory_Impl::CreateFmInputRecordNoDialog( Window* pParent,
1694                                                             sal_uInt32 nResId)
1695 {
1696     FmInputRecordNoDialog* pDlg=NULL;
1697     switch ( nResId )
1698     {
1699         case RID_SVX_DLG_INPUTRECORDNO :
1700             pDlg = new FmInputRecordNoDialog( pParent );
1701             break;
1702         default:
1703             break;
1704     }
1705
1706     if ( pDlg )
1707         return new AbstractFmInputRecordNoDialog_Impl( pDlg );
1708     return 0;
1709 }
1710 //CHINA001  FmInputRecordNoDialog end
1711
1712 //CHINA001  SvxNewDictionaryDialog begin
1713 AbstractSvxNewDictionaryDialog * AbstractDialogFactory_Impl::CreateSvxNewDictionaryDialog( Window* pParent,
1714                                             ::Reference< ::com::sun::star::linguistic2::XSpellChecker1 >  &xSpl,
1715                                             sal_uInt32 nResId )
1716 {
1717     SvxNewDictionaryDialog* pDlg=NULL;
1718     switch ( nResId )
1719     {
1720         case RID_SFXDLG_NEWDICT :
1721             pDlg = new SvxNewDictionaryDialog( pParent, xSpl );
1722             break;
1723         default:
1724             break;
1725     }
1726
1727     if ( pDlg )
1728         return new AbstractSvxNewDictionaryDialog_Impl( pDlg );
1729     return 0;
1730 }
1731 //CHINA001  SvxNewDictionaryDialog end
1732
1733 //CHINA001  SvxEditDictionaryDialog begin
1734 VclAbstractDialog*              AbstractDialogFactory_Impl::CreateSvxEditDictionaryDialog( Window* pParent,
1735                                             const String& rName,
1736                                             ::Reference< ::com::sun::star::linguistic2::XSpellChecker1> &xSpl,
1737                                             sal_uInt32 nResId )
1738 {
1739     Dialog* pDlg=NULL;
1740     switch ( nResId )
1741     {
1742         case RID_SFXDLG_EDITDICT :
1743             pDlg = new SvxEditDictionaryDialog( pParent, rName, xSpl );
1744             break;
1745         default:
1746             break;
1747     }
1748
1749     if ( pDlg )
1750         return new VclAbstractDialog_Impl( pDlg );
1751     return 0;
1752 }
1753 //CHINA001  SvxEditDictionaryDialog end
1754
1755 //CHINA001  SvxNameDialog begin
1756 AbstractSvxNameDialog * AbstractDialogFactory_Impl::CreateSvxNameDialog( Window* pParent,
1757                                     const String& rName, const String& rDesc,
1758                                     sal_uInt32 nResId )
1759 {
1760     SvxNameDialog* pDlg=NULL;
1761     switch ( nResId )
1762     {
1763         case RID_SVXDLG_NAME :
1764             pDlg = new SvxNameDialog( pParent, rName, rDesc );
1765             break;
1766         default:
1767             break;
1768     }
1769
1770     if ( pDlg )
1771         return new AbstractSvxNameDialog_Impl( pDlg );
1772     return 0;
1773 }
1774 //CHINA001  SvxNameDialog end
1775
1776 ///////////////////////////////////////////////////////////////////////////////////////////////
1777 // #i68101#
1778
1779 AbstractSvxObjectNameDialog* AbstractDialogFactory_Impl::CreateSvxObjectNameDialog(Window* pParent, const String& rName, sal_uInt32 nResId)
1780 {
1781     return ((RID_SVXDLG_OBJECT_NAME == nResId)
1782         ? new AbstractSvxObjectNameDialog_Impl(new SvxObjectNameDialog(pParent, rName))
1783         : NULL);
1784 }
1785
1786 ///////////////////////////////////////////////////////////////////////////////////////////////
1787 // #i68101#
1788
1789 AbstractSvxObjectTitleDescDialog* AbstractDialogFactory_Impl::CreateSvxObjectTitleDescDialog(Window* pParent, const String& rTitle, const String& rDescription, sal_uInt32 nResId)
1790 {
1791     return ((RID_SVXDLG_OBJECT_TITLE_DESC == nResId)
1792         ? new AbstractSvxObjectTitleDescDialog_Impl(new SvxObjectTitleDescDialog(pParent, rTitle, rDescription))
1793         : NULL);
1794 }
1795
1796 ///////////////////////////////////////////////////////////////////////////////////////////////
1797
1798 //CHINA001  SvxMessDialog begin
1799 AbstractSvxMessDialog * AbstractDialogFactory_Impl::CreateSvxMessDialog( Window* pParent, sal_uInt32 nResId,
1800                                     const String& rText, const String& rDesc, Image* pImg )
1801 {
1802     SvxMessDialog* pDlg=NULL;
1803     switch ( nResId )
1804     {
1805         case RID_SVXDLG_MESSBOX :
1806             pDlg = new SvxMessDialog( pParent, rText, rDesc, pImg );
1807             break;
1808         default:
1809             break;
1810     }
1811
1812     if ( pDlg )
1813         return new AbstractSvxMessDialog_Impl( pDlg );
1814     return 0;
1815 }
1816 //CHINA001  SvxMessDialog end
1817
1818 //CHINA001  SvxMultiPathDialog begin
1819 AbstractSvxMultiPathDialog * AbstractDialogFactory_Impl::CreateSvxMultiPathDialog( Window* pParent, sal_uInt32 nResId,
1820                                                 BOOL bEmptyAllowed )
1821 {
1822     SvxMultiPathDialog* pDlg=NULL;
1823     switch ( nResId )
1824     {
1825         case RID_SVXDLG_MULTIPATH :
1826             pDlg = new SvxMultiPathDialog( pParent, bEmptyAllowed );
1827             break;
1828         default:
1829             break;
1830     }
1831
1832     if ( pDlg )
1833         return new AbstractSvxMultiPathDialog_Impl( pDlg );
1834     return 0;
1835 }
1836 //CHINA001  SvxMultiPathDialog end
1837
1838 //CHINA001  SvxMultiFileDialog begin
1839 AbstractSvxMultiFileDialog * AbstractDialogFactory_Impl::CreateSvxMultiFileDialog( Window* pParent, sal_uInt32 nResId,
1840                                                 BOOL bEmptyAllowed )
1841 {
1842     SvxMultiFileDialog* pDlg=NULL;
1843     switch ( nResId )
1844     {
1845         case RID_SVXDLG_MULTIPATH :
1846             pDlg = new SvxMultiFileDialog( pParent, bEmptyAllowed );
1847             break;
1848         default:
1849             break;
1850     }
1851
1852     if ( pDlg )
1853         return new AbstractSvxMultiFileDialog_Impl( pDlg );
1854     return 0;
1855 }
1856 //CHINA001  SvxMultiFileDialog end
1857
1858 //CHINA001  SvxHpLinkDlg begin
1859 AbstractSvxHpLinkDlg * AbstractDialogFactory_Impl::CreateSvxHpLinkDlg (Window* pParent,  //add for SvxMultiFileDialog
1860                                             SfxBindings* pBindings,
1861                                             sal_uInt32 nResId)
1862 {
1863     SvxHpLinkDlg* pDlg=NULL;
1864     switch ( nResId )
1865     {
1866         case SID_HYPERLINK_DIALOG :
1867             pDlg = new SvxHpLinkDlg( pParent, pBindings );
1868             break;
1869         default:
1870             break;
1871     }
1872
1873     if ( pDlg )
1874         return new AbstractSvxHpLinkDlg_Impl( pDlg );
1875     return 0;
1876 }
1877 //CHINA001  SvxHpLinkDlg end
1878
1879 //CHINA001  FmSearchDialog begin
1880 AbstractFmSearchDialog*  AbstractDialogFactory_Impl::CreateFmSearchDialog(Window* pParent, //add for FmSearchDialog
1881                                                         const String& strInitialText,
1882                                                         const ::std::vector< String >& _rContexts,
1883                                                         sal_Int16 nInitialContext,
1884                                                         const Link& lnkContextSupplier)
1885 {
1886     FmSearchDialog* pDlg = new FmSearchDialog( pParent, strInitialText, _rContexts, nInitialContext, lnkContextSupplier );
1887     if ( pDlg )
1888         return new AbstractFmSearchDialog_Impl( pDlg );
1889     return 0;
1890 }
1891
1892 //CHINA001 FmSearchDialog end
1893
1894 //CHINA001  GraphicFilterEmboss begin
1895 AbstractGraphicFilterDialog * AbstractDialogFactory_Impl::CreateGraphicFilterEmboss (Window* pParent,  //add for GraphicFilterEmboss
1896                                             const Graphic& rGraphic,
1897                                             RECT_POINT eLightSource,
1898                                             sal_uInt32 nResId)
1899 {
1900     GraphicFilterDialog* pDlg=NULL;
1901     switch ( nResId )
1902     {
1903         case RID_SVX_GRFFILTER_DLG_EMBOSS :
1904             pDlg = new GraphicFilterEmboss( pParent, rGraphic, eLightSource );
1905             break;
1906         default:
1907             break;
1908     }
1909
1910     if ( pDlg )
1911         return new AbstractGraphicFilterDialog_Impl( pDlg );
1912     return 0;
1913 }
1914 //CHINA001  GraphicFilterEmboss end
1915
1916 //CHINA001  GraphicFilterPoster & GraphicFilterSepia begin
1917 AbstractGraphicFilterDialog * AbstractDialogFactory_Impl::CreateGraphicFilterPosterSepia (Window* pParent,  //add for GraphicFilterPoster & GraphicFilterSepia
1918                                             const Graphic& rGraphic,
1919                                             USHORT nCount,
1920                                             sal_uInt32 nResId)
1921 {
1922     GraphicFilterDialog* pDlg=NULL;
1923     switch ( nResId )
1924     {
1925         case RID_SVX_GRFFILTER_DLG_POSTER :
1926             pDlg = new GraphicFilterPoster( pParent, rGraphic, nCount );
1927             break;
1928         case RID_SVX_GRFFILTER_DLG_SEPIA :
1929             pDlg = new GraphicFilterSepia( pParent, rGraphic, nCount );
1930             break;
1931
1932         default:
1933             break;
1934     }
1935
1936     if ( pDlg )
1937         return new AbstractGraphicFilterDialog_Impl( pDlg );
1938     return 0;
1939 }
1940 //CHINA001  GraphicFilterPoster & GraphicFilterSepia end
1941
1942 //CHINA001  GraphicFilterSolarize begin
1943 AbstractGraphicFilterDialog * AbstractDialogFactory_Impl::CreateGraphicFilterSolarize (Window* pParent,  //add for GraphicFilterSolarize
1944                                             const Graphic& rGraphic,
1945                                             BYTE nGreyThreshold, BOOL bInvert,
1946                                             sal_uInt32 nResId)
1947 {
1948     GraphicFilterDialog* pDlg=NULL;
1949     switch ( nResId )
1950     {
1951         case RID_SVX_GRFFILTER_DLG_SOLARIZE :
1952             pDlg = new GraphicFilterSolarize( pParent, rGraphic, nGreyThreshold, bInvert );
1953             break;
1954         default:
1955             break;
1956     }
1957
1958     if ( pDlg )
1959         return new AbstractGraphicFilterDialog_Impl( pDlg );
1960     return 0;
1961 }
1962 //CHINA001  GraphicFilterSolarize end
1963
1964 //CHINA001  GraphicFilterMosaic begin
1965 AbstractGraphicFilterDialog * AbstractDialogFactory_Impl::CreateGraphicFilterMosaic (Window* pParent,  //add for GraphicFilterMosaic
1966                                             const Graphic& rGraphic,
1967                                             USHORT nTileWidth, USHORT nTileHeight, BOOL bEnhanceEdges,
1968                                             sal_uInt32 nResId)
1969 {
1970     GraphicFilterDialog* pDlg=NULL;
1971     switch ( nResId )
1972     {
1973         case RID_SVX_GRFFILTER_DLG_MOSAIC :
1974             pDlg = new GraphicFilterMosaic( pParent, rGraphic, nTileWidth, nTileHeight, bEnhanceEdges );
1975             break;
1976         default:
1977             break;
1978     }
1979
1980     if ( pDlg )
1981         return new AbstractGraphicFilterDialog_Impl( pDlg );
1982     return 0;
1983 }
1984 //CHINA001  GraphicFilterMosaic end
1985 //CHINA001  SvxAreaTabDialog begin
1986 AbstractSvxAreaTabDialog* AbstractDialogFactory_Impl::CreateSvxAreaTabDialog( Window* pParent,
1987                                                             const SfxItemSet* pAttr,
1988                                                             SdrModel* pModel,
1989                                                             sal_uInt32 nResId,
1990                                                             const SdrView* pSdrView )
1991 {
1992     SvxAreaTabDialog* pDlg=NULL;
1993     switch ( nResId )
1994     {
1995         case RID_SVXDLG_AREA :
1996             pDlg = new SvxAreaTabDialog( pParent, pAttr, pModel,pSdrView );
1997             break;
1998         default:
1999             break;
2000     }
2001
2002     if ( pDlg )
2003         return new AbstractSvxAreaTabDialog_Impl( pDlg );
2004     return 0;
2005 }
2006 //CHINA001  SvxAreaTabDialog end
2007 //CHINA001  SvxLineTabDialog begin
2008 SfxAbstractTabDialog* AbstractDialogFactory_Impl::CreateSvxLineTabDialog( Window* pParent, const SfxItemSet* pAttr, //add forSvxLineTabDialog
2009                                                                  SdrModel* pModel,
2010                                                                  sal_uInt32 nResId,
2011                                                                  const SdrObject* pObj ,
2012                                                                 BOOL bHasObj)
2013 {
2014     SfxTabDialog* pDlg=NULL;
2015     switch ( nResId )
2016     {
2017         case RID_SVXDLG_LINE :
2018             pDlg = new SvxLineTabDialog( pParent, pAttr, pModel,pObj,bHasObj );
2019             break;
2020         default:
2021             break;
2022     }
2023
2024     if ( pDlg )
2025         return new AbstractTabDialog_Impl( pDlg );
2026     return 0;
2027 }
2028 //CHINA001  SvxLineTabDialog end
2029
2030 SfxAbstractDialog* AbstractDialogFactory_Impl::CreateSfxDialog( Window* pParent,
2031                                                                         const SfxItemSet& rAttr,
2032                                                                         const Reference< XFrame >& _rxDocumentFrame,
2033                                                                         sal_uInt32 nResId
2034                                                                         )
2035 {
2036     SfxModalDialog* pDlg=NULL;
2037     switch ( nResId )
2038     {
2039         case SID_EVENTCONFIG :
2040             pDlg = new SfxMacroAssignDlg( pParent, _rxDocumentFrame, rAttr );
2041             break;
2042         case RID_SVXPAGE_MACROASSIGN :
2043             pDlg = new SvxShortcutAssignDlg( pParent, _rxDocumentFrame, rAttr );
2044             break;
2045         case RID_SVXDLG_CHARMAP :
2046             pDlg = new SvxCharacterMap( pParent, TRUE, &rAttr );
2047             break;
2048         default:
2049             break;
2050     }
2051
2052     if ( pDlg )
2053         return new AbstractSfxDialog_Impl( pDlg );
2054     return 0;
2055 }
2056
2057 //CHINA001  SvxMeasureDialog & SvxConnectionDialog begin
2058 SfxAbstractDialog* AbstractDialogFactory_Impl::CreateSfxDialog( Window* pParent,
2059                                                                         const SfxItemSet& rAttr,
2060                                                                         const SdrView* pView,
2061                                                                         sal_uInt32 nResId
2062                                                                         )
2063 {
2064     SfxSingleTabDialog* pDlg=NULL;
2065     switch ( nResId )
2066     {
2067         case RID_SVXPAGE_MEASURE :
2068             pDlg = new SvxMeasureDialog( pParent, rAttr, pView );
2069             break;
2070         case RID_SVXPAGE_CONNECTION :
2071             pDlg = new SvxConnectionDialog( pParent, rAttr, pView );
2072             break;
2073         case RID_SFXPAGE_DBREGISTER :
2074             pDlg = new DatabaseRegistrationDialog( pParent, rAttr );
2075             break;
2076         case RID_SVXPAGE_IMPROVEMENT :
2077         {
2078             String help_url;
2079             SFX_ITEMSET_ARG( &rAttr, pItem, SfxStringItem, SID_CURRENT_URL, sal_False );
2080             if ( pItem )
2081                 help_url = pItem->GetValue();
2082             pDlg = new SvxImprovementDialog( pParent, help_url);
2083         }
2084         default:
2085             break;
2086     }
2087
2088     if ( pDlg )
2089         return new AbstractSfxDialog_Impl( pDlg );
2090     return 0;
2091 }
2092
2093 //CHINA001 SvxPostItDialog begin
2094 AbstractSvxPostItDialog* AbstractDialogFactory_Impl::CreateSvxPostItDialog( Window* pParent,
2095                                                                         const SfxItemSet& rCoreSet,
2096                                                                         sal_uInt32 nResId,
2097                                                                         BOOL bPrevNext, BOOL bRedline )
2098 {
2099     SvxPostItDialog* pDlg=NULL;
2100     switch ( nResId )
2101     {
2102         case RID_SVXDLG_POSTIT :
2103             pDlg = new SvxPostItDialog( pParent, rCoreSet, bPrevNext, bRedline );
2104             break;
2105         default:
2106             break;
2107     }
2108
2109     if ( pDlg )
2110         return new AbstractSvxPostItDialog_Impl( pDlg );
2111     return 0;
2112 }
2113 //CHINA001   SvxPostItDialog end
2114
2115 class SvxMacroAssignDialog : public VclAbstractDialog
2116 {
2117 public:
2118     SvxMacroAssignDialog( Window* _pParent, const Reference< XFrame >& _rxDocumentFrame, const bool _bUnoDialogMode,
2119             const Reference< XNameReplace >& _rxEvents, const sal_uInt16 _nInitiallySelectedEvent )
2120         :m_aItems( SFX_APP()->GetPool(), SID_ATTR_MACROITEM, SID_ATTR_MACROITEM )
2121     {
2122         m_aItems.Put( SfxBoolItem( SID_ATTR_MACROITEM, _bUnoDialogMode ) );
2123         m_pDialog.reset( new SvxMacroAssignDlg( _pParent, _rxDocumentFrame, m_aItems, _rxEvents, _nInitiallySelectedEvent ) );
2124     }
2125
2126     virtual short Execute();
2127     virtual ~SvxMacroAssignDialog();
2128
2129 private:
2130     SfxItemSet                              m_aItems;
2131     ::std::auto_ptr< SvxMacroAssignDlg >    m_pDialog;
2132 };
2133
2134 short SvxMacroAssignDialog::Execute()
2135 {
2136     return m_pDialog->Execute();
2137 }
2138
2139 SvxMacroAssignDialog::~SvxMacroAssignDialog()
2140 {
2141 }
2142
2143 VclAbstractDialog * AbstractDialogFactory_Impl::CreateSvxMacroAssignDlg(
2144     Window* _pParent, const Reference< XFrame >& _rxDocumentFrame, const bool _bUnoDialogMode,
2145     const Reference< XNameReplace >& _rxEvents, const sal_uInt16 _nInitiallySelectedEvent )
2146 {
2147     return new SvxMacroAssignDialog( _pParent, _rxDocumentFrame, _bUnoDialogMode, _rxEvents, _nInitiallySelectedEvent );
2148 }
2149
2150 // Factories for TabPages
2151 CreateTabPage AbstractDialogFactory_Impl::GetTabPageCreatorFunc( USHORT nId )
2152 {
2153     switch ( nId )
2154     {
2155         case RID_OFA_TP_INTERNATIONAL:
2156             return ::offapp::InternationalOptionsPage::CreateSc;
2157         case RID_OFA_TP_INTERNATIONAL_SD:
2158         case RID_OFA_TP_INTERNATIONAL_IMPR:
2159             return offapp::InternationalOptionsPage::CreateSd;
2160         case RID_SVXPAGE_TEXTANIMATION :
2161             return SvxTextAnimationPage::Create;
2162         case RID_SVXTABPAGE_GALLERY_GENERAL :
2163             return TPGalleryThemeGeneral::Create;
2164         case RID_SVXPAGE_TRANSPARENCE :
2165             return SvxTransparenceTabPage::Create;
2166         case RID_SVXPAGE_AREA :
2167             return SvxAreaTabPage::Create;
2168         case RID_SVXPAGE_SHADOW :
2169             return SvxShadowTabPage::Create;
2170         case RID_SVXPAGE_LINE :
2171             return SvxLineTabPage::Create;
2172         case RID_SVXPAGE_CONNECTION :
2173             return SvxConnectionPage::Create;
2174         case RID_SVXPAGE_MEASURE :
2175             return SvxMeasurePage::Create;
2176         case RID_SFXPAGE_GENERAL :
2177             return SvxGeneralTabPage::Create;
2178         case RID_SVXPAGE_PICK_SINGLE_NUM :
2179             return SvxSingleNumPickTabPage::Create;
2180         case RID_SVXPAGE_PICK_BMP :
2181             return SvxBitmapPickTabPage::Create;
2182         case RID_SVXPAGE_PICK_BULLET :
2183             return SvxBulletPickTabPage::Create;
2184         case RID_SVXPAGE_NUM_OPTIONS :
2185             return SvxNumOptionsTabPage::Create;
2186         case RID_SVXPAGE_PICK_NUM :
2187             return SvxNumPickTabPage::Create;
2188         case RID_SVXPAGE_NUM_POSITION :
2189             return SvxNumPositionTabPage::Create;
2190         case RID_SVXPAGE_PARA_ASIAN :
2191             return SvxAsianTabPage::Create;
2192         case RID_SVXPAGE_EXT_PARAGRAPH :
2193             return SvxExtParagraphTabPage::Create;
2194         case RID_SVXPAGE_ALIGN_PARAGRAPH :
2195             return SvxParaAlignTabPage::Create;
2196         case RID_SVXPAGE_STD_PARAGRAPH :
2197             return SvxStdParagraphTabPage::Create;
2198         case RID_SVXPAGE_TABULATOR :
2199             return SvxTabulatorTabPage::Create;
2200         case RID_SVXPAGE_TEXTATTR :
2201             return SvxTextAttrPage::Create;
2202         case RID_SVXPAGE_ALIGNMENT :
2203             return svx::AlignmentTabPage::Create;
2204         case RID_SW_TP_BACKGROUND :
2205         case RID_SVXPAGE_BACKGROUND :
2206             return SvxBackgroundTabPage::Create;
2207         case RID_SVXPAGE_BORDER :
2208             return SvxBorderTabPage::Create;
2209         case RID_SVXPAGE_CHAR_NAME :
2210             return SvxCharNamePage::Create;
2211         case RID_SVXPAGE_CHAR_EFFECTS :
2212             return SvxCharEffectsPage::Create;
2213         case RID_SVXPAGE_CHAR_POSITION :
2214             return SvxCharPositionPage::Create;
2215         case RID_SVXPAGE_CHAR_TWOLINES :
2216             return SvxCharTwoLinesPage::Create;
2217         case RID_SVXPAGE_NUMBERFORMAT :
2218             return SvxNumberFormatTabPage::Create;
2219         case RID_SVXPAGE_PAGE :
2220             return SvxPageDescPage::Create;
2221         case RID_SVXPAGE_GRFCROP :
2222             return SvxGrfCropPage::Create;
2223         case RID_SVXPAGE_MACROASSIGN :
2224             return SfxMacroTabPage::Create;
2225         default:
2226             break;
2227     }
2228
2229     return 0;
2230 }
2231 CreateSvxDistributePage AbstractDialogFactory_Impl::GetSvxDistributePageCreatorFunc(USHORT nId )
2232 {
2233         switch ( nId )
2234     {
2235         case RID_SVXPAGE_DISTRIBUTE:
2236             return SvxDistributePage::Create;
2237         default:
2238             break;
2239     }
2240
2241     return 0;
2242 }
2243 DialogGetRanges AbstractDialogFactory_Impl::GetDialogGetRangesFunc( USHORT nId )
2244 {
2245         switch ( nId )
2246     {
2247         case RID_SVXDLG_POSTIT:
2248             return SvxPostItDialog::GetRanges;  //add for SvxPostItDialog
2249         default:
2250             break;
2251     }
2252
2253     return 0;
2254 }
2255 GetTabPageRanges AbstractDialogFactory_Impl::GetTabPageRangesFunc( USHORT nId )
2256 {
2257     switch ( nId )
2258     {
2259         case RID_SVXPAGE_TEXTANIMATION :
2260             return SvxTextAnimationPage::GetRanges;
2261         case RID_SVXPAGE_DISTRIBUTE:
2262             return SvxDistributePage::GetRanges;
2263         case RID_SVXPAGE_TRANSPARENCE :
2264             return SvxTransparenceTabPage::GetRanges;
2265         case RID_SVXPAGE_AREA :
2266             return SvxAreaTabPage::GetRanges;
2267         case RID_SVXPAGE_SHADOW :
2268             return SvxShadowTabPage::GetRanges;
2269         case RID_SVXPAGE_LINE :
2270             return SvxLineTabPage::GetRanges;
2271         case RID_SVXPAGE_CONNECTION :
2272             return SvxConnectionPage::GetRanges;
2273         case RID_SVXPAGE_MEASURE :
2274             return SvxMeasurePage::GetRanges;
2275         case RID_SVXPAGE_PARA_ASIAN :
2276             return SvxAsianTabPage::GetRanges;
2277         case RID_SVXPAGE_EXT_PARAGRAPH :
2278             return SvxExtParagraphTabPage::GetRanges;
2279         case RID_SVXPAGE_ALIGN_PARAGRAPH :
2280             return SvxParaAlignTabPage::GetRanges;
2281         case RID_SVXPAGE_STD_PARAGRAPH :
2282             return SvxStdParagraphTabPage::GetRanges;
2283         case RID_SVXPAGE_TABULATOR :
2284             return SvxTabulatorTabPage::GetRanges;
2285         case RID_SVXPAGE_TEXTATTR :
2286             return SvxTextAttrPage::GetRanges;
2287         case RID_SVXPAGE_ALIGNMENT :
2288             return svx::AlignmentTabPage::GetRanges;
2289         case RID_SW_TP_BACKGROUND :
2290         case RID_SVXPAGE_BACKGROUND :
2291             return SvxBackgroundTabPage::GetRanges;
2292         case RID_SVXPAGE_BORDER :
2293             return SvxBorderTabPage::GetRanges;
2294         case RID_SVXPAGE_CHAR_NAME :
2295             return SvxCharNamePage::GetRanges;
2296         case RID_SVXPAGE_CHAR_EFFECTS :
2297             return SvxCharEffectsPage::GetRanges;
2298         case RID_SVXPAGE_CHAR_POSITION :
2299             return SvxCharPositionPage::GetRanges;
2300         case RID_SVXPAGE_CHAR_TWOLINES :
2301             return SvxCharTwoLinesPage::GetRanges;
2302         case RID_SVXPAGE_NUMBERFORMAT :
2303             return SvxNumberFormatTabPage::GetRanges;
2304         case RID_SVXPAGE_PAGE :
2305             return SvxPageDescPage::GetRanges;
2306         case RID_SVXPAGE_ASIAN_LAYOUT:
2307             return SvxAsianLayoutPage::GetRanges;
2308         default:
2309             break;
2310     }
2311
2312     return 0;
2313 }
2314
2315 SfxAbstractInsertObjectDialog* AbstractDialogFactory_Impl::CreateInsertObjectDialog( Window* pParent, USHORT nSlotId,
2316             const Reference < com::sun::star::embed::XStorage >& xStor,
2317             const SvObjectServerList* pList )
2318 {
2319     InsertObjectDialog_Impl* pDlg=0;
2320     switch ( nSlotId )
2321     {
2322         case SID_INSERT_OBJECT : pDlg = new SvInsertOleDlg( pParent, xStor, pList ); break;
2323         case SID_INSERT_PLUGIN : pDlg = new SvInsertPlugInDialog( pParent, xStor ); break;
2324         case SID_INSERT_APPLET : pDlg = new SvInsertAppletDialog( pParent, xStor ); break;
2325         case SID_INSERT_FLOATINGFRAME : pDlg = new SfxInsertFloatingFrameDialog( pParent, xStor ); break;
2326         default: break;
2327     }
2328
2329     if ( pDlg )
2330     {
2331         pDlg->SetHelpId( nSlotId );
2332         return new AbstractInsertObjectDialog_Impl( pDlg );
2333     }
2334     return 0;
2335 }
2336
2337 VclAbstractDialog* AbstractDialogFactory_Impl::CreateEditObjectDialog( Window* pParent, USHORT nSlotId,
2338             const Reference < com::sun::star::embed::XEmbeddedObject >& xObj )
2339 {
2340     InsertObjectDialog_Impl* pDlg=0;
2341     switch ( nSlotId )
2342     {
2343         case SID_INSERT_APPLET : pDlg = new SvInsertAppletDialog( pParent, xObj ); break;
2344         case SID_INSERT_FLOATINGFRAME : pDlg = new SfxInsertFloatingFrameDialog( pParent, xObj ); break;
2345         default: break;
2346     }
2347
2348     if ( pDlg )
2349     {
2350         pDlg->SetHelpId( nSlotId );
2351         return new VclAbstractDialog_Impl( pDlg );
2352     }
2353     return 0;
2354 }
2355
2356 SfxAbstractPasteDialog* AbstractDialogFactory_Impl::CreatePasteDialog( Window* pParent )
2357 {
2358     return new AbstractPasteDialog_Impl( new SvPasteObjectDialog( pParent ) );
2359 }
2360
2361 SfxAbstractLinksDialog* AbstractDialogFactory_Impl::CreateLinksDialog( Window* pParent, sfx2::SvLinkManager* pMgr, BOOL bHTML, sfx2::SvBaseLink* p)
2362 {
2363     SvBaseLinksDlg* pLinkDlg = new SvBaseLinksDlg( pParent, pMgr, bHTML );
2364     if ( p )
2365         pLinkDlg->SetActLink(p);
2366     return new AbstractLinksDialog_Impl( pLinkDlg );
2367 }
2368
2369 SfxAbstractTabDialog* AbstractDialogFactory_Impl::CreateSvxFormatCellsDialog( Window* pParent, const SfxItemSet* pAttr, SdrModel* pModel, const SdrObject* /*pObj*/ )
2370 {
2371     return new AbstractTabDialog_Impl( new SvxFormatCellsDialog( pParent, pAttr, pModel ) );
2372 }
2373
2374 SvxAbstractSplittTableDialog* AbstractDialogFactory_Impl::CreateSvxSplittTableDialog( Window* pParent, bool bIsTableVertical, long nMaxVertical, long nMaxHorizontal )
2375 {
2376     return new SvxSplitTableDlg( pParent, bIsTableVertical, nMaxVertical, nMaxHorizontal );
2377 }
2378
2379 SvxAbstractNewTableDialog* AbstractDialogFactory_Impl::CreateSvxNewTableDialog( Window* pParent )
2380 {
2381     return new SvxNewTableDialog( pParent );
2382 }
2383
2384 VclAbstractDialog* AbstractDialogFactory_Impl::CreateOptionsDialog(
2385     Window* pParent, const rtl::OUString& rExtensionId, const rtl::OUString& /*rApplicationContext*/ )
2386 {
2387     return new VclAbstractDialog_Impl( new OfaTreeOptionsDialog( pParent, rExtensionId ) );
2388 }
2389
2390 SvxAbstractInsRowColDlg* AbstractDialogFactory_Impl::CreateSvxInsRowColDlg( Window* pParent, bool bCol, ULONG nHelpId )
2391 {
2392     return new SvxInsRowColDlg( pParent, bCol, nHelpId );
2393 }