cui/source/factory/dlgfact.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <align.hxx>
  21 #include "dlgfact.hxx"
  22
  23 #include <sfx2/app.hxx>
  24 #include <sfx2/basedlgs.hxx>
  25 #include <sfx2/pageids.hxx>
  26 #include <svx/dialogs.hrc>
  27 #include <svx/svxids.hrc>
  28 #include <numfmt.hxx>
  29 #include <splitcelldlg.hxx>
  30 #include <dstribut.hxx>
  31 #include <cuiimapwnd.hxx>
  32 #include <cui/cuicharmap.hxx>
  33 #include <srchxtra.hxx>
  34 #include <textanim.hxx>
  35 #include <autocdlg.hxx>
  36 #include <treeopt.hxx>
  37 #include <labdlg.hxx>
  38 #include <hangulhanjadlg.hxx>
  39 #include <showcols.hxx>
  40 #include <zoom.hxx>
  41 #include <cuigaldlg.hxx>
  42 #include <transfrm.hxx>
  43 #include <bbdlg.hxx>
  44 #include <cuisrchdlg.hxx>
  45 #include <cuitbxform.hxx>
  46 #include <optdict.hxx>
  47 #include <dlgname.hxx>
  48 #include <multipat.hxx>
  49 #include <cuihyperdlg.hxx>
  50 #include <cuifmsearch.hxx>
  51 #include <cuigrfflt.hxx>
  52 #include <cuitabarea.hxx>
  53 #include <cuitabline.hxx>
  54 #include <measure.hxx>
  55 #include <connect.hxx>
  56 #include <dbregister.hxx>
  57 #include <cuioptgenrl.hxx>
  58 #include <optasian.hxx>
  59 #include <insdlg.hxx>
  60 #include <pastedlg.hxx>
  61 #include <linkdlg.hxx>
  62 #include <SignatureLineDialog.hxx>
  63 #include <SignSignatureLineDialog.hxx>
  64 #include <QrCodeGenDialog.hxx>
  65 #include <SpellDialog.hxx>
  66 #include <cfg.hxx>
  67 #include <numpages.hxx>
  68 #include <paragrph.hxx>
  69 #include <tabstpge.hxx>
  70 #include <textattr.hxx>
  71 #include <backgrnd.hxx>
  72 #include <border.hxx>
  73 #include <chardlg.hxx>
  74 #include <page.hxx>
  75 #include <postdlg.hxx>
  76 #include <grfpage.hxx>
  77 #include <scriptdlg.hxx>
  78 #include <cfgutil.hxx>
  79 #include <macropg.hxx>
  80 #include <sdrcelldlg.hxx>
  81 #include <newtabledlg.hxx>
  82 #include <macroass.hxx>
  83 #include <insrc.hxx>
  84 #include <passwdomdlg.hxx>
  85 #include <screenshotannotationdlg.hxx>
  86 #include <hyphen.hxx>
  87 #include <thesdlg.hxx>
  88 #include <about.hxx>
  89 #include <tipofthedaydlg.hxx>
  90 #include <DiagramDialog.hxx>
  91
  92 using namespace ::com::sun::star;
  93 using namespace ::com::sun::star::frame;
  94 using namespace ::com::sun::star::container;
  95
  96 using ::com::sun::star::uno::Reference;
  97
  98 using namespace svx;
  99 // AbstractTabDialog implementations just forwards everything to the dialog
 100
 101 short CuiAbstractController_Impl::Execute()
 102 {
 103     return m_xDlg->run();
 104 }
 105
 106 short CuiAbstractSingleTabController_Impl::Execute()
 107 {
 108     return m_xDlg->run();
 109 }
 110
 111 short AbstractSvxDistributeDialog_Impl::Execute()
 112 {
 113     return m_xDlg->run();
 114 }
 115
 116 short AbstractHangulHanjaConversionDialog_Impl::Execute()
 117 {
 118     return m_xDlg->run();
 119 }
 120
 121 short AbstractFmShowColsDialog_Impl::Execute()
 122 {
 123     return m_xDlg->run();
 124 }
 125
 126 short AbstractHyphenWordDialog_Impl::Execute()
 127 {
 128     return m_xDlg->run();
 129 }
 130
 131 short AbstractThesaurusDialog_Impl::Execute()
 132 {
 133     return m_xDlg->run();
 134 }
 135
 136 bool AbstractThesaurusDialog_Impl::StartExecuteAsync(AsyncContext &rCtx)
 137 {
 138     return SfxDialogController::runAsync(m_xDlg, rCtx.maEndDialogFn);
 139 }
 140
 141 short AbstractSvxZoomDialog_Impl::Execute()
 142 {
 143     return m_xDlg->run();
 144 }
 145
 146 short AbstractTitleDialog_Impl::Execute()
 147 {
 148     return m_xDlg->run();
 149 }
 150
 151 short AbstractScriptSelectorDialog_Impl::Execute()
 152 {
 153     return m_xDlg->run();
 154 }
 155
 156 short AbstractGalleryIdDialog_Impl::Execute()
 157 {
 158     return m_xDlg->run();
 159 }
 160
 161 short AbstractURLDlg_Impl::Execute()
 162 {
 163     return m_xDlg->run();
 164 }
 165
 166 short AbstractSvxSearchSimilarityDialog_Impl::Execute()
 167 {
 168     return m_xDlg->run();
 169 }
 170
 171 short AbstractSvxTransformTabDialog_Impl::Execute()
 172 {
 173     return m_xDlg->run();
 174 }
 175
 176 bool AbstractSvxTransformTabDialog_Impl::StartExecuteAsync(AsyncContext &rCtx)
 177 {
 178     return SfxTabDialogController::runAsync(m_xDlg, rCtx.maEndDialogFn);
 179 }
 180
 181 short AbstractSvxCaptionDialog_Impl::Execute()
 182 {
 183     return m_xDlg->run();
 184 }
 185
 186 bool AbstractSvxCaptionDialog_Impl::StartExecuteAsync(AsyncContext &rCtx)
 187 {
 188     return SfxTabDialogController::runAsync(m_xDlg, rCtx.maEndDialogFn);
 189 }
 190
 191 short AbstractSvxJSearchOptionsDialog_Impl::Execute()
 192 {
 193     return m_xDlg->run();
 194 }
 195
 196 short AbstractFmInputRecordNoDialog_Impl::Execute()
 197 {
 198     return m_xDlg->run();
 199 }
 200
 201 short AbstractSvxNewDictionaryDialog_Impl::Execute()
 202 {
 203     return m_xDlg->run();
 204 }
 205
 206 short AbstractSvxNameDialog_Impl::Execute()
 207 {
 208     return m_xDlg->run();
 209 }
 210
 211 // #i68101#
 212 short AbstractSvxObjectNameDialog_Impl::Execute()
 213 {
 214     return m_xDlg->run();
 215 }
 216
 217 short AbstractSvxObjectTitleDescDialog_Impl::Execute()
 218 {
 219     return m_xDlg->run();
 220 }
 221
 222 short AbstractSvxMultiPathDialog_Impl::Execute()
 223 {
 224     return m_xDlg->run();
 225 }
 226
 227 short AbstractSvxPathSelectDialog_Impl::Execute()
 228 {
 229     return m_xDlg->run();
 230 }
 231
 232 short AbstractSvxHpLinkDlg_Impl::Execute()
 233 {
 234     return m_xDlg->run();
 235 }
 236
 237 short AbstractFmSearchDialog_Impl::Execute()
 238 {
 239     return m_xDlg->run();
 240 }
 241
 242 short AbstractGraphicFilterDialog_Impl::Execute()
 243 {
 244     return m_xDlg->run();
 245 }
 246
 247 short AbstractSvxAreaTabDialog_Impl::Execute()
 248 {
 249     return m_xDlg->run();
 250 }
 251
 252 bool AbstractSvxAreaTabDialog_Impl::StartExecuteAsync(AsyncContext &rCtx)
 253 {
 254     return SfxTabDialogController::runAsync(m_xDlg, rCtx.maEndDialogFn);
 255 }
 256
 257 short AbstractPasteDialog_Impl::Execute()
 258 {
 259     return m_xDlg->run();
 260 }
 261
 262 bool AbstractPasteDialog_Impl::StartExecuteAsync(AsyncContext &rCtx)
 263 {
 264     return SfxDialogController::runAsync(m_xDlg, rCtx.maEndDialogFn);
 265 }
 266
 267 short AbstractInsertObjectDialog_Impl::Execute()
 268 {
 269     return m_xDlg->run();
 270 }
 271
 272 short AbstractLinksDialog_Impl::Execute()
 273 {
 274     return m_xDlg->run();
 275 }
 276
 277 short AbstractSpellDialog_Impl::Execute()
 278 {
 279     return m_xDlg->run();
 280 }
 281
 282 bool AbstractSpellDialog_Impl::StartExecuteAsync(AsyncContext &rCtx)
 283 {
 284     return SfxDialogController::runAsync(m_xDlg, rCtx.maEndDialogFn);
 285 }
 286
 287 short AbstractSvxPostItDialog_Impl::Execute()
 288 {
 289     return m_xDlg->run();
 290 }
 291
 292 short AbstractPasswordToOpenModifyDialog_Impl::Execute()
 293 {
 294     return m_xDlg->run();
 295 }
 296
 297 short AbstractSvxCharacterMapDialog_Impl::Execute()
 298 {
 299     return m_xDlg->run();
 300 }
 301
 302 const SfxItemSet* AbstractSvxCharacterMapDialog_Impl::GetOutputItemSet() const
 303 {
 304     return m_xDlg->GetOutputItemSet();
 305 }
 306
 307 void AbstractSvxCharacterMapDialog_Impl::SetText(const OUString& rStr)
 308 {
 309     m_xDlg->set_title(rStr);
 310 }
 311
 312 short AbstractSignatureLineDialog_Impl::Execute()
 313 {
 314     return m_xDlg->run();
 315 }
 316
 317 short AbstractSignSignatureLineDialog_Impl::Execute()
 318 {
 319     return m_xDlg->run();
 320 }
 321
 322 short AbstractQrCodeGenDialog_Impl::Execute()
 323 {
 324     return m_xDlg->run();
 325 }
 326
 327 short AbstractScreenshotAnnotationDlg_Impl::Execute()
 328 {
 329     return m_xDlg->run();
 330 }
 331
 332 short CuiAbstractTabController_Impl::Execute()
 333 {
 334     return m_xDlg->run();
 335 }
 336
 337 bool CuiAbstractTabController_Impl::StartExecuteAsync(AsyncContext &rCtx)
 338 {
 339     return SfxTabDialogController::runAsync(m_xDlg, rCtx.maEndDialogFn);
 340 }
 341
 342 void CuiAbstractTabController_Impl::SetCurPageId( const OString &rName )
 343 {
 344     m_xDlg->SetCurPageId( rName );
 345 }
 346
 347 const SfxItemSet* CuiAbstractTabController_Impl::GetOutputItemSet() const
 348 {
 349     return m_xDlg->GetOutputItemSet();
 350 }
 351
 352 const sal_uInt16* CuiAbstractTabController_Impl::GetInputRanges(const SfxItemPool& pItem )
 353 {
 354     return m_xDlg->GetInputRanges( pItem );
 355 }
 356
 357 void CuiAbstractTabController_Impl::SetInputSet( const SfxItemSet* pInSet )
 358 {
 359      m_xDlg->SetInputSet( pInSet );
 360 }
 361
 362 //From class Window.
 363 void CuiAbstractTabController_Impl::SetText( const OUString& rStr )
 364 {
 365     m_xDlg->set_title(rStr);
 366 }
 367
 368 std::vector<OString> CuiAbstractTabController_Impl::getAllPageUIXMLDescriptions() const
 369 {
 370     return m_xDlg->getAllPageUIXMLDescriptions();
 371 }
 372
 373 bool CuiAbstractTabController_Impl::selectPageByUIXMLDescription(const OString& rUIXMLDescription)
 374 {
 375     return m_xDlg->selectPageByUIXMLDescription(rUIXMLDescription);
 376 }
 377
 378 BitmapEx CuiAbstractTabController_Impl::createScreenshot() const
 379 {
 380     return m_xDlg->createScreenshot();
 381 }
 382
 383 OString CuiAbstractTabController_Impl::GetScreenshotId() const
 384 {
 385     return m_xDlg->GetScreenshotId();
 386 }
 387
 388 bool CuiAsyncAbstractTabController_Impl::StartExecuteAsync(VclAbstractDialog::AsyncContext &rCtx)
 389 {
 390     return SfxTabDialogController::runAsync(m_xDlg, rCtx.maEndDialogFn);
 391 }
 392
 393 void CuiAsyncAbstractTabController_Impl::SetCurPageId( const OString &rName )
 394 {
 395     m_xDlg->SetCurPageId( rName );
 396 }
 397
 398 const SfxItemSet* CuiAsyncAbstractTabController_Impl::GetOutputItemSet() const
 399 {
 400     return m_xDlg->GetOutputItemSet();
 401 }
 402
 403 const SfxItemSet* CuiAbstractSingleTabController_Impl::GetOutputItemSet() const
 404 {
 405     return m_xDlg->GetOutputItemSet();
 406 }
 407
 408 void CuiAbstractSingleTabController_Impl::SetText(const OUString& rStr)
 409 {
 410     m_xDlg->set_title(rStr);
 411 }
 412
 413 SvxDistributeHorizontal AbstractSvxDistributeDialog_Impl::GetDistributeHor()const
 414 {
 415     return m_xDlg->GetDistributeHor();
 416 }
 417 SvxDistributeVertical AbstractSvxDistributeDialog_Impl::GetDistributeVer()const
 418 {
 419     return m_xDlg->GetDistributeVer();
 420 }
 421
 422 void AbstractHangulHanjaConversionDialog_Impl::EndDialog(sal_Int32 nResult)
 423 {
 424     m_xDlg->response(nResult);
 425 }
 426
 427 void AbstractHangulHanjaConversionDialog_Impl::EnableRubySupport( bool _bVal )
 428 {
 429     m_xDlg->EnableRubySupport(_bVal);
 430 }
 431
 432 void AbstractHangulHanjaConversionDialog_Impl::SetByCharacter( bool _bByCharacter )
 433 {
 434     m_xDlg->SetByCharacter(_bByCharacter);
 435 }
 436
 437 void AbstractHangulHanjaConversionDialog_Impl::SetConversionDirectionState( bool _bTryBothDirections, editeng::HangulHanjaConversion::ConversionDirection _ePrimaryConversionDirection )
 438 {
 439     m_xDlg->SetConversionDirectionState(_bTryBothDirections, _ePrimaryConversionDirection);
 440 }
 441
 442 void AbstractHangulHanjaConversionDialog_Impl::SetConversionFormat( editeng::HangulHanjaConversion::ConversionFormat _eType )
 443 {
 444     m_xDlg->SetConversionFormat(_eType);
 445 }
 446
 447 void AbstractHangulHanjaConversionDialog_Impl::SetOptionsChangedHdl( const Link<LinkParamNone*,void>& _rHdl )
 448 {
 449     m_xDlg->SetOptionsChangedHdl(_rHdl );
 450 }
 451
 452 void AbstractHangulHanjaConversionDialog_Impl::SetIgnoreHdl( const Link<weld::Button&,void>& _rHdl )
 453 {
 454     m_xDlg->SetIgnoreHdl(_rHdl );
 455 }
 456
 457 void AbstractHangulHanjaConversionDialog_Impl::SetIgnoreAllHdl(const Link<weld::Button&,void>& rHdl)
 458 {
 459     m_xDlg->SetIgnoreAllHdl(rHdl);
 460 }
 461
 462 void AbstractHangulHanjaConversionDialog_Impl::SetChangeHdl(const Link<weld::Button&,void>& rHdl)
 463 {
 464     m_xDlg->SetChangeHdl(rHdl);
 465 }
 466
 467 void AbstractHangulHanjaConversionDialog_Impl::SetChangeAllHdl( const Link<weld::Button&,void>& rHdl )
 468 {
 469     m_xDlg->SetChangeAllHdl(rHdl);
 470 }
 471
 472 void AbstractHangulHanjaConversionDialog_Impl::SetClickByCharacterHdl( const Link<weld::ToggleButton&,void>& _rHdl )
 473 {
 474     m_xDlg->SetClickByCharacterHdl(_rHdl );
 475 }
 476
 477 void AbstractHangulHanjaConversionDialog_Impl::SetConversionFormatChangedHdl(const Link<weld::Button&,void>& rHdl)
 478 {
 479     m_xDlg->SetConversionFormatChangedHdl(rHdl);
 480 }
 481
 482 void AbstractHangulHanjaConversionDialog_Impl::SetFindHdl( const Link<weld::Button&,void>& rHdl )
 483 {
 484     m_xDlg->SetFindHdl(rHdl);
 485 }
 486
 487 bool AbstractHangulHanjaConversionDialog_Impl::GetUseBothDirections( ) const
 488 {
 489     return m_xDlg->GetUseBothDirections();
 490 }
 491
 492 editeng::HangulHanjaConversion::ConversionDirection AbstractHangulHanjaConversionDialog_Impl::GetDirection( editeng::HangulHanjaConversion::ConversionDirection _eDefaultDirection ) const
 493 {
 494     return m_xDlg->GetDirection( _eDefaultDirection );
 495 }
 496
 497 void AbstractHangulHanjaConversionDialog_Impl::SetCurrentString(
 498                     const OUString& _rNewString,
 499                     const css::uno::Sequence< OUString >& _rSuggestions,
 500                     bool _bOriginatesFromDocument
 501                 )
 502 {
 503      m_xDlg->SetCurrentString(_rNewString,_rSuggestions,_bOriginatesFromDocument);
 504 }
 505
 506 OUString AbstractHangulHanjaConversionDialog_Impl::GetCurrentString( ) const
 507 {
 508     return m_xDlg->GetCurrentString();
 509 }
 510
 511 editeng::HangulHanjaConversion::ConversionFormat AbstractHangulHanjaConversionDialog_Impl::GetConversionFormat( ) const
 512 {
 513     return m_xDlg->GetConversionFormat();
 514 }
 515
 516 void AbstractHangulHanjaConversionDialog_Impl::FocusSuggestion( )
 517 {
 518     m_xDlg->FocusSuggestion();
 519 }
 520
 521 OUString AbstractHangulHanjaConversionDialog_Impl::GetCurrentSuggestion( ) const
 522 {
 523     return m_xDlg->GetCurrentSuggestion();
 524 }
 525
 526 OUString AbstractThesaurusDialog_Impl::GetWord()
 527 {
 528     return m_xDlg->GetWord();
 529 };
 530
 531 Reference < css::embed::XEmbeddedObject > AbstractInsertObjectDialog_Impl::GetObject()
 532 {
 533    return m_xDlg->GetObject();
 534 }
 535
 536 bool AbstractInsertObjectDialog_Impl::IsCreateNew()
 537 {
 538     return m_xDlg->IsCreateNew();
 539 }
 540
 541 ::Reference< css::io::XInputStream > AbstractInsertObjectDialog_Impl::GetIconIfIconified( OUString* pGraphicMediaType )
 542 {
 543    return m_xDlg->GetIconIfIconified( pGraphicMediaType );
 544 }
 545
 546 void AbstractPasteDialog_Impl::Insert(SotClipboardFormatId nFormat, const OUString& rFormatName)
 547 {
 548     m_xDlg->Insert(nFormat, rFormatName);
 549 }
 550
 551 void AbstractPasteDialog_Impl::SetObjName(const SvGlobalName & rClass, const OUString& rObjName)
 552 {
 553     m_xDlg->SetObjName(rClass, rObjName);
 554 }
 555
 556 void AbstractPasteDialog_Impl::PreGetFormat( const TransferableDataHelper& aHelper )
 557 {
 558     m_xDlg->PreGetFormat(aHelper);
 559 }
 560
 561 SotClipboardFormatId AbstractPasteDialog_Impl::GetFormatOnly()
 562 {
 563     return m_xDlg->GetFormatOnly();
 564 }
 565
 566 SotClipboardFormatId AbstractPasteDialog_Impl::GetFormat( const TransferableDataHelper& aHelper )
 567 {
 568     return m_xDlg->GetFormat(aHelper);
 569 }
 570
 571 void AbstractFmShowColsDialog_Impl::SetColumns(const ::Reference< css::container::XIndexContainer>& xCols)
 572 {
 573      m_xDlg->SetColumns(xCols);
 574 }
 575
 576 void AbstractSvxZoomDialog_Impl::SetLimits( sal_uInt16 nMin, sal_uInt16 nMax )
 577 {
 578     m_xDlg->SetLimits( nMin, nMax );
 579 }
 580
 581 void AbstractSvxZoomDialog_Impl::HideButton( ZoomButtonId nBtnId )
 582 {
 583     m_xDlg->HideButton( nBtnId );
 584 }
 585
 586 const SfxItemSet* AbstractSvxZoomDialog_Impl::GetOutputItemSet() const
 587 {
 588     return m_xDlg->GetOutputItemSet();
 589 }
 590
 591 void AbstractSpellDialog_Impl::InvalidateDialog()
 592 {
 593     m_xDlg->InvalidateDialog();
 594 }
 595
 596 std::shared_ptr<SfxDialogController> AbstractSpellDialog_Impl::GetController()
 597 {
 598     return m_xDlg;
 599 }
 600
 601 SfxBindings& AbstractSpellDialog_Impl::GetBindings()
 602 {
 603     return m_xDlg->GetBindings();
 604 }
 605
 606 OUString AbstractTitleDialog_Impl::GetTitle() const
 607 {
 608     return m_xDlg->GetTitle();
 609 }
 610
 611 sal_uInt32 AbstractGalleryIdDialog_Impl::GetId() const
 612 {
 613     return m_xDlg->GetId();
 614 }
 615
 616 OUString AbstractURLDlg_Impl::GetURL() const
 617 {
 618     return m_xDlg->GetURL();
 619 }
 620
 621 OUString AbstractURLDlg_Impl::GetAltText() const
 622 {
 623     return m_xDlg->GetAltText();
 624 }
 625
 626 OUString AbstractURLDlg_Impl::GetDesc() const
 627 {
 628     return m_xDlg->GetDesc();
 629 }
 630
 631 OUString AbstractURLDlg_Impl::GetTarget() const
 632 {
 633     return m_xDlg->GetTarget();
 634 }
 635
 636 OUString AbstractURLDlg_Impl::GetName() const
 637 {
 638     return m_xDlg->GetName();
 639 }
 640
 641 sal_uInt16 AbstractSvxSearchSimilarityDialog_Impl::GetOther()
 642 {
 643     return m_xDlg->GetOther();
 644 }
 645
 646 sal_uInt16 AbstractSvxSearchSimilarityDialog_Impl::GetShorter()
 647 {
 648     return m_xDlg->GetShorter();
 649 }
 650
 651 sal_uInt16 AbstractSvxSearchSimilarityDialog_Impl::GetLonger()
 652 {
 653     return m_xDlg->GetLonger();
 654 }
 655
 656 bool AbstractSvxSearchSimilarityDialog_Impl::IsRelaxed()
 657 {
 658     return m_xDlg->IsRelaxed();
 659 }
 660
 661 // AbstractSvxTransformTabDialog implementations just forwards everything to the dialog
 662 void AbstractSvxTransformTabDialog_Impl::SetCurPageId( const OString& rName )
 663 {
 664     m_xDlg->SetCurPageId( rName );
 665 }
 666
 667 const SfxItemSet* AbstractSvxTransformTabDialog_Impl::GetOutputItemSet() const
 668 {
 669     return m_xDlg->GetOutputItemSet();
 670 }
 671
 672 const sal_uInt16* AbstractSvxTransformTabDialog_Impl::GetInputRanges(const SfxItemPool& pItem )
 673 {
 674     return m_xDlg->GetInputRanges( pItem );
 675 }
 676
 677 void AbstractSvxTransformTabDialog_Impl::SetInputSet( const SfxItemSet* pInSet )
 678 {
 679      m_xDlg->SetInputSet( pInSet );
 680 }
 681
 682 //From class Window.
 683 void AbstractSvxTransformTabDialog_Impl::SetText( const OUString& rStr )
 684 {
 685     m_xDlg->set_title(rStr);
 686 }
 687
 688 void AbstractSvxTransformTabDialog_Impl::SetValidateFramePosLink( const Link<SvxSwFrameValidation&,void>& rLink )
 689 {
 690     m_xDlg->SetValidateFramePosLink( rLink );
 691 }
 692
 693 // AbstractSvxCaptionDialog implementations just forwards everything to the dialog
 694 void AbstractSvxCaptionDialog_Impl::SetCurPageId( const OString& rName )
 695 {
 696     m_xDlg->SetCurPageId(rName);
 697 }
 698
 699 const SfxItemSet* AbstractSvxCaptionDialog_Impl::GetOutputItemSet() const
 700 {
 701     return m_xDlg->GetOutputItemSet();
 702 }
 703
 704 const sal_uInt16* AbstractSvxCaptionDialog_Impl::GetInputRanges(const SfxItemPool& pItem )
 705 {
 706     return m_xDlg->GetInputRanges( pItem );
 707 }
 708
 709 void AbstractSvxCaptionDialog_Impl::SetInputSet( const SfxItemSet* pInSet )
 710 {
 711      m_xDlg->SetInputSet( pInSet );
 712 }
 713
 714 void AbstractSvxCaptionDialog_Impl::SetText( const OUString& rStr )
 715 {
 716     m_xDlg->set_title(rStr);
 717 }
 718
 719 void AbstractSvxCaptionDialog_Impl::SetValidateFramePosLink( const Link<SvxSwFrameValidation&,void>& rLink )
 720 {
 721     m_xDlg->SetValidateFramePosLink( rLink );
 722 }
 723
 724 TransliterationFlags AbstractSvxJSearchOptionsDialog_Impl::GetTransliterationFlags() const
 725 {
 726     return m_xDlg->GetTransliterationFlags();
 727 }
 728
 729 void AbstractFmInputRecordNoDialog_Impl::SetValue(long nNew)
 730 {
 731     m_xDlg->SetValue(nNew);
 732 }
 733
 734 long AbstractFmInputRecordNoDialog_Impl::GetValue() const
 735 {
 736     return m_xDlg->GetValue();
 737 }
 738
 739 ::Reference< css::linguistic2::XDictionary > AbstractSvxNewDictionaryDialog_Impl::GetNewDictionary()
 740 {
 741     return m_xDlg->GetNewDictionary();
 742 }
 743
 744 void AbstractSvxNameDialog_Impl::GetName(OUString& rName)
 745 {
 746     rName = m_xDlg->GetName();
 747 }
 748
 749 void AbstractSvxNameDialog_Impl::SetCheckNameHdl( const Link<AbstractSvxNameDialog&,bool>& rLink, bool bCheckImmediately )
 750 {
 751     aCheckNameHdl = rLink;
 752     if( rLink.IsSet() )
 753         m_xDlg->SetCheckNameHdl( LINK(this, AbstractSvxNameDialog_Impl, CheckNameHdl), bCheckImmediately );
 754     else
 755         m_xDlg->SetCheckNameHdl( Link<SvxNameDialog&,bool>(), bCheckImmediately );
 756 }
 757
 758 void AbstractSvxNameDialog_Impl::SetEditHelpId(const OString& rHelpId)
 759 {
 760     m_xDlg->SetEditHelpId(rHelpId);
 761 }
 762
 763 void AbstractSvxNameDialog_Impl::SetHelpId(const OString& rHelpId)
 764 {
 765     m_xDlg->set_help_id(rHelpId);
 766 }
 767
 768 void AbstractSvxNameDialog_Impl::SetText( const OUString& rStr )
 769 {
 770     m_xDlg->set_title(rStr);
 771 }
 772
 773 IMPL_LINK_NOARG(AbstractSvxNameDialog_Impl, CheckNameHdl, SvxNameDialog&, bool)
 774 {
 775     return aCheckNameHdl.Call(*this);
 776 }
 777
 778 void AbstractSvxObjectNameDialog_Impl::GetName(OUString& rName)
 779 {
 780     rName = m_xDlg->GetName();
 781 }
 782
 783 void AbstractSvxObjectNameDialog_Impl::SetCheckNameHdl(const Link<AbstractSvxObjectNameDialog&,bool>& rLink)
 784 {
 785     aCheckNameHdl = rLink;
 786
 787     if(rLink.IsSet())
 788     {
 789         m_xDlg->SetCheckNameHdl(LINK(this, AbstractSvxObjectNameDialog_Impl, CheckNameHdl));
 790     }
 791     else
 792     {
 793         m_xDlg->SetCheckNameHdl(Link<SvxObjectNameDialog&,bool>());
 794     }
 795 }
 796
 797 IMPL_LINK_NOARG(AbstractSvxObjectNameDialog_Impl, CheckNameHdl, SvxObjectNameDialog&, bool)
 798 {
 799     return aCheckNameHdl.Call(*this);
 800 }
 801
 802 void AbstractSvxObjectTitleDescDialog_Impl::GetTitle(OUString& rTitle)
 803 {
 804     rTitle = m_xDlg->GetTitle();
 805 }
 806
 807 void AbstractSvxObjectTitleDescDialog_Impl::GetDescription(OUString& rDescription)
 808 {
 809     rDescription = m_xDlg->GetDescription();
 810 }
 811
 812 OUString AbstractSvxMultiPathDialog_Impl::GetPath() const
 813 {
 814     return m_xDlg->GetPath();
 815 }
 816
 817 void AbstractSvxMultiPathDialog_Impl::SetPath( const OUString& rPath )
 818 {
 819     m_xDlg->SetPath( rPath );
 820 }
 821
 822 void AbstractSvxMultiPathDialog_Impl::SetTitle( const OUString& rNewTitle )
 823 {
 824     m_xDlg->SetTitle(rNewTitle);
 825 }
 826
 827 OUString AbstractSvxPathSelectDialog_Impl::GetPath() const
 828 {
 829     return m_xDlg->GetPath();
 830 }
 831
 832 void AbstractSvxPathSelectDialog_Impl::SetPath( const OUString& rPath )
 833 {
 834     m_xDlg->SetPath( rPath );
 835 }
 836
 837 void AbstractSvxPathSelectDialog_Impl::SetTitle( const OUString& rNewTitle )
 838 {
 839     m_xDlg->SetTitle(rNewTitle);
 840 }
 841
 842 std::shared_ptr<SfxDialogController> AbstractSvxHpLinkDlg_Impl::GetController()
 843 {
 844     return m_xDlg;
 845 }
 846
 847 bool AbstractSvxHpLinkDlg_Impl::QueryClose()
 848 {
 849     return m_xDlg->QueryClose();
 850 }
 851
 852 void AbstractFmSearchDialog_Impl::SetFoundHandler(const Link<FmFoundRecordInformation&,void>& lnk)
 853 {
 854     m_xDlg->SetFoundHandler(lnk);
 855 }
 856
 857 void AbstractFmSearchDialog_Impl::SetCanceledNotFoundHdl(const Link<FmFoundRecordInformation&,void>& lnk)
 858 {
 859     m_xDlg->SetCanceledNotFoundHdl(lnk);
 860 }
 861
 862 void AbstractFmSearchDialog_Impl::SetActiveField(const OUString& strField)
 863 {
 864     m_xDlg->SetActiveField(strField);
 865 }
 866
 867 Graphic AbstractGraphicFilterDialog_Impl::GetFilteredGraphic(const Graphic& rGraphic, double fScaleX, double fScaleY)
 868 {
 869     return m_xDlg->GetFilteredGraphic(rGraphic, fScaleX, fScaleY);
 870 }
 871
 872 // AbstractSvxAreaTabDialog implementations just forwards everything to the dialog
 873 void AbstractSvxAreaTabDialog_Impl::SetCurPageId( const OString& rName )
 874 {
 875     m_xDlg->SetCurPageId( rName );
 876 }
 877
 878 const SfxItemSet* AbstractSvxAreaTabDialog_Impl::GetOutputItemSet() const
 879 {
 880     return m_xDlg->GetOutputItemSet();
 881 }
 882
 883 const sal_uInt16* AbstractSvxAreaTabDialog_Impl::GetInputRanges(const SfxItemPool& pItem )
 884 {
 885     return m_xDlg->GetInputRanges( pItem );
 886 }
 887
 888 void AbstractSvxAreaTabDialog_Impl::SetInputSet( const SfxItemSet* pInSet )
 889 {
 890      m_xDlg->SetInputSet( pInSet );
 891 }
 892
 893 void AbstractSvxAreaTabDialog_Impl::SetText( const OUString& rStr )
 894 {
 895     m_xDlg->set_title(rStr);
 896 }
 897
 898 void AbstractSvxPostItDialog_Impl::SetText( const OUString& rStr )
 899 {
 900     m_xDlg->set_title(rStr);
 901 }
 902
 903 const SfxItemSet* AbstractSvxPostItDialog_Impl::GetOutputItemSet() const
 904 {
 905     return m_xDlg->GetOutputItemSet();
 906 }
 907
 908 void AbstractSvxPostItDialog_Impl::EnableTravel(bool bNext, bool bPrev)
 909 {
 910     m_xDlg->EnableTravel( bNext, bPrev );
 911 }
 912
 913 OUString AbstractSvxPostItDialog_Impl::GetNote()
 914 {
 915     return m_xDlg->GetNote();
 916 }
 917
 918 void AbstractSvxPostItDialog_Impl::SetNote(const OUString& rTxt)
 919 {
 920     m_xDlg->SetNote( rTxt );
 921 }
 922
 923 void AbstractSvxPostItDialog_Impl::ShowLastAuthor(const OUString& rAuthor, const OUString& rDate)
 924 {
 925     m_xDlg->ShowLastAuthor( rAuthor, rDate );
 926 }
 927
 928 void AbstractSvxPostItDialog_Impl::DontChangeAuthor()
 929 {
 930     m_xDlg->DontChangeAuthor();
 931 }
 932
 933 void AbstractSvxPostItDialog_Impl::HideAuthor()
 934 {
 935     m_xDlg->HideAuthor();
 936 }
 937
 938 void AbstractSvxPostItDialog_Impl::SetNextHdl( const Link<AbstractSvxPostItDialog&,void>& rLink )
 939 {
 940     aNextHdl = rLink;
 941     if( rLink.IsSet() )
 942         m_xDlg->SetNextHdl( LINK(this, AbstractSvxPostItDialog_Impl, NextHdl ) );
 943     else
 944         m_xDlg->SetNextHdl( Link<SvxPostItDialog&,void>() );
 945 }
 946
 947 void AbstractSvxPostItDialog_Impl::SetPrevHdl( const Link<AbstractSvxPostItDialog&,void>& rLink )
 948 {
 949     aPrevHdl = rLink;
 950     if( rLink.IsSet() )
 951         m_xDlg->SetPrevHdl( LINK(this, AbstractSvxPostItDialog_Impl, PrevHdl ) );
 952     else
 953         m_xDlg->SetPrevHdl( Link<SvxPostItDialog&,void>() );
 954 }
 955
 956 IMPL_LINK_NOARG(AbstractSvxPostItDialog_Impl, NextHdl, SvxPostItDialog&, void)
 957 {
 958     aNextHdl.Call(*this);
 959 }
 960
 961 IMPL_LINK_NOARG(AbstractSvxPostItDialog_Impl, PrevHdl, SvxPostItDialog&, void)
 962 {
 963     aPrevHdl.Call(*this);
 964 }
 965
 966 std::shared_ptr<weld::Dialog> AbstractSvxPostItDialog_Impl::GetDialog()
 967 {
 968     return m_xDlg->GetDialog();
 969 }
 970
 971 OUString AbstractPasswordToOpenModifyDialog_Impl::GetPasswordToOpen() const
 972 {
 973     return m_xDlg->GetPasswordToOpen();
 974 }
 975
 976 OUString AbstractPasswordToOpenModifyDialog_Impl::GetPasswordToModify() const
 977 {
 978     return m_xDlg->GetPasswordToModify();
 979 }
 980
 981 bool AbstractPasswordToOpenModifyDialog_Impl::IsRecommendToOpenReadonly() const
 982 {
 983     return m_xDlg->IsRecommendToOpenReadonly();
 984 }
 985
 986 // Create dialogs with simplest interface
 987 VclPtr<VclAbstractDialog> AbstractDialogFactory_Impl::CreateVclDialog(weld::Window* pParent, sal_uInt32 nResId)
 988 {
 989     std::unique_ptr<OfaTreeOptionsDialog> xDlg;
 990     switch ( nResId )
 991     {
 992         case SID_OPTIONS_TREEDIALOG :
 993         case SID_OPTIONS_DATABASES :
 994         case SID_LANGUAGE_OPTIONS :
 995         {
 996             bool bActivateLastSelection = false;
 997             if (nResId == SID_OPTIONS_TREEDIALOG)
 998                 bActivateLastSelection = true;
 999             Reference< frame::XFrame > xFrame;
1000             xDlg = std::make_unique<OfaTreeOptionsDialog>(pParent, xFrame, bActivateLastSelection);
1001             if (nResId == SID_OPTIONS_DATABASES)
1002             {
1003                 xDlg->ActivatePage(SID_SB_DBREGISTEROPTIONS);
1004             }
1005             else if (nResId == SID_LANGUAGE_OPTIONS)
1006             {
1007                 //open the tab page "tools/options/languages"
1008                 xDlg->ActivatePage(OFA_TP_LANGUAGES_FOR_SET_DOCUMENT_LANGUAGE);
1009             }
1010         }
1011         break;
1012         default:
1013             break;
1014     }
1015
1016     if (xDlg)
1017         return VclPtr<CuiAbstractController_Impl>::Create(std::move(xDlg));
1018     return nullptr;
1019 }
1020
1021 VclPtr<VclAbstractDialog> AbstractDialogFactory_Impl::CreateAboutDialog(weld::Window* pParent)
1022 {
1023     return VclPtr<CuiAbstractController_Impl>::Create(std::make_unique<AboutDialog>(pParent));
1024 }
1025
1026 VclPtr<VclAbstractDialog> AbstractDialogFactory_Impl::CreateFrameDialog(weld::Window* pParent, const Reference< frame::XFrame >& rxFrame,
1027     sal_uInt32 nResId, const OUString& rParameter )
1028 {
1029     std::unique_ptr<OfaTreeOptionsDialog> xDlg;
1030     if (SID_OPTIONS_TREEDIALOG == nResId || SID_OPTIONS_DATABASES == nResId)
1031     {
1032         // only activate last page if we don't want to activate a special page
1033         bool bActivateLastSelection = ( nResId != SID_OPTIONS_DATABASES && rParameter.isEmpty() );
1034         xDlg = std::make_unique<OfaTreeOptionsDialog>(pParent, rxFrame, bActivateLastSelection);
1035         if ( nResId == SID_OPTIONS_DATABASES )
1036             xDlg->ActivatePage(SID_SB_DBREGISTEROPTIONS);
1037         else if ( !rParameter.isEmpty() )
1038             xDlg->ActivatePage( rParameter );
1039     }
1040
1041     if (xDlg)
1042         return VclPtr<CuiAbstractController_Impl>::Create(std::move(xDlg));
1043     return nullptr;
1044 }
1045
1046 // TabDialog outside the drawing layer
1047 VclPtr<SfxAbstractTabDialog> AbstractDialogFactory_Impl::CreateAutoCorrTabDialog(weld::Window* pParent, const SfxItemSet* pAttrSet)
1048 {
1049     return VclPtr<CuiAbstractTabController_Impl>::Create(std::make_unique<OfaAutoCorrDlg>(pParent, pAttrSet));
1050 }
1051
1052 VclPtr<SfxAbstractTabDialog> AbstractDialogFactory_Impl::CreateCustomizeTabDialog(weld::Window* pParent,
1053                                                 const SfxItemSet* pAttrSet,
1054                                                 const Reference< frame::XFrame >& xViewFrame )
1055 {
1056     std::unique_ptr<SvxConfigDialog> xDlg1(new SvxConfigDialog(pParent, pAttrSet));
1057     xDlg1->SetFrame(xViewFrame);
1058     return VclPtr<CuiAbstractTabController_Impl>::Create(std::move(xDlg1));
1059 }
1060
1061 // TabDialog that use functionality of the drawing layer
1062 VclPtr<SfxAbstractTabDialog> AbstractDialogFactory_Impl::CreateTextTabDialog(weld::Window* pParent,
1063                                             const SfxItemSet* pAttrSet,
1064                                             SdrView* pView)
1065 {
1066     return VclPtr<CuiAbstractTabController_Impl>::Create(std::make_unique<SvxTextTabDialog>(pParent, pAttrSet, pView));
1067 }
1068
1069 // TabDialog that use functionality of the drawing layer and add AnchorTypes -- for SvxCaptionTabDialog
1070 VclPtr<AbstractSvxCaptionDialog> AbstractDialogFactory_Impl::CreateCaptionDialog(weld::Window* pParent,
1071                                                                                  const SdrView* pView,
1072                                                                                  SvxAnchorIds nAnchorTypes)
1073 {
1074     return VclPtr<AbstractSvxCaptionDialog_Impl>::Create(std::make_unique<SvxCaptionTabDialog>(pParent, pView, nAnchorTypes));
1075 }
1076
1077 VclPtr<AbstractSvxDistributeDialog> AbstractDialogFactory_Impl::CreateSvxDistributeDialog(weld::Window* pParent,
1078                                                                                           const SfxItemSet& rAttr)
1079 {
1080     return VclPtr<AbstractSvxDistributeDialog_Impl>::Create(std::make_unique<SvxDistributeDialog>(pParent, rAttr, SvxDistributeHorizontal::NONE, SvxDistributeVertical::NONE));
1081 }
1082
1083 VclPtr<AbstractHangulHanjaConversionDialog> AbstractDialogFactory_Impl::CreateHangulHanjaConversionDialog(weld::Window* pParent)
1084 {
1085     return VclPtr<AbstractHangulHanjaConversionDialog_Impl>::Create(std::make_unique<HangulHanjaConversionDialog>(pParent));
1086 }
1087
1088 VclPtr<AbstractThesaurusDialog> AbstractDialogFactory_Impl::CreateThesaurusDialog(weld::Window* pParent,
1089                                 css::uno::Reference<css::linguistic2::XThesaurus> xThesaurus,
1090                                 const OUString &rWord, LanguageType nLanguage)
1091 {
1092     return VclPtr<AbstractThesaurusDialog_Impl>::Create(std::make_unique<SvxThesaurusDialog>(pParent, xThesaurus, rWord, nLanguage));
1093 }
1094
1095 VclPtr<AbstractHyphenWordDialog> AbstractDialogFactory_Impl::CreateHyphenWordDialog(weld::Window* pParent,
1096                                                 const OUString &rWord, LanguageType nLang,
1097                                                 css::uno::Reference< css::linguistic2::XHyphenator >  &xHyphen,
1098                                                 SvxSpellWrapper* pWrapper)
1099 {
1100     return VclPtr<AbstractHyphenWordDialog_Impl>::Create(std::make_unique<SvxHyphenWordDialog>(rWord, nLang, pParent, xHyphen, pWrapper));
1101 }
1102
1103 VclPtr<AbstractFmShowColsDialog> AbstractDialogFactory_Impl::CreateFmShowColsDialog(weld::Window* pParent)
1104 {
1105     return VclPtr<AbstractFmShowColsDialog_Impl>::Create(std::make_unique<FmShowColsDialog>(pParent));
1106 }
1107
1108 VclPtr<AbstractSvxZoomDialog> AbstractDialogFactory_Impl::CreateSvxZoomDialog(weld::Window* pParent, const SfxItemSet& rCoreSet)
1109 {
1110     return VclPtr<AbstractSvxZoomDialog_Impl>::Create(std::make_unique<SvxZoomDialog>(pParent, rCoreSet));
1111 }
1112
1113 VclPtr<AbstractSpellDialog> AbstractDialogFactory_Impl::CreateSvxSpellDialog(
1114                         weld::Window* pParent,
1115                         SfxBindings* pBindings,
1116                         svx::SpellDialogChildWindow* pSpellChildWindow)
1117 {
1118     return VclPtr<AbstractSpellDialog_Impl>::Create(std::make_unique<svx::SpellDialog>(pSpellChildWindow, pParent, pBindings));
1119 }
1120
1121 VclPtr<VclAbstractDialog> AbstractDialogFactory_Impl::CreateActualizeProgressDialog(weld::Window* pParent,
1122                                                                                                GalleryTheme* pThm)
1123 {
1124    return VclPtr<CuiAbstractController_Impl>::Create(std::make_unique<ActualizeProgress>(pParent, pThm));
1125 }
1126
1127 VclPtr<VclAbstractDialog> AbstractDialogFactory_Impl::CreateScriptErrorDialog(const css::uno::Any& rException)
1128 {
1129     return VclPtr<SvxScriptErrorDialog>::Create(rException);
1130 }
1131
1132 VclPtr<AbstractScriptSelectorDialog> AbstractDialogFactory_Impl::CreateScriptSelectorDialog(weld::Window* pParent,
1133         const Reference<frame::XFrame>& rxFrame)
1134 {
1135     return VclPtr<AbstractScriptSelectorDialog_Impl>::Create(std::make_unique<SvxScriptSelectorDialog>(pParent, false/*bShowSlots*/, rxFrame));
1136 }
1137
1138 OUString AbstractScriptSelectorDialog_Impl::GetScriptURL() const
1139 {
1140     return m_xDlg->GetScriptURL();
1141 }
1142
1143 void AbstractScriptSelectorDialog_Impl::SetRunLabel()
1144 {
1145     m_xDlg->SetRunLabel();
1146 }
1147
1148 VclPtr<VclAbstractDialog> AbstractDialogFactory_Impl::CreateSvxScriptOrgDialog(weld::Window* pParent,
1149                                             const OUString& rLanguage)
1150 {
1151     return VclPtr<CuiAbstractController_Impl>::Create(std::make_unique<SvxScriptOrgDialog>(pParent, rLanguage));
1152 }
1153
1154 VclPtr<AbstractTitleDialog> AbstractDialogFactory_Impl::CreateTitleDialog(weld::Window* pParent,
1155                                             const OUString& rOldText)
1156 {
1157    return VclPtr<AbstractTitleDialog_Impl>::Create(std::make_unique<TitleDialog>(pParent, rOldText));
1158 }
1159
1160 VclPtr<AbstractGalleryIdDialog> AbstractDialogFactory_Impl::CreateGalleryIdDialog(weld::Window* pParent,
1161                                             GalleryTheme* pThm)
1162 {
1163    return VclPtr<AbstractGalleryIdDialog_Impl>::Create(std::make_unique<GalleryIdDialog>(pParent, pThm));
1164 }
1165
1166 VclPtr<VclAbstractDialog> AbstractDialogFactory_Impl::CreateGalleryThemePropertiesDialog(weld::Window* pParent,
1167                                             ExchangeData* pData,
1168                                             SfxItemSet* pItemSet)
1169 {
1170     return VclPtr<CuiAbstractTabController_Impl>::Create(std::make_unique<GalleryThemeProperties>(
1171                                                          pParent, pData, pItemSet));
1172 }
1173
1174 VclPtr<AbstractURLDlg> AbstractDialogFactory_Impl::CreateURLDialog(weld::Widget* pParent,
1175                                             const OUString& rURL, const OUString& rAltText, const OUString& rDescription,
1176                                             const OUString& rTarget, const OUString& rName,
1177                                             TargetList& rTargetList )
1178 {
1179     return VclPtr<AbstractURLDlg_Impl>::Create(std::make_unique<URLDlg>(pParent, rURL, rAltText, rDescription,
1180                                                                         rTarget, rName, rTargetList));
1181
1182 }
1183
1184 VclPtr<SfxAbstractTabDialog> AbstractDialogFactory_Impl::CreateTabItemDialog(weld::Window* pParent,
1185     const SfxItemSet& rSet)
1186 {
1187     return VclPtr<CuiAbstractTabController_Impl>::Create(std::make_unique<SvxSearchFormatDialog>(
1188                                                          pParent, rSet));
1189 }
1190
1191 VclPtr<VclAbstractDialog> AbstractDialogFactory_Impl::CreateSvxSearchAttributeDialog(weld::Window* pParent,
1192                                             SearchAttrItemList& rLst,
1193                                             const sal_uInt16* pWhRanges )
1194 {
1195     return VclPtr<CuiAbstractController_Impl>::Create(std::make_unique<SvxSearchAttributeDialog>(pParent, rLst, pWhRanges));
1196 }
1197
1198 VclPtr<AbstractSvxSearchSimilarityDialog> AbstractDialogFactory_Impl::CreateSvxSearchSimilarityDialog(weld::Window* pParent,
1199                                                             bool bRelax,
1200                                                             sal_uInt16 nOther,
1201                                                             sal_uInt16 nShorter,
1202                                                             sal_uInt16 nLonger)
1203 {
1204     return VclPtr<AbstractSvxSearchSimilarityDialog_Impl>::Create(std::make_unique<SvxSearchSimilarityDialog>(pParent, bRelax, nOther, nShorter, nLonger));
1205 }
1206
1207 VclPtr<SfxAbstractTabDialog> AbstractDialogFactory_Impl::CreateSvxBorderBackgroundDlg(
1208     weld::Window* pParent,
1209     const SfxItemSet& rCoreSet,
1210     bool bEnableDrawingLayerFillStyles)
1211 {
1212     return VclPtr<CuiAbstractTabController_Impl>::Create(std::make_unique<SvxBorderBackgroundDlg>(
1213         pParent,
1214         rCoreSet,
1215         /*bEnableSelector*/true,
1216         bEnableDrawingLayerFillStyles));
1217 }
1218
1219 VclPtr<AbstractSvxTransformTabDialog> AbstractDialogFactory_Impl::CreateSvxTransformTabDialog(weld::Window* pParent,
1220                                                                                               const SfxItemSet* pAttr,
1221                                                                                               const SdrView* pView,
1222                                                                                               SvxAnchorIds nAnchorTypes)
1223 {
1224     return VclPtr<AbstractSvxTransformTabDialog_Impl>::Create(new SvxTransformTabDialog(pParent, pAttr,pView, nAnchorTypes));
1225 }
1226
1227 VclPtr<SfxAbstractTabDialog> AbstractDialogFactory_Impl::CreateSchTransformTabDialog(weld::Window* pParent,
1228                                                                                      const SfxItemSet* pAttr,
1229                                                                                      const SdrView* pSdrView,
1230                                                                                      bool bSizeTabPage)
1231 {
1232     auto pDlg = std::make_unique<SvxTransformTabDialog>(pParent, pAttr, pSdrView,
1233             bSizeTabPage ? SvxAnchorIds::NoProtect :  SvxAnchorIds::NoProtect|SvxAnchorIds::NoResize);
1234     pDlg->RemoveTabPage( "RID_SVXPAGE_ANGLE" );
1235     pDlg->RemoveTabPage( "RID_SVXPAGE_SLANT" );
1236     return VclPtr<CuiAbstractTabController_Impl>::Create(std::move(pDlg));
1237 }
1238
1239 VclPtr<AbstractSvxJSearchOptionsDialog> AbstractDialogFactory_Impl::CreateSvxJSearchOptionsDialog(weld::Window* pParent,
1240                                                             const SfxItemSet& rOptionsSet,
1241                                                             TransliterationFlags nInitialFlags)
1242 {
1243     return VclPtr<AbstractSvxJSearchOptionsDialog_Impl>::Create(std::make_unique<SvxJSearchOptionsDialog>(pParent, rOptionsSet, nInitialFlags));
1244 }
1245
1246 VclPtr<AbstractFmInputRecordNoDialog> AbstractDialogFactory_Impl::CreateFmInputRecordNoDialog(weld::Window* pParent)
1247 {
1248     return VclPtr<AbstractFmInputRecordNoDialog_Impl>::Create(std::make_unique<FmInputRecordNoDialog>(pParent));
1249 }
1250
1251 VclPtr<AbstractSvxNewDictionaryDialog> AbstractDialogFactory_Impl::CreateSvxNewDictionaryDialog(weld::Window* pParent)
1252 {
1253     return VclPtr<AbstractSvxNewDictionaryDialog_Impl>::Create(std::make_unique<SvxNewDictionaryDialog>(pParent));
1254 }
1255
1256 VclPtr<VclAbstractDialog> AbstractDialogFactory_Impl::CreateSvxEditDictionaryDialog(weld::Window* pParent, const OUString& rName)
1257 {
1258     return VclPtr<CuiAbstractController_Impl>::Create(std::make_unique<SvxEditDictionaryDialog>(pParent, rName));
1259 }
1260
1261 VclPtr<AbstractSvxNameDialog> AbstractDialogFactory_Impl::CreateSvxNameDialog(weld::Window* pParent,
1262                                     const OUString& rName, const OUString& rDesc)
1263 {
1264     return VclPtr<AbstractSvxNameDialog_Impl>::Create(std::make_unique<SvxNameDialog>(pParent, rName, rDesc));
1265 }
1266
1267 VclPtr<AbstractSvxObjectNameDialog> AbstractDialogFactory_Impl::CreateSvxObjectNameDialog(weld::Window* pParent, const OUString& rName)
1268 {
1269     return VclPtr<AbstractSvxObjectNameDialog_Impl>::Create(std::make_unique<SvxObjectNameDialog>(pParent, rName));
1270 }
1271
1272 VclPtr<AbstractSvxObjectTitleDescDialog> AbstractDialogFactory_Impl::CreateSvxObjectTitleDescDialog(weld::Window* pParent, const OUString& rTitle, const OUString& rDescription)
1273 {
1274     return VclPtr<AbstractSvxObjectTitleDescDialog_Impl>::Create(std::make_unique<SvxObjectTitleDescDialog>(pParent, rTitle, rDescription));
1275 }
1276
1277 VclPtr<AbstractSvxMultiPathDialog> AbstractDialogFactory_Impl::CreateSvxMultiPathDialog(weld::Window* pParent)
1278 {
1279     return VclPtr<AbstractSvxMultiPathDialog_Impl>::Create(std::make_unique<SvxMultiPathDialog>(pParent));
1280 }
1281
1282 VclPtr<AbstractSvxMultiPathDialog> AbstractDialogFactory_Impl::CreateSvxPathSelectDialog(weld::Window* pParent)
1283 {
1284     return VclPtr<AbstractSvxPathSelectDialog_Impl>::Create(std::make_unique<SvxPathSelectDialog>(pParent));
1285 }
1286
1287 VclPtr<AbstractSvxHpLinkDlg> AbstractDialogFactory_Impl::CreateSvxHpLinkDlg(SfxChildWindow* pChild, SfxBindings* pBindings, weld::Window* pParent)
1288 {
1289     return VclPtr<AbstractSvxHpLinkDlg_Impl>::Create(std::make_unique<SvxHpLinkDlg>(pBindings, pChild, pParent));
1290 }
1291
1292 VclPtr<AbstractFmSearchDialog> AbstractDialogFactory_Impl::CreateFmSearchDialog(weld::Window* pParent,
1293                                                         const OUString& strInitialText,
1294                                                         const std::vector< OUString >& _rContexts,
1295                                                         sal_Int16 nInitialContext,
1296                                                         const Link<FmSearchContext&,sal_uInt32>& lnkContextSupplier)
1297 {
1298     return VclPtr<AbstractFmSearchDialog_Impl>::Create(std::make_unique<FmSearchDialog>(pParent,
1299                                                          strInitialText, _rContexts, nInitialContext, lnkContextSupplier));
1300
1301 }
1302
1303 VclPtr<AbstractGraphicFilterDialog> AbstractDialogFactory_Impl::CreateGraphicFilterEmboss(weld::Window* pParent,
1304                                             const Graphic& rGraphic)
1305 {
1306     return VclPtr<AbstractGraphicFilterDialog_Impl>::Create(std::make_unique<GraphicFilterEmboss>(pParent, rGraphic, RectPoint::MM));
1307 }
1308
1309 VclPtr<AbstractGraphicFilterDialog> AbstractDialogFactory_Impl::CreateGraphicFilterPoster(weld::Window* pParent,
1310                                             const Graphic& rGraphic)
1311 {
1312     return VclPtr<AbstractGraphicFilterDialog_Impl>::Create(std::make_unique<GraphicFilterPoster>(pParent, rGraphic, 16));
1313 }
1314
1315 VclPtr<AbstractGraphicFilterDialog> AbstractDialogFactory_Impl::CreateGraphicFilterSepia(weld::Window* pParent,
1316                                             const Graphic& rGraphic)
1317 {
1318     return VclPtr<AbstractGraphicFilterDialog_Impl>::Create(std::make_unique<GraphicFilterSepia>(pParent, rGraphic, 10));
1319 }
1320
1321 VclPtr<AbstractGraphicFilterDialog> AbstractDialogFactory_Impl::CreateGraphicFilterSmooth(weld::Window* pParent,
1322                                             const Graphic& rGraphic, double nRadius)
1323 {
1324     return VclPtr<AbstractGraphicFilterDialog_Impl>::Create(std::make_unique<GraphicFilterSmooth>(pParent, rGraphic, nRadius));
1325 }
1326
1327 VclPtr<AbstractGraphicFilterDialog> AbstractDialogFactory_Impl::CreateGraphicFilterSolarize(weld::Window* pParent,
1328                                             const Graphic& rGraphic)
1329 {
1330     return VclPtr<AbstractGraphicFilterDialog_Impl>::Create(std::make_unique<GraphicFilterSolarize>(pParent, rGraphic, 128, false /*bInvert*/));
1331 }
1332
1333 VclPtr<AbstractGraphicFilterDialog> AbstractDialogFactory_Impl::CreateGraphicFilterMosaic(weld::Window* pParent,
1334                                             const Graphic& rGraphic)
1335 {
1336     return VclPtr<AbstractGraphicFilterDialog_Impl>::Create(std::make_unique<GraphicFilterMosaic>(pParent, rGraphic, 4, 4, false /*bEnhanceEdges*/));
1337 }
1338
1339 VclPtr<AbstractSvxAreaTabDialog> AbstractDialogFactory_Impl::CreateSvxAreaTabDialog(weld::Window* pParent,
1340                                                             const SfxItemSet* pAttr,
1341                                                             SdrModel* pModel,
1342                                                             bool bShadow)
1343 {
1344     return VclPtr<AbstractSvxAreaTabDialog_Impl>::Create(std::make_unique<SvxAreaTabDialog>(pParent, pAttr, pModel, bShadow));
1345 }
1346
1347 VclPtr<SfxAbstractTabDialog> AbstractDialogFactory_Impl::CreateSvxLineTabDialog(weld::Window* pParent, const SfxItemSet* pAttr, //add forSvxLineTabDialog
1348                                                                  SdrModel* pModel,
1349                                                                  const SdrObject* pObj ,
1350                                                                  bool bHasObj)
1351 {
1352     return VclPtr<CuiAbstractTabController_Impl>::Create(std::make_unique<SvxLineTabDialog>(pParent, pAttr, pModel, pObj,bHasObj));
1353 }
1354
1355 VclPtr<SfxAbstractDialog> AbstractDialogFactory_Impl::CreateCharMapDialog(weld::Window* pParent, const SfxItemSet& rAttr,
1356                                                                           const Reference< XFrame >& rDocumentFrame)
1357 {
1358     return VclPtr<AbstractSvxCharacterMapDialog_Impl>::Create(std::make_unique<SvxCharacterMap>(pParent, &rAttr, rDocumentFrame));
1359 }
1360
1361 VclPtr<SfxAbstractDialog> AbstractDialogFactory_Impl::CreateEventConfigDialog(weld::Widget* pParent,
1362                                                                               const SfxItemSet& rAttr,
1363                                                                               const Reference< XFrame >& rDocumentFrame)
1364 {
1365     return VclPtr<CuiAbstractSingleTabController_Impl>::Create(std::make_unique<SfxMacroAssignDlg>(pParent, rDocumentFrame, rAttr));
1366 }
1367
1368 VclPtr<SfxAbstractDialog> AbstractDialogFactory_Impl::CreateSfxDialog(weld::Window* pParent,
1369                                                                       const SfxItemSet& rAttr,
1370                                                                       const SdrView* pView,
1371                                                                       sal_uInt32 nResId)
1372 {
1373     switch ( nResId )
1374     {
1375         case RID_SVXPAGE_MEASURE:
1376             return VclPtr<CuiAbstractSingleTabController_Impl>::Create(std::make_unique<SvxMeasureDialog>(pParent, rAttr, pView));
1377         case RID_SVXPAGE_CONNECTION:
1378             return VclPtr<CuiAbstractSingleTabController_Impl>::Create(std::make_unique<SvxConnectionDialog>(pParent, rAttr, pView));
1379         case RID_SFXPAGE_DBREGISTER:
1380             return VclPtr<CuiAbstractSingleTabController_Impl>::Create(std::make_unique<DatabaseRegistrationDialog>(pParent, rAttr));
1381     }
1382
1383     return nullptr;
1384 }
1385
1386 VclPtr<AbstractSvxPostItDialog> AbstractDialogFactory_Impl::CreateSvxPostItDialog(weld::Widget* pParent,
1387                                                                                   const SfxItemSet& rCoreSet,
1388                                                                                   bool bPrevNext)
1389 {
1390     return VclPtr<AbstractSvxPostItDialog_Impl>::Create(std::make_unique<SvxPostItDialog>(pParent, rCoreSet, bPrevNext));
1391 }
1392
1393 class SvxMacroAssignDialog : public VclAbstractDialog
1394 {
1395 public:
1396     SvxMacroAssignDialog( weld::Window* _pParent, const Reference< XFrame >& _rxDocumentFrame, const bool _bUnoDialogMode,
1397             const Reference< XNameReplace >& _rxEvents, const sal_uInt16 _nInitiallySelectedEvent )
1398         :m_aItems( SfxGetpApp()->GetPool(), svl::Items<SID_ATTR_MACROITEM, SID_ATTR_MACROITEM>{} )
1399     {
1400         m_aItems.Put( SfxBoolItem( SID_ATTR_MACROITEM, _bUnoDialogMode ) );
1401         m_xDialog.reset(new SvxMacroAssignDlg(_pParent, _rxDocumentFrame, m_aItems, _rxEvents, _nInitiallySelectedEvent));
1402     }
1403
1404     virtual short Execute() override;
1405
1406 private:
1407     SfxItemSet                              m_aItems;
1408     std::unique_ptr<SvxMacroAssignDlg>      m_xDialog;
1409 };
1410
1411 short SvxMacroAssignDialog::Execute()
1412 {
1413     return m_xDialog->run();
1414 }
1415
1416 short AbstractTipOfTheDayDialog_Impl::Execute()
1417 {
1418     return m_xDlg->run();
1419 }
1420
1421 short AbstractDiagramDialog_Impl::Execute()
1422 {
1423     return m_xDlg->run();
1424 }
1425
1426 VclPtr<VclAbstractDialog> AbstractDialogFactory_Impl::CreateSvxMacroAssignDlg(
1427     weld::Window* _pParent, const Reference< XFrame >& _rxDocumentFrame, const bool _bUnoDialogMode,
1428     const Reference< XNameReplace >& _rxEvents, const sal_uInt16 _nInitiallySelectedEvent )
1429 {
1430     return VclPtr<SvxMacroAssignDialog>::Create( _pParent, _rxDocumentFrame, _bUnoDialogMode, _rxEvents, _nInitiallySelectedEvent );
1431 }
1432
1433 // Factories for TabPages
1434 CreateTabPage AbstractDialogFactory_Impl::GetTabPageCreatorFunc( sal_uInt16 nId )
1435 {
1436     switch ( nId )
1437     {
1438         case RID_SVXPAGE_BKG :
1439             return SvxBkgTabPage::Create;
1440         case RID_SVXPAGE_TEXTANIMATION :
1441             return SvxTextAnimationPage::Create;
1442         case RID_SVXPAGE_TRANSPARENCE :
1443             return SvxTransparenceTabPage::Create;
1444         case RID_SVXPAGE_AREA :
1445             return SvxAreaTabPage::Create;
1446         case RID_SVXPAGE_SHADOW :
1447             return SvxShadowTabPage::Create;
1448         case RID_SVXPAGE_LINE :
1449             return SvxLineTabPage::Create;
1450         case RID_SVXPAGE_CONNECTION :
1451             return SvxConnectionPage::Create;
1452         case RID_SVXPAGE_MEASURE :
1453             return SvxMeasurePage::Create;
1454         case RID_SFXPAGE_GENERAL :
1455             return SvxGeneralTabPage::Create;
1456         case RID_SVXPAGE_PICK_SINGLE_NUM :
1457             return SvxSingleNumPickTabPage::Create;
1458         case RID_SVXPAGE_PICK_BMP :
1459             return SvxBitmapPickTabPage::Create;
1460         case RID_SVXPAGE_PICK_BULLET :
1461             return SvxBulletPickTabPage::Create;
1462         case RID_SVXPAGE_NUM_OPTIONS :
1463             return SvxNumOptionsTabPage::Create;
1464         case RID_SVXPAGE_PICK_NUM :
1465             return SvxNumPickTabPage::Create;
1466         case RID_SVXPAGE_NUM_POSITION :
1467             return SvxNumPositionTabPage::Create;
1468         case RID_SVXPAGE_PARA_ASIAN :
1469             return SvxAsianTabPage::Create;
1470         case RID_SVXPAGE_EXT_PARAGRAPH :
1471             return SvxExtParagraphTabPage::Create;
1472         case RID_SVXPAGE_ALIGN_PARAGRAPH :
1473             return SvxParaAlignTabPage::Create;
1474         case RID_SVXPAGE_STD_PARAGRAPH :
1475             return SvxStdParagraphTabPage::Create;
1476         case RID_SVXPAGE_TABULATOR :
1477             return SvxTabulatorTabPage::Create;
1478         case RID_SVXPAGE_TEXTATTR :
1479             return SvxTextAttrPage::Create;
1480         case RID_SVXPAGE_ALIGNMENT :
1481             return svx::AlignmentTabPage::Create;
1482         case RID_SW_TP_BACKGROUND :
1483         case RID_SVXPAGE_BACKGROUND :
1484             return SvxBackgroundTabPage::Create;
1485         case RID_SVXPAGE_BORDER :
1486             return SvxBorderTabPage::Create;
1487         case RID_SVXPAGE_CHAR_NAME :
1488             return SvxCharNamePage::Create;
1489         case RID_SVXPAGE_CHAR_EFFECTS :
1490             return SvxCharEffectsPage::Create;
1491         case RID_SVXPAGE_CHAR_POSITION :
1492             return SvxCharPositionPage::Create;
1493         case RID_SVXPAGE_CHAR_TWOLINES :
1494             return SvxCharTwoLinesPage::Create;
1495         case RID_SVXPAGE_NUMBERFORMAT :
1496             return SvxNumberFormatTabPage::Create;
1497         case RID_SVXPAGE_PAGE :
1498             return SvxPageDescPage::Create;
1499         case RID_SVXPAGE_GRFCROP :
1500             return SvxGrfCropPage::Create;
1501         case RID_SVXPAGE_MACROASSIGN :
1502             return SfxMacroTabPage::Create;
1503         default:
1504             break;
1505     }
1506
1507     return nullptr;
1508 }
1509
1510 DialogGetRanges AbstractDialogFactory_Impl::GetDialogGetRangesFunc()
1511 {
1512     return SvxPostItDialog::GetRanges;
1513 }
1514
1515 GetTabPageRanges AbstractDialogFactory_Impl::GetTabPageRangesFunc( sal_uInt16 nId )
1516 {
1517     switch ( nId )
1518     {
1519         case RID_SVXPAGE_TEXTANIMATION :
1520             return SvxTextAnimationPage::GetRanges;
1521         case RID_SVXPAGE_TRANSPARENCE :
1522             return SvxTransparenceTabPage::GetRanges;
1523         case RID_SVXPAGE_AREA :
1524             return SvxAreaTabPage::GetRanges;
1525         case RID_SVXPAGE_SHADOW :
1526             return SvxShadowTabPage::GetRanges;
1527         case RID_SVXPAGE_LINE :
1528             return SvxLineTabPage::GetRanges;
1529         case RID_SVXPAGE_CONNECTION :
1530             return SvxConnectionPage::GetRanges;
1531         case RID_SVXPAGE_MEASURE :
1532             return SvxMeasurePage::GetRanges;
1533         case RID_SVXPAGE_PARA_ASIAN :
1534             return SvxAsianTabPage::GetRanges;
1535         case RID_SVXPAGE_EXT_PARAGRAPH :
1536             return SvxExtParagraphTabPage::GetRanges;
1537         case RID_SVXPAGE_ALIGN_PARAGRAPH :
1538             return SvxParaAlignTabPage::GetRanges;
1539         case RID_SVXPAGE_STD_PARAGRAPH :
1540             return SvxStdParagraphTabPage::GetRanges;
1541         case RID_SVXPAGE_TABULATOR :
1542             return SvxTabulatorTabPage::GetRanges;
1543         case RID_SVXPAGE_TEXTATTR :
1544             return SvxTextAttrPage::GetRanges;
1545         case RID_SVXPAGE_ALIGNMENT :
1546             return svx::AlignmentTabPage::GetRanges;
1547         case RID_SW_TP_BACKGROUND :
1548         case RID_SVXPAGE_BACKGROUND :
1549             return SvxBackgroundTabPage::GetRanges;
1550         case RID_SVXPAGE_BORDER :
1551             return SvxBorderTabPage::GetRanges;
1552         case RID_SVXPAGE_CHAR_NAME :
1553             return SvxCharNamePage::GetRanges;
1554         case RID_SVXPAGE_CHAR_EFFECTS :
1555             return SvxCharEffectsPage::GetRanges;
1556         case RID_SVXPAGE_CHAR_POSITION :
1557             return SvxCharPositionPage::GetRanges;
1558         case RID_SVXPAGE_CHAR_TWOLINES :
1559             return SvxCharTwoLinesPage::GetRanges;
1560         case RID_SVXPAGE_NUMBERFORMAT :
1561             return SvxNumberFormatTabPage::GetRanges;
1562         case RID_SVXPAGE_PAGE :
1563             return SvxPageDescPage::GetRanges;
1564         case RID_SVXPAGE_ASIAN_LAYOUT:
1565             return SvxAsianLayoutPage::GetRanges;
1566         default:
1567             break;
1568     }
1569
1570     return nullptr;
1571 }
1572
1573 VclPtr<SfxAbstractInsertObjectDialog> AbstractDialogFactory_Impl::CreateInsertObjectDialog(weld::Window* pParent, const OUString& rCommand,
1574             const Reference <css::embed::XStorage>& xStor, const SvObjectServerList* pList)
1575 {
1576     std::unique_ptr<InsertObjectDialog_Impl> pDlg;
1577     if ( rCommand == ".uno:InsertObject" )
1578         pDlg.reset(new SvInsertOleDlg(pParent, xStor, pList));
1579     else if ( rCommand == ".uno:InsertObjectFloatingFrame" )
1580         pDlg.reset(new SfxInsertFloatingFrameDialog(pParent, xStor));
1581
1582     if ( pDlg )
1583     {
1584         pDlg->SetHelpId( OUStringToOString( rCommand, RTL_TEXTENCODING_UTF8 ) );
1585         return VclPtr<AbstractInsertObjectDialog_Impl>::Create( std::move(pDlg) );
1586     }
1587     return nullptr;
1588 }
1589
1590 VclPtr<VclAbstractDialog> AbstractDialogFactory_Impl::CreateEditObjectDialog(weld::Window* pParent, const OUString& rCommand,
1591             const Reference<css::embed::XEmbeddedObject>& xObj)
1592 {
1593     if ( rCommand == ".uno:InsertObjectFloatingFrame" )
1594     {
1595         auto pDlg = std::make_unique<SfxInsertFloatingFrameDialog>(pParent, xObj);
1596         pDlg->SetHelpId( OUStringToOString( rCommand, RTL_TEXTENCODING_UTF8 ) );
1597         return VclPtr<AbstractInsertObjectDialog_Impl>::Create( std::move(pDlg) );
1598     }
1599     return nullptr;
1600 }
1601
1602 VclPtr<SfxAbstractPasteDialog> AbstractDialogFactory_Impl::CreatePasteDialog(weld::Window* pParent)
1603 {
1604     return VclPtr<AbstractPasteDialog_Impl>::Create(std::make_unique<SvPasteObjectDialog>(pParent));
1605 }
1606
1607 VclPtr<SfxAbstractLinksDialog> AbstractDialogFactory_Impl::CreateLinksDialog(weld::Window* pParent, sfx2::LinkManager* pMgr, bool bHTML, sfx2::SvBaseLink* p)
1608 {
1609     auto xLinkDlg(std::make_unique<SvBaseLinksDlg>(pParent, pMgr, bHTML));
1610     if (p)
1611         xLinkDlg->SetActLink(p);
1612     return VclPtr<AbstractLinksDialog_Impl>::Create(std::move(xLinkDlg));
1613 }
1614
1615 std::shared_ptr<AbstractTabController> AbstractDialogFactory_Impl::CreateSvxFormatCellsDialog(weld::Window* pParent, const SfxItemSet* pAttr, const SdrModel& rModel)
1616 {
1617     return std::make_shared<CuiAsyncAbstractTabController_Impl>(std::make_unique<SvxFormatCellsDialog>(pParent, pAttr, rModel));
1618 }
1619
1620 VclPtr<SvxAbstractSplitTableDialog> AbstractDialogFactory_Impl::CreateSvxSplitTableDialog(weld::Window* pParent, bool bIsTableVertical, long nMaxVertical)
1621 {
1622     return VclPtr<SvxAbstractSplitTableDialog_Impl>::Create( std::make_shared<SvxSplitTableDlg>(pParent, bIsTableVertical, nMaxVertical, 99 ));
1623 }
1624
1625 std::shared_ptr<SvxAbstractNewTableDialog> AbstractDialogFactory_Impl::CreateSvxNewTableDialog(weld::Window* pParent)
1626 {
1627     return std::make_shared<SvxNewTableDialogWrapper>(pParent);
1628 }
1629
1630 VclPtr<VclAbstractDialog> AbstractDialogFactory_Impl::CreateOptionsDialog(weld::Window* pParent, const OUString& rExtensionId)
1631 {
1632     return VclPtr<CuiAbstractController_Impl>::Create(std::make_unique<OfaTreeOptionsDialog>(pParent, rExtensionId));
1633 }
1634
1635 VclPtr<SvxAbstractInsRowColDlg> AbstractDialogFactory_Impl::CreateSvxInsRowColDlg(weld::Window* pParent, bool bCol, const OString& rHelpId)
1636 {
1637     return VclPtr<SvxInsRowColDlg>::Create(pParent, bCol, rHelpId);
1638 }
1639
1640 VclPtr<AbstractPasswordToOpenModifyDialog> AbstractDialogFactory_Impl::CreatePasswordToOpenModifyDialog(
1641     weld::Window * pParent, sal_uInt16 nMaxPasswdLen, bool bIsPasswordToModify)
1642 {
1643     return VclPtr<AbstractPasswordToOpenModifyDialog_Impl>::Create(std::make_unique<PasswordToOpenModifyDialog>(pParent, nMaxPasswdLen, bIsPasswordToModify));
1644 }
1645
1646 VclPtr<AbstractScreenshotAnnotationDlg> AbstractDialogFactory_Impl::CreateScreenshotAnnotationDlg(weld::Dialog& rParentDialog)
1647 {
1648     return VclPtr<AbstractScreenshotAnnotationDlg_Impl>::Create(std::make_unique<ScreenshotAnnotationDlg>(rParentDialog));
1649 }
1650
1651 VclPtr<AbstractSignatureLineDialog> AbstractDialogFactory_Impl::CreateSignatureLineDialog(
1652     weld::Window* pParent, const Reference<XModel> xModel, bool bEditExisting)
1653 {
1654     return VclPtr<AbstractSignatureLineDialog_Impl>::Create(
1655         std::make_unique<SignatureLineDialog>(pParent, xModel, bEditExisting));
1656 }
1657
1658 VclPtr<AbstractSignSignatureLineDialog>
1659 AbstractDialogFactory_Impl::CreateSignSignatureLineDialog(weld::Window* pParent,
1660                                                           const Reference<XModel> xModel)
1661 {
1662     return VclPtr<AbstractSignSignatureLineDialog_Impl>::Create(
1663         std::make_unique<SignSignatureLineDialog>(pParent, xModel));
1664 }
1665
1666 VclPtr<AbstractQrCodeGenDialog> AbstractDialogFactory_Impl::CreateQrCodeGenDialog(
1667     weld::Window* pParent, const Reference<XModel> xModel, bool bEditExisting)
1668 {
1669     return VclPtr<AbstractQrCodeGenDialog_Impl>::Create(
1670         std::make_unique<QrCodeGenDialog>(pParent, xModel, bEditExisting));
1671 }
1672
1673 VclPtr<AbstractTipOfTheDayDialog>
1674 AbstractDialogFactory_Impl::CreateTipOfTheDayDialog(weld::Window* pParent)
1675 {
1676     return VclPtr<AbstractTipOfTheDayDialog_Impl>::Create(std::make_unique<TipOfTheDayDialog>(pParent));
1677 }
1678
1679 VclPtr<AbstractDiagramDialog>
1680 AbstractDialogFactory_Impl::CreateDiagramDialog(weld::Window* pParent, std::shared_ptr<DiagramDataInterface> pDiagramData)
1681 {
1682     return VclPtr<AbstractDiagramDialog_Impl>::Create(
1683         std::make_unique<DiagramDialog>(pParent, pDiagramData));
1684 }
1685
1686 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */